diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000000..e69de29bb2 diff --git a/Dockerfile b/Dockerfile new file mode 100755 index 0000000000..989c9abb2c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM mcr.microsoft.com/dotnet/sdk:7.0 + +RUN apt-get update \ + && apt-get -y upgrade \ + && apt-get -y install python3 python3-pip python3-dev ipython3 + +RUN python3 -m pip install --no-cache-dir notebook jupyterlab + +ARG NB_USER=fsdocs-user +ARG NB_UID=1000 +ENV USER ${NB_USER} +ENV NB_UID ${NB_UID} +ENV HOME /home/${NB_USER} + +RUN adduser --disabled-password \ + --gecos "Default user" \ + --uid ${NB_UID} \ + ${NB_USER} + +COPY . ${HOME} +USER root +RUN chown -R ${NB_UID} ${HOME} +USER ${NB_USER} + +ENV PATH="${PATH}:$HOME/.dotnet/tools/" + +RUN dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.410202 + +RUN dotnet-interactive jupyter install diff --git a/NuGet.config b/NuGet.config new file mode 100755 index 0000000000..cf1ace51a2 --- /dev/null +++ b/NuGet.config @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/builder-caches.html b/builder-caches.html new file mode 100644 index 0000000000..206be66c50 --- /dev/null +++ b/builder-caches.html @@ -0,0 +1,511 @@ + + + + + + + + + + + + + + + + + + IncrementalBuilder caches | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

IncrementalBuilder SyntaxTree cache

+

Incremental builder keeps in a cache at most one ParsedInput for each file it parses. +This behavior can be toggled with useSyntaxTreeCache parameter.

+

Memory impact of this feature can be in range of tens of MB for larger solutions. This can be inspected in memory profilng tools by searching for ParsedInput instances. +When partial checking is enabled, implementation files backed by signature will not be parsed or cached, as expected.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/changing-the-ast.html b/changing-the-ast.html new file mode 100644 index 0000000000..639ab5c124 --- /dev/null +++ b/changing-the-ast.html @@ -0,0 +1,575 @@ + + + + + + + + + + + + + + + + + + Changing the AST | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Changing the AST

+

Making changes to the AST is a common task when working on new F# compiler features or when working on developer tooling.
+This document describes the process of making changes to the AST.

+

The easiest way to modify the AST is to start with the type definitions in SyntaxTree.fsi and SyntaxTree.fs and then let the compiler guide you to the places where you need to make changes. +Let's look at an example: We want to extend the AST to include the range of the / symbol in a SynRationalConst.Rational.

+

There are two solutions to choose from: +- Add a new field to the Rational union case +- Add a dedicated trivia type to the union case which contains the new range and maybe move the existing ranges to the trivia type as well

+

The pros of introducing a dedicated trivia type are: +- Having the additional information in a separate structure allows it to grow more easily over time. Adding new information to an existing trivia type won't disrupt most FCS consumers.
+- It is clear that it is information that is not relevant for the compilation.

+

The cons are: +- It can be a bit excessive to introduce for a single field. +- The existing AST node might already contain fields that are historically more suited for trivia, but predate the SyntaxTrivia module.

+

In this example, we'll go with the first solution and add a new field named divRange to the Rational union case as it felt a bit excessive to introduce a new trivia type for a single field.
+But these are the type of decisions that need to be made when changing the AST.

+
type SynRationalConst =
+
+    // ...
+
+    | Rational of
+        numerator: int32 *
+        numeratorRange: range *
+        divRange: range *   // our new field
+        denominator: int32 *
+        denominatorRange: range *
+        range: range
+    
+    // ...
+
+

After modifying SyntaxTree.fsi and SyntaxTree.fs, the compiler will report erros in pars.fsy. If not, the fsy file wasn't processed by the compilation. In this case, a rebuild of FSharp.Compiler.Service.fsproj should help.
+pars.fsy is the parser specification of F#, a list of rules that describe how to parse F# code. Don't be scared by the size of the file or the unfamiliar content. +It's easier than it looks. +The F# compiler uses a parser generator called fsyacc to generate the parser from the specification in pars.fsy. +Let's look at the most relevant syntax parts of a .fsy file:

+
rationalConstant:
+  | INT32 INFIX_STAR_DIV_MOD_OP INT32
+    { if $2 <> "/" then reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnexpectedOperatorForUnitOfMeasure())
+      if fst $3 = 0 then reportParseErrorAt (rhs parseState 3) (FSComp.SR.parsIllegalDenominatorForMeasureExponent())
+      if (snd $1) || (snd $3) then errorR(Error(FSComp.SR.lexOutsideThirtyTwoBitSigned(), lhs parseState))
+      SynRationalConst.Rational(fst $1, rhs parseState 1, fst $3, rhs parseState 3, lhs parseState) }
+  | // ...
+
+

The first line is the name of the rule, rationalConstant in this case. It's a so called non-terminal symbol in contrast to a terminal symbol like INT32 or INFIX_STAR_DIV_MOD_OP. The individual cases of the rule are separated by |, they are called productions.

+

By now, you should be able to see the similarities between an fsyacc rule and the pattern matching you know from F#.
+The code between the curly braces is the code that gets executed when the rule is matched and is real F# code. After compilation, it ends up in +.\artifacts\obj\FSharp.Compiler.Service\Debug\netstandard2.0\pars.fs, generated by fsyacc.

+

The first three lines do error checking and report errors if the input is invalid. +Then the code calls the Rational constructor of SynRationalConst and passes some values to it. Here we need to make changes to adjust the parser to our modified type definition.
+The values or symbols that matched the rule are available as $1, $2, $3 etc. in the code. As you can see, $1 is a tuple, consisting of the parsed number and a boolean indicating whether the number is a valid 32 bit signed integer or not. +The code is executed in the context of the parser, so you can use the parseState variable, an instance of IParseState, to access the current state of the parser. There are helper functions defined in ParseHelpers.fs that make it easier to work with it.
+rhs parseState 1 returns the range of the first symbol that matched the rule, here INT32. So, it returns the range of 23 in 23/42.
+rhs is short for right hand side.
+Another helper is rhs2. Using it like rhs2 parseState 2 3 for example, returns the range covering the symbols from the second to the third symbol that matched the rule. Given 23/42, it would return the range of /42.
+lhs parseState returns the range of the whole rule, 23/42 in our example. +When parser recovery is of concern for a rule, it's preferred to use rhs2 over lhs.

+

Circling back to our original example of adding a new field to SynRationalConst, we need to add a new parameter to the call of the Rational constructor. We want to pass the range of the / symbol, so we need to add rhs parseState 2 as the third parameter to the constructor call:

+
SynRationalConst.Rational(fst $1, rhs parseState 1, rhs parseState 2, fst $3, rhs parseState 3, lhs parseState)
+
+

That's it. Adjusting the other constructor calls of Rational in pars.fsy should be enough to have a working parser again which returns the modified AST.
+While fixing the remaining compiler errors outside of pars.fsy, it's a good idea to use named access to the fields of the SynRationalConst.Rational union case instead of positional access. This way, the compilation won't fail if aditional fields are added to the union case in the future.
+After a successful compilation, you can run the parser tests in SyntaxTreeTests.fs to verify that everything works as expected.
+It's likely that you'll need to update the baseline files as decribed in SyntaxTreeTests.fs.

+ +
type SynRationalConst = | Rational of numerator: int32 * numeratorRange: obj * divRange: obj * denominator: int32 * denominatorRange: obj * range: obj
+
Multiple items
val int32: value: 'T -> int32 (requires member op_Explicit)

--------------------
type int32 = System.Int32

--------------------
type int32<'Measure> = int<'Measure>
+
val fst: tuple: ('T1 * 'T2) -> 'T1
+
val snd: tuple: ('T1 * 'T2) -> 'T2
+
union case Result.Error: ErrorValue: 'TError -> Result<'T,'TError>
+
union case SynRationalConst.Rational: numerator: int32 * numeratorRange: obj * divRange: obj * denominator: int32 * denominatorRange: obj * range: obj -> SynRationalConst
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/coding-standards.html b/coding-standards.html new file mode 100644 index 0000000000..5efb37a41e --- /dev/null +++ b/coding-standards.html @@ -0,0 +1,721 @@ + + + + + + + + + + + + + + + + + + Coding standards | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Coding standards and idioms

+

The F# compiler code base is slowly being updated to better coding standards. There is a long way to go.

+

The future work includes

+ +

Abbreviations

+

The compiler codebase uses various abbreviations. Here are some of the most common ones.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Abbreviation

Meaning

ad

Accessor domain, meaning the permissions the accessing code has to access other constructs

amap

Assembly map, saying how to map IL references to F# CCUs

arg

Argument (parameter)

argty

Argument (parameter) type

arginfo

Argument (parameter) metadata

ccu

Reference to an F# compilation unit = an F# DLL (possibly including the DLL being compiled)

celem

Custom attribute element

cenv

Compilation environment. Means different things in different contexts, but usually a parameter for a single compilation state object being passed through a set of related functions in a single phase. The compilation state is often mutable.

cpath

Compilation path, meaning A.B.C for the overall names containing a type or module definition

css

Constraint solver state.

denv

Display Environment. Parameters guiding the formatting of types

einfo

An info object for an event (whether a .NET event, an F# event or a provided event)

e

Expression

env

Environment. Means different things in different contexts, but usually immutable state being passed and adjusted through a set of related functions in a single phase.

finfo

An info object for a field (whether a .NET field or a provided field)

fref

A reference to an ILFieldRef Abstract IL node for a field reference. Would normally be modernized to ilFieldRef

g

The TcGlobals value

id

Identifier

lid

Long Identifier

m

A source code range marker

mimpl

IL interface method implementation

minfo

An info object for a method (whether a .NET method, an F# method or a provided method)

mk

Means make in old fashioned F#/OCaml coding style

modul

a Typed Tree structure for a namespace or F# module

pat

Pattern, a syntactic AST node representing part of a pattern in a pattern match

pinfo

An info object for a property (whether a .NET property, an F# property or a provided property)

rfref

Record or class field reference, a reference to a Typed Tree node for a record or class field

scoref

The scope of a reference in IL metadata, either assembly, .netmodule or local

sp

Sequence points or debug points

spat

Simple Pattern, a syntactic AST node representing part of a pattern in a pattern match

tau

A type with the "forall" nodes stripped off (i.e. the nodes which represent generic type parameters). Comes from the notation 𝛕 used in type theory

tcref

Type constructor reference (an EntityRef)

tinst

Type instantiation

tpenv

Type parameter environment, tracks the type parameters in scope during type checking

ty (not: typ)

Type, usually a Typed Tree type

tys (not: typs)

List of types, usually Typed Tree types

typar

Type Parameter

tyvar

Type Variable, usually referring to an IL type variable, the compiled form of an F# type parameter

ucref

Union case reference, a reference to a Typed Tree node for a union case

vref

Value reference, a reference to a Typed Tree node for a value

+ + + + + + + + + + + + + + + + + + + + + + + + + + +

Phase Abbreviation

Meaning

Syn

Abstract Syntax Tree

Tc

Type-checker

IL

Abstract IL = F# representation of .NET IL

Ilx

Extended Abstract IL = .NET IL plus a couple of contructs that get erased

+ + + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/compiler-startup-performance.html b/compiler-startup-performance.html new file mode 100644 index 0000000000..40da3143e0 --- /dev/null +++ b/compiler-startup-performance.html @@ -0,0 +1,516 @@ + + + + + + + + + + + + + + + + + + Startup Performance | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Startup Performance

+

Compiler startup performance is a key factor affecting happiness of F# users. If the compiler took 10sec to start up, then far fewer people would use F#.

+

On all platforms, the following factors affect startup performance:

+ +

On Windows, the compiler delivered with Visual Studio currently uses NGEN to pre-compile fsc, fsi, and some assemblies used in Visual Studio tooling. For .NET Core, the CrossGen tool is used to accomplish the same thing. Visual Studio will use delayed NGEN, meaning that it does not run NGEN on every binary up front. This means that F# compilation through Visual Studio may be slow for a few times before it gets NGENed.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/content/fsdocs-default.css b/content/fsdocs-default.css new file mode 100755 index 0000000000..77a82c816c --- /dev/null +++ b/content/fsdocs-default.css @@ -0,0 +1,1230 @@ +:root { + --monospace-font: "Fira Code", monospace; + --system-font: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif; + --heading-font-family: var(--system-font); + + --spacing-50: 4px; + --spacing-100: 8px; + --spacing-200: 12px; + --spacing-300: 16px; + --spacing-400: 24px; + --spacing-500: 32px; + --spacing-600: 48px; + --spacing-700: 64px; + --spacing-800: 96px; + --spacing-900: 128px; + --spacing-950: 192px; + + --font-50: 12x; + --font-100: 14px; + --font-200: 16px; + --font-300: 18px; + --font-400: 20px; + --font-500: 24px; + --font-600: 30px; + --font-700: 36px; + --font-800: 48px; + --font-900: 60px; + --font-950: 72px; + + --line-height: 1.5; + --heading-line-height: 1.25; + --radius: 6px; + + --container-sm: 768px; + --container-md: 960px; + --container-lg: 1024px; + --container-xl: 1200px; + --container-xxl: 1400px; + --container-xxxl: 1800px; + --main-menu-width: 260px; + --page-menu-width: var(--main-menu-width); + --header-height: 60px; + --body-grid-template-columns: var(--main-menu-width) minmax(0, 1fr); + --body-grid-template-columns-xl: var(--main-menu-width) minmax(0, 1fr) var(--page-menu-width); + --main-menu-grid-row: 2; + --main-menu-grid-column: 1; + --main-grid-row: 2; + --main-grid-column: 2; + --dialog-width: 500px; + + /* light theme */ + --primary: #1e8bc3; + --background: #f5f5f6; + --text-color: #020202; + --text-hover: #282828; + --heading-color: #2e293a; + --code-background: #ffffff; + --code-color: #1a4b0b; + --header-background: #f9fbfc; + --header-border: #e8ecf1; + --header-link-color: var(--text-color); + --mobile-menu-background: var(--header-background); + --menu-color: var(--text-color); + --menu-item-hover-background: #eff0f1; + --menu-item-hover-color: var(--menu-color); + --doc-tip-background: #F7F7F7; + --link-color: #4871f7; + --link-hover: #91aafa; + --search-background: rgb(229, 231, 235); + --nav-category: rgb(156, 163, 175); + --scrollbar-track-background: #424242; + --scrollbar-track-border: #4A4A4A; + --scrollbar-thumb-background: #686868; + --shadow-color: hsla(0, 0%, 0%, .1); + --main-shadow-color: hsla(0, 0%, 0%, .025); + --aside-background: var(--header-background); + --blockquote-bacground-color: var(--header-background); + --blockquote-color: var(--text-color); + --on-this-page-color: var(--menu-color); + --page-menu-background-color: var(--header-background); + --page-menu-background-border-color: var(--header-border); + --page-menu-background-hover-border-color: var(--text-color); + --nav-item-border-color: var(--header-border); + --nav-item-active-border-color: var(--text-color); + --dialog-background-color: var(--header-background); + --dialog-empty-color: var(--nav-category); + --dialog-icon-color: var(--text-color); + --dialog-link-color: var(--link-color); + --dialog-link-hover-color: var(--header-background); + --dialog-link-hover-background-color: var(--link-hover); + --code-fence-border-color: transparent; + + --header-brand-text-transform: none; + + --code-strings-color: #0093A1; + --code-printf-color: #6B2FBA; + --code-escaped-color: #EA8675; + --code-identifiers-color: #6B2FBA; + --code-module-color: #009999; + --code-reference-color: #4974D1; + --code-value-color: #1B6600; + --code-interface-color: #43AEC6; + --code-typearg-color: #43AEC6; + --code-disposable-color: #43AEC6; + --code-property-color: #43AEC6; + --code-punctuation-color: #43AEC6; + --code-punctuation2-color: var(--text-color); + --code-function-color: #6B2FBA; + --code-function2-color: #6B2FBA; + --code-activepattern-color: #4ec9b0; + --code-unioncase-color: #4ec9b0; + --code-enumeration-color: #8C6C41; + --code-keywords-color: #0F54D6; + --code-comment-color: #707070; + --code-operators-color: #0F54D6; + --code-numbers-color: #009999; + --code-linenumbers-color: #80b0b0; + --code-mutable-color: #1b6600; + --code-inactive-color: #808080; + --code-preprocessor-color: #af75c1; + --code-fsioutput-color: #808080; + --code-tooltip-color: #d1d1d1; +} + +/* dark theme */ + +[data-theme=dark] { + --primary: #81cfe0; + --background: rgb(20, 21, 26); + --text-color: #F7F7F7; + --text-hover: #FFF; + --heading-color: rgb(229, 231, 235); + --code-background: #28282D; + --code-color: #f5f5f6; + --header-background: #0c1318; + --header-border: #9b9b9b; + --menu-item-hover-background: #2c2624; + --doc-tip-background: #2e293a; + --link-color: #c5eff7; + --search-background: #020202; + --nav-category: rgb(207, 211, 215); + --code-strings-color: #86b4b9; + --code-printf-color: #6B2FBA; + --code-escaped-color: #EA8675; + --code-identifiers-color: #d1b3f5; + --code-module-color: #15e1e1; + --code-reference-color: #40fddd; + --code-value-color: #ffb4e9; + --code-interface-color: #43AEC6; + --code-typearg-color: #43AEC6; + --code-disposable-color: #6dd6f1; + --code-property-color: #6acfe7; + --code-punctuation-color: #43AEC6; + --code-punctuation2-color: var(--text-color); + --code-function-color: #6B2FBA; + --code-function2-color: #cbda9d; + --code-activepattern-color: #4ec9b0; + --code-unioncase-color: #4ec9b0; + --code-enumeration-color: #8C6C41; + --code-keywords-color: #a7c2f8; + --code-comment-color: #84d16e; + --code-operators-color: #b4c6ee; + --code-numbers-color: #009999; + --code-linenumbers-color: #80b0b0; + --code-mutable-color: #1b6600; + --code-inactive-color: #808080; + --code-preprocessor-color: #af75c1; + --code-fsioutput-color: #808080; + --code-tooltip-color: #d1d1d1; +} + +/* CSS Reset, source: https://www.joshwcomeau.com/css/custom-css-reset/ */ +*, *::before, *::after { + box-sizing: border-box; +} + +* { + margin: 0; +} + +html { + overflow-y: hidden; +} + +body { + line-height: 1.5; + -webkit-font-smoothing: antialiased; +} + +picture, video, canvas, svg { + display: block; + max-width: 100%; +} + +input, button, textarea, select { + font: inherit; +} + +p, h1, h2, h3, h4, h5, h6 { + overflow-wrap: break-word; +} + +/* Main layout */ +body { + font-family: var(--system-font); + background-color: var(--background); + color: var(--text-color); + line-height: var(--line-height); + scroll-padding-top: var(--header-height); + scroll-behavior: smooth; +} + +header { + background-color: var(--header-background); + padding: var(--spacing-300); + height: var(--header-height); + display: flex; + align-items: center; + justify-content: space-between; + position: sticky; + top: 0; + z-index: 100; + box-shadow: 0 1px 1px var(--shadow-color); + + & .start { + display: flex; + align-items: center; + + & #menu-toggle { + position: relative; + height: var(--spacing-500); + width: var(--spacing-500); + border: 1px solid var(--header-border); + border-radius: var(--radius); + box-shadow: 0 1px 1px var(--shadow-color); + + & .icon { + top: 4px; + left: 4px; + width: calc(var(--spacing-500) - 4px); + height: calc(var(--spacing-500) - 4px); + position: absolute; + color: var(--header-link-color); + + &.open { + display: none; + } + } + + & input[type=checkbox] { + position: absolute; + width: 100%; + height: 100%; + left: 0; + top: 0; + appearance: none; + cursor: pointer; + } + + & .menu { + visibility: hidden; + height: 0; + opacity: 0; + width: 100%; + transition: all 0.2s ease-in-out; + position: fixed; + top: var(--header-height); + left: 0; + background-color: var(--mobile-menu-background); + list-style: none; + padding: var(--spacing-300); + overflow-y: auto; + } + + & input:checked + .menu { + visibility: visible; + opacity: 1; + height: calc(100vh - var(--header-height)); + } + + &:has(input:checked) { + .icon.open { + display: block; + } + + .icon.closed { + display: none; + } + } + } + + > a { + display: flex; + justify-content: center; + align-items: center; + text-decoration: none; + color: var(--header-link-color); + } + + & img { + margin: 0 var(--spacing-200); + border-radius: var(--radius); + height: calc(var(--spacing-500) - 2px); + } + + & strong { + line-height: var(--spacing-500); + font-size: var(--font-200); + display: block; + text-transform: var(--header-brand-text-transform); + font-weight: 500; + } + } + + & .end { + display: flex; + align-items: center; + + & a { + display: none; + color: var(--header-link-color); + } + + & > .themeToggle, & > .search { + cursor: pointer; + height: var(--spacing-500); + align-items: center; + margin: 0 var(--spacing-100); + } + + & > .search { + display: flex; + color: var(--header-link-color); + } + } +} + +aside { + display: none; +} + +main { + height: calc(100vh - var(--header-height)); +} + +#content { + padding: var(--spacing-300); + + > *:first-child { + margin-top: 0; + } +} + +#fsdocs-page-menu { + display: none; + padding: var(--spacing-300); + background-color: var(--page-menu-background-color); + border-left: 1px solid var(--page-menu-background-border-color); + + &:has(.empty) { + display: none; + } + + > #on-this-page { + font-size: var(--font-100); + line-height: 1.5; + color: var(--on-this-page-color); + font-weight: 500; + margin: 0 0 var(--spacing-50); + } + + & ul { + list-style: none; + padding: 0; + margin: 0; + + & li { + border-left: 1px solid var(--header-border); + margin: 0; + + &:hover, &:focus { + border-color: var(--page-menu-background-hover-border-color); + } + + & a { + color: var(--menu-color); + text-decoration: none; + padding: var(--spacing-50) var(--spacing-100); + display: block; + overflow-x: hidden; + text-overflow: ellipsis; + } + + &.level-3 { + padding-left: var(--spacing-100); + } + + &.level-4 { + padding-left: var(--spacing-300); + } + } + } +} + +/* menu items */ +.menu { + padding: 0; + + & li { + list-style: none; + margin: 0; + } + + .nav-header { + margin-top: var(--spacing-300); + text-transform: uppercase; + font-size: var(--font-200); + font-weight: 500; + color: var(--menu-color); + } +} + +.nav-header:first-child { + margin-top: 0; +} + +.nav-item { + border-left: 1px solid var(--nav-item-border-color); + + & a { + color: var(--menu-color); + text-decoration: none; + font-size: var(--font-200); + padding: var(--spacing-100); + display: block; + overflow-x: hidden; + text-overflow: ellipsis; + + &:hover { + background-color: var(--menu-item-hover-background); + color: var(--menu-item-hover-color); + } + } + + &:hover, &.active { + border-color: var(--nav-item-active-border-color); + } + + &.active { + font-weight: 600; + } +} + +@media screen and (min-width: 768px) { + #menu-toggle { + display: none; + } + + body { + display: grid; + grid-template-rows: var(--header-height) minmax(0, 1fr); + grid-template-columns:var(--body-grid-template-columns); + gap: 0; + } + + header { + border-bottom: 1px solid var(--header-border); + grid-row: 1; + grid-column: span 2; + box-shadow: none; + + & .end { + > a { + display: flex; + align-items: center; + text-decoration: none; + + &:hover { + color: var(--link-hover); + } + } + } + } + + aside, main { + height: calc(100vh - var(--header-height)); + } + + aside { + position: sticky; + top: var(--header-height); + } + + #fsdocs-main-menu { + display: block; + padding: var(--spacing-300) var(--spacing-500); + background-color: var(--aside-background); + width: var(--main-menu-width); + border-right: 1px solid var(--header-border); + grid-row: var(--main-menu-grid-row); + grid-column: var(--main-menu-grid-column); + overflow-y: auto; + } + + main { + grid-row: var(--main-grid-row); + grid-column: var(--main-grid-column); + box-shadow: inset 1px 1px var(--main-shadow-color); + border-radius: 0; + } + + #content { + padding-left: var(--spacing-300); + padding-right: var(--spacing-300); + } +} + +@media screen and (min-width: 768px) { + #content { + max-width: calc(100vw - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + margin: 0 auto; + } +} + +@media screen and (min-width: 960px) { + #content { + max-width: calc(var(--container-md) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1024px) { + #content { + max-width: calc(var(--container-lg) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1200px) { + body { + grid-template-columns: var(--body-grid-template-columns-xl); + + &.api-docs { + grid-template-columns: var(--body-grid-template-columns); + + #content { + max-width: calc(var(--container-xl) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } + + #fsdocs-page-menu { + display: none; + } + } + } + + header { + grid-column: span 3; + } + + #fsdocs-page-menu { + grid-column: 3; + display: block; + } + + #content { + max-width: calc(var(--container-xl) - var(--main-menu-width) - var(--page-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1400px) { + body { + &.api-docs, &:has(#fsdocs-page-menu .empty) { + #content { + max-width: calc(var(--container-xxl) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } + } + } + + #content { + max-width: calc(var(--container-xxl) - var(--main-menu-width) - var(--page-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1800px) { + body { + &.api-docs, &:has(#fsdocs-page-menu .empty) { + #content { + max-width: calc(var(--container-xxxl) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } + } + } + + #content { + max-width: calc(var(--container-xxxl) - var(--main-menu-width) - var(--page-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +/* Headings */ +h1, h2, h3, h4, h5, h6 { + font-family: var(--heading-font-family); +} + +h1 a, h2 a, h3 a, h4 a, h5 a, h6 a { + color: var(--heading-color); + text-decoration: none; +} + +h1 { + font-size: var(--font-600); + line-height: var(--heading-line-height); + margin-bottom: var(--spacing-400); + margin-top: var(--spacing-50); +} + +h2 { + font-size: var(--font-500); + line-height: var(--heading-line-height); + margin-top: var(--spacing-400); + margin-bottom: var(--spacing-300); +} + +h3 { + font-size: var(--font-400); + line-height: var(--heading-line-height); + margin-top: var(--spacing-300); + margin-bottom: var(--spacing-200); +} + +h4 { + font-weight: bold; +} + +h4, h5, h6 { + font-size: var(--font-300); + margin-top: var(--spacing-200); + margin-bottom: var(--spacing-200); +} + +@media screen and (min-width: 768px) { + h1 { + font-size: var(--font-800); + margin-bottom: var(--spacing-400); + line-height: var(--heading-line-height); + } + + h2 { + font-size: var(--font-700); + margin-top: var(--spacing-500); + margin-bottom: var(--spacing-400); + } + + h3 { + font-size: var(--font-600); + margin-top: var(--spacing-500); + margin-bottom: var(--spacing-200); + } + + h4 { + font-size: var(--font-500); + } + + h4, h5, h6 { + margin-top: var(--spacing-300); + } +} + +/* Common items */ +a { + color: var(--link-color); +} + +p { + line-height: 1.8; + margin-top: var(--spacing-300); +} + +ol, ul { + padding-left: var(--spacing-400); +} + +ol li, ul li { + margin: var(--spacing-100) 0; +} + +img { + max-width: 100%; +} + +#content > table { + margin: var(--spacing-300) 0; +} + +blockquote { + border-left: var(--spacing-50) solid var(--primary); + margin: var(--spacing-200) 0; + margin-left: var(--spacing-200); + padding: var(--spacing-100) var(--spacing-300); + background-color: var(--blockquote-bacground-color); + color: var(--blockquote-color); + + > p { + margin: 0; + padding: 0; + } +} + +@media screen and (min-width: 768px) { + blockquote { + margin-left: var(--spacing-400); + } +} + +/* Code snippets */ + +/* reset browser style */ +pre { + margin: 0; + padding: 0; +} + +code, table.pre, pre { + background-color: var(--code-background); + color: var(--code-color); + font-family: var(--monospace-font); + font-variant-ligatures: none; + font-size: var(--font-200); +} + +table.pre, #content > pre.fssnip { + border: 1px solid var(--code-fence-border-color); +} + +table.pre, pre.fssnip.highlighted { + margin: var(--spacing-300) 0; + padding: var(--spacing-200); +} + +table.pre .snippet pre.fssnip { + padding: 0; + margin: 0; +} + +p > code, li > code { + padding: 2px var(--spacing-50); +} + +table.pre, pre > code { + display: block; +} + +pre.fssnip > code { + max-width: initial; + margin-bottom: initial; +} + +/* avoid problems with transparent background colors */ +pre.fssnip.highlighted > code, table.pre .fssnip, table.pre .fssnip code { + background-color: transparent; +} + +/* Custom scrollbar styling */ +body, aside, #menu-toggle .menu, table.pre, code, +.fsdocs-entity-xmldoc > div > pre, div.fsdocs-summary > pre, +dialog ul, div.fsdocs-tip, .fsdocs-xmldoc > pre { + overflow-x: auto; + max-width: 100%; + + &::-webkit-scrollbar { + height: var(--spacing-100); + width: var(--spacing-100); + } + + &::-webkit-scrollbar-track { + background-color: var(--scrollbar-track-background); + border: 1px solid var(--scrollbar-track-border); + } + + &::-webkit-scrollbar-thumb { + background-color: var(--scrollbar-thumb-background); + } +} + +body, aside, #menu-toggle .menu, table.pre, code, +.fsdocs-entity-xmldoc > div > pre, div.fsdocs-summary > pre, +dialog ul, div.fsdocs-tip, .fsdocs-xmldoc > pre { + @media screen and (min-width: 768px) { + &::-webkit-scrollbar { + height: var(--spacing-200); + width: var(--spacing-300); + } + } +} + +table.pre, code, pre.fssnip { + border-radius: var(--radius); +} + +/* Code coloring */ +.param-name, +.return-name, +.param { + font-weight: 900; + font-size: var(--font-100); + font-family: var(--monospace-font); + font-variant-ligatures: none; +} + +.fssnip { + /* strings --- and stlyes for other string related formats */ + + & span.s { + color: var(--code-strings-color); + } + + /* printf formatters */ + + & span.pf { + color: var(--code-printf-color); + } + + /* escaped chars */ + + & span.e { + color: var(--code-escaped-color); + } + + /* identifiers --- and styles for more specific identifier types */ + + & span.id { + color: var(--code-identifiers-color);; + } + + /* module */ + + & span.m { + color: var(--code-module-color); + } + + /* reference type */ + + & span.rt { + color: var(--code-reference-color); + } + + /* value type */ + + & span.vt { + color: var(--code-value-color); + } + + /* interface */ + + & span.if { + color: var(--code-interface-color); + } + + /* type argument */ + + & span.ta { + color: var(--code-typearg-color); + } + + /* disposable */ + + & span.d { + color: var(--code-disposable-color); + } + + /* property */ + + & span.prop { + color: var(--code-property-color); + } + + /* punctuation */ + + & span.p { + color: var(--code-punctuation-color); + } + + & span.pn { + color: var(--code-punctuation2-color); + } + + /* function */ + + & span.f { + color: var(--code-function-color); + } + + & span.fn { + color: var(--code-function2-color); + } + + /* active pattern */ + + & span.pat { + color: var(--code-activepattern-color); + } + + /* union case */ + + & span.u { + color: var(--code-unioncase-color); + } + + /* enumeration */ + + & span.e { + color: var(--code-enumeration-color); + } + + /* keywords */ + + & span.k { + color: var(--code-keywords-color); + } + + /* comment */ + + & span.c { + color: var(--code-comment-color); + font-weight: 400; + font-style: italic; + } + + /* operators */ + + & span.o { + color: var(--code-operators-color); + } + + /* numbers */ + + & span.n { + color: var(--code-numbers-color); + } + + /* line number */ + + & span.l { + color: var(--code-linenumbers-color); + } + + /* mutable var or ref cell */ + + & span.v { + color: var(--code-mutable-color); + font-weight: bold; + } + + /* inactive code */ + + & span.inactive { + color: var(--code-inactive-color); + } + + /* preprocessor */ + + & span.prep { + color: var(--code-preprocessor-color); + } + + /* fsi output */ + + & span.fsi { + color: var(--code-fsioutput-color); + } +} + +/* tooltips */ +div.fsdocs-tip { + z-index: 1000; + display: none; + background-color: var(--doc-tip-background); + border-radius: var(--radius); + border: 1px solid var(--header-border); + padding: var(--spacing-200); + font-family: var(--monospace-font); + font-variant-ligatures: none; + color: var(--code-color); + box-shadow: 0 1px 1px var(--shadow-color); + + & code { + color: var(--code-color); + } +} + +span[onmouseout] { + cursor: pointer; +} + +/* API docs */ +#content > div > h2:first-child { + margin-top: 0; +} + +.fsdocs-xmldoc { + & pre { + overflow-x: auto; + } +} + +.table { + width: 100%; + table-layout: fixed; + + & thead tr td { + font-weight: bold; + padding: var(--spacing-400) 0; + } + + & tbody td { + border-top: 1px solid var(--header-border); + padding: var(--spacing-300) 0; + padding-right: var(--spacing-300); + + &:first-child a { + overflow-x: hidden; + text-overflow: ellipsis; + width: 100%; + display: block; + } + + &:last-child { + padding-right: 0; + } + } + + & thead tr td:first-child, & td.fsdocs-entity-name, & td.fsdocs-member-usage { + width: 25%; + + & p { + margin: 0; + } + } + + .fsdocs-entity-xmldoc { + > div { + display: flex; + flex-direction: row-reverse; + justify-content: flex-start; + align-items: center; + + & p.fsdocs-summary { + margin: 0; + flex-grow: 1; + } + + & pre { + margin-bottom: var(--spacing-200); + padding: var(--spacing-50); + flex-grow: 1; + overflow-x: auto; + } + } + } + + .fsdocs-member-xmldoc { + & summary { + list-style: none; + + > .fsdocs-summary { + display: flex; + align-items: center; + flex-direction: row-reverse; + + & p.fsdocs-summary { + margin: 0; + flex-grow: 1; + } + + & pre { + margin-bottom: var(--spacing-200); + padding: var(--spacing-50); + flex-grow: 1; + overflow-x: auto; + } + } + + &::after { + content: '▶'; + cursor: pointer; + } + } + + & details[open] summary { + margin-bottom: var(--spacing-200); + } + + & details[open] summary::after { + content: "▼"; + } + + .fsdocs-returns, .fsdocs-params { + margin: var(--spacing-200) 0; + + &:first-child { + margin-top: 0; + } + + &:last-child { + margin-bottom: 0; + } + } + + .fsdocs-return-name, .fsdocs-param-name { + font-weight: 500; + } + + /* hide the browser mark and display one after the summary */ + + & ::marker { + display: none; + } + + > div.fsdocs-summary { + display: flex; + flex-direction: row-reverse; + justify-content: space-between; + align-items: center; + + > p { + margin: 0; + } + } + } +} + +.fsdocs-source-link { + display: none; + padding: 0 var(--spacing-100); + color: var(--text-color); + cursor: pointer; + height: var(--font-500); + width: var(--font-500); + margin: 0 var(--spacing-50); + + &:hover { + color: var(--primary); + } +} + +@media screen and (min-width: 768px) { + .fsdocs-source-link { + display: block; + } +} + +/* Search */ +::backdrop { + background-color: #020202; + opacity: 0.5; +} + +dialog { + background-color: var(--dialog-background-color); + margin: var(--spacing-700) auto; + padding: var(--spacing-100); + border: none; + opacity: 0; + visibility: hidden; + transition: all 0.2s ease-in-out; + border-radius: var(--radius); + width: var(--dialog-width); + + &[open] { + opacity: 1; + visibility: visible; + } + + & input[type=search] { + margin: 0; + display: block; + width: 100%; + padding: var(--spacing-200); + outline: 1px solid var(--primary); + border-radius: var(--radius); + border: none; + + &::placeholder { + font-size: var(--font-400); + } + } + + .empty { + color: var(--dialog-empty-color); + text-align: center; + font-size: var(--font-100); + margin: var(--spacing-100); + margin-bottom: 0; + } + + & ul { + overflow-y: auto; + max-height: calc(50vh - var(--spacing-700) - var(--spacing-700)); + list-style: none; + padding: 0; + + & li { + margin: 0; + border-bottom: 1px solid var(--header-border); + + &:hover { + & a, & a iconify-icon { + background-color: var(--dialog-link-hover-background-color); + color: var(--dialog-link-hover-color); + } + } + + & a { + display: flex; + padding: var(--spacing-300); + overflow-x: hidden; + color: var(--dialog-link-color); + + & iconify-icon { + color: var(--dialog-icon-color); + width: 24px; + margin-right: var(--spacing-200); + } + } + } + } +} + +/* Variables don't seem to work on ::backdrop */ +[data-theme=dark] { + ::backdrop { + opacity: 0.75; + } +} \ No newline at end of file diff --git a/content/fsdocs-search.js b/content/fsdocs-search.js new file mode 100755 index 0000000000..9e4c21de2d --- /dev/null +++ b/content/fsdocs-search.js @@ -0,0 +1,126 @@ +import Fuse from "https://esm.sh/fuse.js@7.0.0"; + +const searchBtn = document.querySelector("#search-btn"); + +function hideSearchBtn() { + // Hide search icon if we can't search in the first place. + searchBtn.style.display = 'none'; +} + +function debounce(mainFunction, delay) { + // Declare a variable called 'timer' to store the timer ID + let timer; + + // Return an anonymous function that takes in any number of arguments + return function (...args) { + // Clear the previous timer to prevent the execution of 'mainFunction' + clearTimeout(timer); + + // Set a new timer that will execute 'mainFunction' after the specified delay + timer = setTimeout(() => { + mainFunction(...args); + }, delay); + }; +} + +const root = document.documentElement.getAttribute("data-root"); +if (root && searchBtn) { + let fuse = null; + const searchIndexUrl = `${root}/index.json`; + fetch(searchIndexUrl, {}) + .then(response => response.json()) + .then(index => { + fuse = new Fuse(index, { + includeScore: true, + keys: ['uri', 'title', 'content', 'headings'], + includeMatches: true, + limit: 20, + ignoreLocation: true, + threshold: 0.6, + minMatchCharLength: 2, + ignoreFieldNorm: true, + shouldSort: true + }); + }) + .catch(() => { + hideSearchBtn(); + }) + + const searchDialog = document.querySelector("dialog"); + const empty = document.querySelector("dialog .empty"); + const resultsElement = document.querySelector("dialog ul"); + const searchBox = document.querySelector("dialog input[type=search]"); + + searchBtn.addEventListener("click", () => { + searchDialog.showModal(); + }) + + searchDialog.addEventListener("click", ev => { + if (ev.target.tagName === "DIALOG") { + searchBox.value = ''; + searchDialog.close() + } + }) + + function searchAux(searchTerm) { + if (!fuse) return; + + const results = fuse.search(searchTerm); + if (results.length === 0) { + clearResults(); + empty.textContent = "No results were found"; + } else { + if (location.hostname === 'localhost'){ + console.table(results); + } + + empty.style.display = 'none'; + const newResultNodes = + results + .map(result => { + const item = result.item; + const li = document.createElement("li"); + const a = document.createElement("a"); + a.setAttribute("href", item.uri); + const icon = document.createElement("iconify-icon"); + icon.setAttribute("width", "24"); + icon.setAttribute("height", "24"); + icon.setAttribute("icon", item.type === "content" ? "iconoir:page" : "bxs:file-doc") + a.append(icon, item.title); + li.appendChild(a); + return li; + }); + resultsElement.replaceChildren(...newResultNodes); + } + } + + const search = debounce(searchAux, 250); + + function clearResults() { + empty.style.display = 'block'; + resultsElement.replaceChildren(); + } + + searchBox.addEventListener('keyup', ev => { + ev.stopPropagation(); + const searchTerm = ev.target.value; + if (!searchTerm) { + empty.textContent = "Type something to start searching."; + clearResults(); + } else { + search(searchTerm); + } + }); + + window.addEventListener('keyup', ev => { + if (ev.key === 'Escape' && searchDialog.open) { + searchDialog.close(); + } + + if (ev.key === '/' && !searchDialog.open) { + searchDialog.showModal(); + } + }) +} else { + hideSearchBtn(); +} diff --git a/content/fsdocs-theme-toggle.js b/content/fsdocs-theme-toggle.js new file mode 100755 index 0000000000..5254e3ad22 --- /dev/null +++ b/content/fsdocs-theme-toggle.js @@ -0,0 +1,41 @@ +import {LitElement, html, css} from 'https://cdn.jsdelivr.net/gh/lit/dist@3/core/lit-core.min.js'; + +const prefersDark = window.matchMedia("@media (prefers-color-scheme: dark)").matches; +let currentTheme = localStorage.getItem('theme') ?? (prefersDark ? 'dark' : 'light'); +if (currentTheme === 'dark') { + window.document.documentElement.setAttribute("data-theme", 'dark'); +} + +export class ThemeToggle extends LitElement { + static properties = { + _theme: {state: true, type: String}, + }; + + constructor() { + super(); + this._theme = currentTheme; + } + + static styles = css` + :host { + cursor: pointer; + box-sizing: border-box; + transform: translateY(3px); + } + `; + + changeTheme() { + this._theme = this._theme === 'light' ? 'dark' : 'light'; + localStorage.setItem('theme', this._theme); + window.document.documentElement.setAttribute("data-theme", this._theme); + } + + render() { + const icon = this._theme === 'light' ? 'basil:moon-solid' : 'basil:sun-solid'; + return html` + + `; + } +} + +customElements.define('fsdocs-theme-toggle', ThemeToggle); diff --git a/content/fsdocs-theme.css b/content/fsdocs-theme.css new file mode 100644 index 0000000000..78b11777ba --- /dev/null +++ b/content/fsdocs-theme.css @@ -0,0 +1,3 @@ +:root { + --main-menu-width: 300px; +} diff --git a/content/fsdocs-theme.js b/content/fsdocs-theme.js new file mode 100755 index 0000000000..9ea6b3f7d8 --- /dev/null +++ b/content/fsdocs-theme.js @@ -0,0 +1,28 @@ +// Automatically scroll to the active aside menu item. +const mainMenu = document.getElementById('fsdocs-main-menu'); +function scrollToActiveItem(activeItem) { + const halfMainMenuHeight = mainMenu.offsetHeight / 2 + if(activeItem.offsetTop > halfMainMenuHeight){ + mainMenu.scrollTop = (activeItem.offsetTop - halfMainMenuHeight) - (activeItem.offsetHeight / 2); + } +} + +const activeItem = document.querySelector("aside .nav-item.active"); +if (activeItem && mainMenu) { + scrollToActiveItem(activeItem); +} + +if(location.hash) { + const header = document.querySelector(`a[href='${location.hash}']`); + header.scrollIntoView({ behavior: 'instant'}); +} + +if(location.pathname.startsWith('/reference/')) { + // Scroll to API Reference header + const navHeaders = document.querySelectorAll(".nav-header"); + for (const navHeader of navHeaders) { + if (navHeader.textContent && navHeader.textContent.trim() === 'API Reference') { + scrollToActiveItem(navHeader); + } + } +} \ No newline at end of file diff --git a/content/fsdocs-tips.js b/content/fsdocs-tips.js new file mode 100755 index 0000000000..787e183f42 --- /dev/null +++ b/content/fsdocs-tips.js @@ -0,0 +1,59 @@ +let currentTip = null; +let currentTipElement = null; + +function hideTip(evt, name, unique) { + const el = document.getElementById(name); + el.style.display = "none"; + currentTip = null; +} + +function hideUsingEsc(e) { + hideTip(e, currentTipElement, currentTip); +} + +function showTip(evt, name, unique, owner) { + document.onkeydown = hideUsingEsc; + if (currentTip === unique) return; + currentTip = unique; + currentTipElement = name; + + const offset = 20; + let x = evt.clientX; + let y = evt.clientY + offset; + + const el = document.getElementById(name); + el.style.position = "absolute"; + el.style.display = "block"; + el.style.left = `${x}px`; + el.style.top = `${y}px`; + const maxWidth = document.documentElement.clientWidth - x - 16; + el.style.maxWidth = `${maxWidth}px`; + + const rect = el.getBoundingClientRect(); + // Move tooltip if it is out of sight + if(rect.bottom > window.innerHeight) { + y = y - el.clientHeight - offset; + el.style.top = `${y}px`; + } + + if (rect.right > window.innerWidth) { + x = y - el.clientWidth - offset; + el.style.left = `${x}px`; + const maxWidth = document.documentElement.clientWidth - x - 16; + el.style.maxWidth = `${maxWidth}px`; + } +} + +function Clipboard_CopyTo(value) { + const tempInput = document.createElement("input"); + tempInput.value = value; + document.body.appendChild(tempInput); + tempInput.select(); + document.execCommand("copy"); + document.body.removeChild(tempInput); +} + +window.showTip = showTip; +window.hideTip = hideTip; +// Used by API documentation +window.Clipboard_CopyTo = Clipboard_CopyTo; \ No newline at end of file diff --git a/content/img/github-pages-settings.png b/content/img/github-pages-settings.png new file mode 100755 index 0000000000..a7657705da Binary files /dev/null and b/content/img/github-pages-settings.png differ diff --git a/debug-emit.html b/debug-emit.html new file mode 100644 index 0000000000..7b91087bd1 --- /dev/null +++ b/debug-emit.html @@ -0,0 +1,1292 @@ + + + + + + + + + + + + + + + + + + Debug emit | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Debug emit

+

The F# compiler code base emits debug information and attributes. This article documents what we do, how it is implemented and the problem areas in our implementation.

+

There are mistakes and missing pieces to our debug information. Small improvements can make a major difference. Please help us fix mistakes and get things right.

+

The file tests\walkthroughs\DebugStepping\TheBigFileOfDebugStepping.fsx is crucial for testing the stepping experience for a range of constructs.

+

User experiences

+

Debugging information affects numerous user experiences:

+ +

Some experiences are un-implemented by F# including:

+ +

Emitted information

+

Emitted debug information includes:

+ +

We almost always now emit the Portable PDB format.

+

Design-time services

+

IDE tooling performs queries into the F# language service, notably:

+ +

Debugging and optimization

+

Nearly all optimizations are off when debug code is being generated.

+ +

Otherwise, what comes out of the type checker is pretty much what goes into IlxGen.fs.

+

Debug points

+

Terminology

+

We use the terms "sequence point" and "debug point" interchangeably. The word "sequence" has too many meanings in the F# compiler so in the actual code you'll see "DebugPoint" more often, though for abbreviations you may see spFoo or mFoo.

+

How breakpoints work (high level)

+

Breakpoints have two existences which must give matching behavior:

+ +

This means there is an invariant that ValidateBreakpointLocation and the emitted IL debug points correspond.

+
+

NOTE: The IL code can and does contain extra debug points that don't pass ValidateBreakpointLocation. It won't be possible to set a breakpoint for these, but they will appear in stepping.

+
+

Intended debug points based on syntax

+

The intended debug points for constructs are determined by syntax as follows. Processing depends on whether a construct is being processed as "control-flow" or not. This means at least one debug point will be placed, either over the whole expression or some of its parts.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Construct

Debug points

let x = leaf-expr in BODY-EXPR

Debug point over let x = leaf-expr.

let x = NON-LEAF-EXPR in BODY-EXPR

let f x = BODY-EXPR in BODY-EXPR

let rec f x = BODY-EXPR and g x = BODY-EXPR in BODY-EXPR

if guard-expr then THEN-EXPR

Debug point over if guard-expr then

if guard-expr then THEN-EXPR else ELSE-EXPR

Debug point over if .. then

match .. with ...

Debug point over match .. with

... -> TARGET-EXPR

... when WHEN-EXPR -> TARGET-EXPR

while .. do BODY-EXPR

Debug point over while .. do

for .. in collection-expr do BODY-EXPR

Debug points over for, in and collection-expr

try TRY-EXPR with .. -> HANDLER-EXPR

Debug points over try and with

try TRY-EXPR finally .. -> FINALLY-EXPR

Debug points try and finally

use x = leaf-expr in BODY-EXPR

Debug point over use x = leaf-expr.

use x = NON-LEAF-EXPR in BODY-EXPR

EXPR; EXPR

(fun .. -> BODY-EXPR)

Not a leaf, do not produce a debug point on outer expression, but include them on BODY-EXPR

{ new C(args) with member ... = BODY-EXPR }

Pipe EXPR1 &amp;&amp; EXPR2

Pipe EXPR1 &#124;&#124; EXPR2

Pipe EXPR1 &#124;> EXPR2

Pipe (EXPR1, EXPR2) &#124;&#124;> EXPR3

Pipe (EXPR1, EXPR2, EXPR3) &#124;&#124;&#124;> EXPR4

yield leaf-expr

Debug point over 'yield expr'

yield! leaf-expr

Debug point over 'yield! expr'

return leaf-expr

Debug point over 'return expr'

return! leaf-expr

Debug point over 'return! expr'

[ BODY ]

See notes below. If a computed list expression with yields (explicit or implicit) then process as control-flow. Otherwise treat as leaf

[| BODY |]

See notes below. If a computed list expression with yields (explicit or implicit) then process as control-flow. Otherwise treat as leaf

seq { BODY }

See notes below

builder { BODY }

See notes below

f expr, new C(args), constants or other leaf

Debug point when being processed as control-flow. The sub-expressions are processed as non-control-flow.

+ +

Intended debug points for let-bindings

+

Simple let bindings get debug points that extend over the let (if the thing is not a function and the implementation is a leaf expression):

+
let f () =
+    let x = 1 // debug point for whole of `let x = 1`
+    let f x = 1 // no debug point on `let f x =`, debug point on `1`
+    let x = if today then 1 else tomorrow // no debug point on `let x =`, debug point on `if today then` and `1` and `tomorrow`
+    let x = let y = 1 in y + y // no debug point on `let x =`, debug point on `let y = 1` and `y + y`
+    ...
+
+

Intended debug points for nested control-flow

+

Debug points are not generally emitted for constituent parts of non-leaf constructs, in particular function applications, e.g. consider:

+
let h1 x = g (f x)
+let h2 x = x |> f |> g
+
+

Here g (f x) gets one debug point covering the whole expression. The corresponding pipelining gets three debug points.

+

If however a nested expression is control-flow, then debug points start being emitted again e.g.

+
let h3 x = f (if today then 1 else 2)
+
+

Here debug points are at if today then and 1 and 2 and all of f (if today then 1 else 2)

+
+

NOTE: these debug points are overlapping. That's life.

+
+

Intended debug points for [...], [| ... |] code

+

The intended debug points for computed list and array expressions are the same as for the expressions inside the constructs. For example

+
let x = [ for i in 1 .. 10 do yield 1 ]
+
+

This will have debug points on for i in 1 .. 10 do and yield 1.

+

Intended debug points for seq { .. } and task { .. } code

+

The intended debug points for tasks is the same as for the expressions inside the constructs. For example

+
let f() = task { for i in 1 .. 10 do printfn "hello" }
+
+

This will have debug points on for i in 1 .. 10 do and printfn "hello".

+
+

NOTE: there are glitches, see further below

+
+

Intended debug points for other computation expressions

+

Other computation expressions such as async { .. } or builder { ... } get debug points as follows:

+ +

The computations are often "cold-start" anyway, leading to a two-phase debug problem.

+

The "step-into" and "step-over" behaviour for computation expressions is often buggy because it is performed with respect to the de-sugaring and inlining rather than the original source. +For example, a "step over" on a "while" with a non-inlined builder.While will step over the whole call, when the user expects it to step the loop. +One approach is to inline the builder.While method, and apply [<InlineIfLambda>] to the body function. This however has only limited success +as at some points inlining fails to fully flatten. Builders implemented with resumable code tend to be much better in this regards as +more complete inlining and code-flattening is applied.

+

Intended debug points for implicit constructors

+ +

e.g.

+
type C(args) =        
+    let x = 1+1         // debug point over `let x = 1+1` as the only side effect
+    let f x = x + 1
+    member _.P = x + f 4
+
+type C(args) =        
+    do printfn "hello"         // debug point over `printfn "hello"` as side effect
+    static do printfn "hello"         // debug point over `printfn "hello"` as side effect for static init
+    let f x = x + 1
+    member _.P = x + f 4
+
+type C(args) =        // debug point over `(args)` since there's no other place to stop on object construction
+    let f x = x + 1
+    member _.P = 4
+
+

Internal implementation of debug points in the compiler

+

Most (but not all) debug points are noted by the parser by adding DebugPointAtTry, DebugPointAtWith, DebugPointAtFinally, DebugPointAtFor, DebugPointAtWhile, DebugPointAtBinding or DebugPointAtLeaf.

+

These are then used by ValidateBreakpointLocation. These same values are also propagated unchanged all the way through to IlxGen.fs for actual code generation, and used for IL emit, e.g. a simple case like this:

+
    match spTry with
+    | DebugPointAtTry.Yes m -> CG.EmitDebugPoint cgbuf m ... 
+    | DebugPointAtTry.No -> ...
+    ...
+
+

For many constructs this is adequate. However, in practice the situation is far more complicated.

+

Internals: Debug points for [...], [| ... |]

+

The internal implementation of debug points for list and array expressions is conceptually simple but a little complex.

+

Conceptually the task is easy, e.g. [ while check() do yield x + x ] is lowered to code like this:

+
let $collector = ListCollector<int>()
+while check() do
+    $collector.Add(x+x)
+$collector.Close()
+
+

Note the while loop is still a while loop - no magic here - and the debug points for the while loop can also apply to the actual generated for loop.

+

However, the actual implementation is more complicated because there is a TypedTree representation of the code in-between that at first seems to bear little resemblance to what comes in.

+
SyntaxTree --[CheckComputationExpressions.fs]--> TypedTree --> IlxGen -->[LowerComputedListOrArrayExpr.fs]--> IlxGen
+
+

The TypedTree is a functional encoding into Seq.toList, Seq.singleton and so on. How do the debug points get propagated?

+ +

This then gives accurate debug points for these constructs.

+

Internals: debug points for seq { .. .} code

+

Debug points for seq { .. } compiling to state machines poses similar problems.

+ +

Internals: debug points for task { .. .} code

+

Debug points for task { .. } poses much harder problems. We use "while" loops as an example:

+ +

Internals: debug points for other computation expressions

+

As mentioned above, other computation expressions such as async { .. } have significant problems with their debug points.

+

The main problem is stepping: even after inlining the code for computation expressions is rarely "flattened" enough, so, for example, a "step-into" is required to get into the second part of an expr1; expr2 construct (i.e. an async.Combine(..., async.Delay(fun () -> ...))) where the user expects to press "step-over".

+

Breakpoints tend to be less problematic.

+
+

NOTE: A systematic solution for quality debugging of computation expressions code is still elusive, and especially for async { ... }. Extensive use of inlining and InlineIfLambda can succeed in flattening most simple computation expression code. This is however not yet fully applied to async programming. +NOTE: The use of library code to implement "async" and similar computation expressions also interacts badly with "Just My Code" debugging, see https://github.com/dotnet/fsharp/issues/5539 for example. +NOTE: As mentioned, the use of many functions to implement "async" and friends implements badly with "Step Into" and "Step Over" and related attributes, see for example https://github.com/dotnet/fsharp/issues/3359

+
+

FeeFee and F00F00 debug points (Hidden and JustMyCodeWithNoSource)

+

Some fragments of code use constructs generate calls and other IL code that should not have debug points and not participate in "Step Into", for example. These are generated in IlxGen as "FeeFee" debug points. See the the Portable PDB spec linked here.

+
+

TODO: There is also the future prospect of generating JustMyCodeWithNoSource (0xF00F00) debug points but these are not yet emitted by F#. We should check what this is and when the C# compiler emits these. +NOTE: We always make space for a debug point at the head of each method by emitting a FeeFee debug sequence point. This may be immediately replaced by a "real" debug point here.

+
+

Generated code

+

The F# compiler generates entire IL classes and methods for constructs such as records, closures, state machines and so on. Each time code is generated we must carefully consider what attributes and debug points are generated.

+

Generated "augment" methods for records, unions and structs

+

Generated methods for equality, hash and comparison on records, unions and structs do not get debug points at all.

+
+

NOTE: Methods without debug points (or with only 0xFEEFEE debug points) are shown as "no code available" in Visual Studio - or in Just My Code they are hidden altogether - and are removed from profiling traces (in profiling, their costs are added to the cost of the calling method). +TODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing, however the absence of debug points should be sufficient to exclude these.

+
+

Generated "New*", "Is*", "Tag" etc. for unions

+

Discriminated unions generate NewXYZ, IsXYZ, Tag etc. members. These do not get debug points at all.

+

These methods also get CompilerGeneratedAttribute, and DebuggerNonUserCodeAttribute.

+
+

TODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing, however the absence of debug points should be sufficient to exclude these. +TODO: the NewABC methods are missing CompilerGeneratedAttribute, and DebuggerNonUserCodeAttribute. However, the absence of debug points should be sufficient to exclude these from code coverage and profiling.

+
+

Generated closures for lambdas

+

The debug codegen involved in closures is as follows:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Source

Construct

Debug Points

Attributes

(fun x -> ...)

Closure class

.ctor method

none

CompilerGenerated, DebuggerNonUserCode

Invoke method

from body of closure

generic local defn

Closure class

.ctor method

none

CompilerGenerated, DebuggerNonUserCode

Specialize method

from body of closure

Intermediate closure classes

For long curried closures fun a b c d e f -> ....

CompilerGenerated, DebuggerNonUserCode

+ +

Generated intermediate closure methods do not get debug points, and are labelled CompilerGenerated and DebuggerNonUserCode.

+
+

TODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing

+
+

Generated state machines for seq { .. }

+

Sequence expressions generate class implementations which resemble closures.

+

The debug points recovered for the generated state machine code for seq { ... } is covered up above. The other codegen is as follows:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Source

Construct

Debug Points

Attributes

seq { ... }

State machine class

"Closure"

.ctor method

none

none

GetFreshEnumerator

none

CompilerGenerated, DebuggerNonUserCode

LastGenerated

none

CompilerGenerated, DebuggerNonUserCode

Close

none

none

get_CheckClose

none

none

GenerateNext

from desugaring

none

+ +
+

NOTE: it appears from the code that extraneous debug points are not being generated, which is good, though should be checked +TODO: we should likely be generating CompilerGeneratedAttribute and DebuggerNonUserCodeAttribute attributes for the Close and get_CheckClose and .ctor methods +TODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing

+
+

Generated state machines for task { .. }

+

Resumable state machines used for task { .. } also generate struct implementations which resemble closures.

+

The debug points recovered for the generated state machine code for seq { ... } is covered up above. The other codegen is as follows:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Source

Construct

Debug Points

Attributes

Notes

task { ... }

State machine struct

"Closure"

.ctor method

none

none

TBD

+ +
+

TODO: we should be generating attributes for some of these +TODO: we should assess that only the "MoveNext" method gets any debug points at all +TODO: Currently stepping into a task-returning method needs a second step-into to get into the MoveNext method of the state machine. We should emit the StateMachineMethod and StateMachineHoistedLocalScopes tables into the PDB to get better debugging into task methods. See https://github.com/dotnet/fsharp/issues/12000.

+
+

Generated code for delegate constructions Func<int,int,int>(fun x y -> x + y)

+

A closure class is generated. Consider the code

+
open System
+let d = Func<int,int,int>(fun x y -> x + y)
+
+

There is one debug point over all of Func<int,int,int>(fun x y -> x + y) and one over x+y.

+

Generated code for constant-sized array and list expressions

+

These are not generally problematic for debug.

+

Generated code for large constant arrays

+

These are not generally problematic for debug.

+

Generated code for pattern matching

+

The implementation is a little gnarly and complicated and has historically had glitches.

+

Generated code for conditionals and boolean logic

+

Generally straight-forward. See for example this proposed feature improvement

+

Capture and closures

+

Captured locals are available via the this pointer of the immediate closure. Un-captured locals are not available as things stand. See for example this proposed feature improvement.

+

Consider this code:

+
let F() =
+    let x = 1
+    let y = 2
+    (fun () -> x + y)
+
+

Here x and y become closure fields of the closure class generated for the final lambda. When inspecting locals in the inner closure, the C# expression evaluator we rely on for Visual Studio takes local names like x and y and is happy to look them up via this. This means hovering over x correctly produces the value stored in this.x.

+

For nested closures, values are implicitly re-captured, and again the captured locals will be available.

+

However this doesn't work with "capture" from a class-defined "let" context. Consider the following variation:

+
type C() =
+    let x = 1
+    member _.M() = 
+        let y = 2
+        (fun () -> x + y)
+
+

Here the implicitly captured local is y, but x is not captured, instead it is implicitly rewritten by the F# compiler to c.x where c is the captured outer "this" pointer of the invocation of M(). This means that hovering over x does not produce a value. See issue 3759.

+

Provided code

+

Code provided by erasing type providers has all debugging points removed. It isn't possible to step into such code or if there are implicit debug points they will be the same range as the construct that was macro-expanded by the code erasure.

+
+

For example, a provided if/then/else expression has no debug point

+
+

Added code generation for better debugging

+

We do some "extra" code gen to improve debugging. It is likely much of this could be removed if we had an expression evaluator for F#.

+

'this' value

+

For member x.Foo() = ... the implementation of the member adds a local variable x containing the this pointer from ldarg.0. This means hovering over x in the method produces the right value, as does x.Property etc.

+

Pipeline debugging

+

For pipeline debugging we emit extra locals for each stage of a pipe and debug points at each stage.

+

See pipeline debugging mini-spec.

+

Shadowed locals

+

For shadowed locals we change the name of a local for the scope for which it is shadowed.

+

See shadowed locals mini-spec.

+

Discriminated union debug display text

+

For discriminated union types and all implied subtypes we emit a DebuggerDisplayAttrubte and a private __DebugDisplay() method that uses sprintf "%+0.8A" obj to format the object.

+

Missing debug emit

+

Missing debug emit for PDBs

+

Our PDB emit is missing considerable information:

+ +

These are major holes in the F# experience. Some are required for things like hot-reload.

+

Missing design-time services

+

Some design-time services are un-implemented by F#:

+ +

These are major holes in the F# experience and should be implemented.

+ +
val f: unit -> 'a
+
val x: int
+
val f: x: 'b -> int
+
val x: 'b
+
val y: int
+
val h1: x: 'a -> 'b
+
val x: 'a
+
val h2: x: unit -> 'a
+
val x: unit
+
val h3: x: 'a -> 'b
+
val x: int list
+
val i: int
+
val f: unit -> System.Threading.Tasks.Task<unit>
+
val task: TaskBuilder
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
type C = + new: args: obj -> C + member P: int
+
val args: obj
+
val f: x: int -> int
+
member C.P: int
+
Multiple items
type C = + new: args: obj -> C + member P: int

--------------------
new: args: obj -> C
+
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+
namespace System
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/diagnostics.html b/diagnostics.html new file mode 100644 index 0000000000..48bb506e78 --- /dev/null +++ b/diagnostics.html @@ -0,0 +1,577 @@ + + + + + + + + + + + + + + + + + + Diagnostics | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Diagnostics

+

The key types are:

+ +

and functions

+ +

For the compiler, a key file is https://github.com/dotnet/fsharp/blob/main/src/Compiler/FSComp.txt holding most of the messages. There are also a few other similar files including some old error messages in FSStrings.resx.

+

Adding Diagnostics

+

Adding or adjusting diagnostics emitted by the compiler is usually straightforward (though it can sometimes imply deeper compiler work). Here's the general process:

+
    +
  1. Reproduce the compiler error or warning with the latest F# compiler built from the F# compiler repository.
    2. +
  2. Find the error code (such as FS0020) in the message.
    3. +
  3. Use a search tool and search for a part of the message. You should find it in FSComp.fs with a title, such as parsMissingTypeArgs.
    4. +
  4. Use another search tool or a tool like Find All References / Find Usages to see where it's used in the compiler source code.
    5. +
  5. Set a breakpoint at the location in source you found. If you debug the compiler with the same steps, it should trigger the breakpoint you set. This verifies that the location you found is the one that emits the error or warning you want to improve.
    6. +
+

From here, you can either simply update the error text, or you can use some of the information at the point in the source code you identified to see if there is more information to include in the error message. For example, if the error message doesn't contain information about the identifier the user is using incorrectly, you may be able to include the name of the identifier based on data the compiler has available at that stage of compilation.

+

If you're including data from user code in an error message, it's important to also write a test that verifies the exact error message for a given string of F# code.

+

Formatting Typed Tree items in Diagnostics

+

Diagnostics must often format TAST items as user text. When formatting these, you normally use either

+ +

When formatting "info" objects, see the functions in the NicePrint module.

+

Notes on displaying types

+

Diagnostics must often format types.

+ +

Localization

+

The file FSComp.txt contains the canonical listing of diagnostic messages, but there are also .xlf localization files for various languages. +See the DEVGUIDE for more details.

+

Enabling a warning or error by default

+

The file CompilerDiagnostics.fs contains the function IsWarningOrInfoEnabled, which determines whether a given diagnostic is emitted.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/caches.html b/fcs/caches.html new file mode 100644 index 0000000000..55f01cd2da --- /dev/null +++ b/fcs/caches.html @@ -0,0 +1,583 @@ + + + + + + + + + + + + + + + + + + FSharpChecker caches | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Notes on the FSharpChecker caches

+

This is a design note on the FSharpChecker component and its caches. See also the notes on the FSharpChecker operations queue

+

Each FSharpChecker object maintains a set of caches. These are

+ +

Profiling the memory used by the various caches can be done by looking for the corresponding static roots in memory profiling traces.

+

The sizes of some of these caches can be adjusted by giving parameters to FSharpChecker. Unless otherwise noted, +the cache sizes above indicate the "strong" size of the cache, where memory is held regardless of the memory +pressure on the system. Some of the caches can also hold "weak" references which can be collected at will by the GC.

+
+

Note: Because of these caches, you should generally use one global, shared FSharpChecker for everything in an IDE application.

+
+

Low-Memory Condition

+

Version 1.4.0.8 added a "maximum memory" limit specified by the MaxMemory property on FSharpChecker (in MB). If an FCS project operation +is performed (see CheckMaxMemoryReached in service.fs) and System.GC.GetTotalMemory(false) reports a figure greater than this, then +the strong sizes of all FCS caches are reduced to either 0 or 1. This happens for the remainder of the lifetime of the FSharpChecker object. +In practice this will still make tools like the Visual Studio F# Power Tools usable, but some operations like renaming across multiple +projects may take substantially longer.

+

By default the maximum memory trigger is disabled, see maxMBDefault in service.fs.

+

Reducing the FCS strong cache sizes does not guarantee there will be enough memory to continue operations - even holding one project +strongly may exceed a process memory budget. It just means FCS may hold less memory strongly.

+

If you do not want the maximum memory limit to apply then set MaxMemory to System.Int32.MaxValue.

+

Summary

+

In this design note, you learned that the FSharpChecker component keeps a set of caches in order to support common +incremental analysis scenarios reasonably efficiently. They correspond roughly to the original caches and sizes +used by the Visual F# Tools, from which the FSharpChecker component derives.

+

In long running, highly interactive, multi-project scenarios you should carefully +consider the cache sizes you are using and the tradeoffs involved between incremental multi-project checking and memory usage.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/compiler.html b/fcs/compiler.html new file mode 100644 index 0000000000..a0fb579147 --- /dev/null +++ b/fcs/compiler.html @@ -0,0 +1,627 @@ + + + + + + + + + + + + + + + + + + Tutorial: Hosting the compiler | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Hosted Compiler

+

This tutorial demonstrates how to host the F# compiler.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published

+
+
+

NOTE: There are several options for hosting the F# compiler. The easiest one is to use the +fsc.exe process and pass arguments.

+
+
+

NOTE: By default compilations using FSharp.Compiler.Service reference FSharp.Core 4.3.0.0 (matching F# 3.0). You can override +this choice by passing a reference to FSharp.Core for 4.3.1.0 or later explicitly in your command-line arguments.

+
+
+

First, we need to reference the libraries that contain F# interactive service:

+
#r "FSharp.Compiler.Service.dll"
+open System.IO
+open FSharp.Compiler.CodeAnalysis
+
+// Create an interactive checker instance 
+let checker = FSharpChecker.Create()
+
+

Now write content to a temporary file:

+
let fn = Path.GetTempFileName()
+let fn2 = Path.ChangeExtension(fn, ".fsx")
+let fn3 = Path.ChangeExtension(fn, ".dll")
+
+File.WriteAllText(fn2, """
+module M
+
+type C() = 
+   member x.P = 1
+
+let x = 3 + 4
+""")
+
+

Now invoke the compiler:

+
let errors1, exitCode1 = 
+    checker.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |]) 
+    |> Async.RunSynchronously
+
+

If errors occur you can see this in the 'exitCode' and the returned array of errors:

+
File.WriteAllText(fn2, """
+module M
+
+let x = 1.0 + "" // a type error
+""")
+
+let errors1b, exitCode1b = 
+    checker.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |])
+    |> Async.RunSynchronously
+
+ +
namespace System
+
namespace System.IO
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val fn: 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.GetTempFileName() : string
+
val fn2: string
+
Path.ChangeExtension(path: string, extension: string) : string
+
val fn3: string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: System.Text.Encoding) : unit
+
val errors1: FSharp.Compiler.Diagnostics.FSharpDiagnostic array
+
val exitCode1: int
+
member FSharpChecker.Compile: argv: string array * ?userOpName: string -> Async<FSharp.Compiler.Diagnostics.FSharpDiagnostic array * int>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
+
val errors1b: FSharp.Compiler.Diagnostics.FSharpDiagnostic array
+
val exitCode1b: int
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/corelib.html b/fcs/corelib.html new file mode 100644 index 0000000000..388027fb9e --- /dev/null +++ b/fcs/corelib.html @@ -0,0 +1,560 @@ + + + + + + + + + + + + + + + + + + Notes on FSharp.Core | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Notes on FSharp.Core.dll

+

Versions of FSharp.Core involved in the operation of FSharp.Compiler.Service

+

There are three versions of FSharp.Core relevant to the operation of FSharp.Compiler.Service:

+
    +
  1. +

    The FSharp.Compiler.Service.dll static reference to FSharp.Core - The FCS DLL and nuget have a static minbound dependency on FSharp.Core.

    +

    This is just a normal .NET dependency like any other, it expresses the minimum surface area of FSharp.Core that the implementation of FSharp.Compiler.Service (and any components that depend on it) needs. It could be a reference to a reference assembly if we supported that. In theory this could be very low and all is cool - if we could implement FCS in terms of FSharp.Core 2.0.0.0 then that could be the minbound (indeed in theory we could implement FCS pretty almost without any use of FSharp.Core functionality at all, though obviously we don't).

    +

    In practice this is 0-2 versions behind latest FSharp.Core.

    +
    2. +
  2. +

    The runtime reference to FSharp.Core in a tool, application or test suite that includes FSharp.Compiler.Service - This is the actual version of FSharp.Core used when, say, fsc.exe or devenv.exe or fsi.exe or fsdocs.exe runs.

    +

    This must be at least as high as (1) and is usually the very latest FSharp.Core available (in or out of repo tree). This is important to the operation of the FCS-based tool because it is used for execution of scripts, and the default compilation reference for scripts. If scripts are going to use a particular language feature then this must be sufficient to support the language feature.

    +
    3. +
  3. +

    The FSharp.Core reference in a compilation or analysis being processed by FSharp.Compiler.Service.

    +

    This can be anything - 2.0.0.0, 4.0.0.0 or 5.0.0 or whatever. For script compilation and execution is the same as (2). It must be sufficient to support language features used in the compilation.

    +
    4. +
+

Shipping an FSharp.Core with your application

+

When building applications or plug-in components which use FSharp.Compiler.Service.dll, you will normally also +include a copy of FSharp.Core.dll as part of your application.

+

For example, if you build a HostedCompiler.exe, you will normally place an FSharp.Core.dll (say 4.3.1.0) alongside +your HostedCompiler.exe.

+

Which FSharp.Core and .NET SDK get referenced in compilation?

+

The FSharp.Compiler.Service component can be used to do more or less any sort of F# compilation. +In particular you can reference an explicit FSharp.Core and/or framework +assemblies in the command line arguments (different to the FSharp.Core and a .NET Framework being used to run your tool).

+

What about if I am using FsiEvaluationSession or GetProjectOptionsFromScript

+

If you do not explicitly reference an FSharp.Core.dll from an SDK location, or if you are processing a script +using FsiEvaluationSession or GetProjectOptionsFromScript, then an implicit reference to FSharp.Core will be made +by the following choice:

+
    +
  1. The version of FSharp.Core.dll for the SDK implied by global.json.
    2. +

  2. The version of FSharp.Core.dll statically referenced by the host assembly returned by System.Reflection.Assembly.GetEntryAssembly().

    3. +
  3. If there is no static reference to FSharp.Core in the host assembly, then a default is chosen.
    4. +
+
+

NOTE: these may depend on exact flags passed to GetProjectOptionsFromScript

+
+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/editor.html b/fcs/editor.html new file mode 100644 index 0000000000..39441465be --- /dev/null +++ b/fcs/editor.html @@ -0,0 +1,860 @@ + + + + + + + + + + + + + + + + + + Tutorial: Editor services | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Editor services

+

This tutorial demonstrates how to use the editor services provided by the F# compiler. +This API is used to provide auto-complete, tool-tips, parameter info help, matching of +brackets and other functions in F# editors including Visual Studio, Xamarin Studio and Emacs +(see fsharpbindings project for more information). +Similarly to the tutorial on using untyped AST, we start by +getting the InteractiveChecker object.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published

+
+

Type checking sample source code

+

As in the previous tutorial (using untyped AST), we start by referencing +FSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance +of InteractiveChecker:

+
// Reference F# compiler API
+#r "FSharp.Compiler.Service.dll"
+
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.EditorServices
+open FSharp.Compiler.Text
+open FSharp.Compiler.Tokenization
+
+// Create an interactive checker instance
+let checker = FSharpChecker.Create()
+
+

As previously, we use GetProjectOptionsFromScriptRoot to get a context +where the specified input is the only file passed to the compiler (and it is treated as a +script file or stand-alone F# source code).

+
// Sample input as a multi-line string
+let input =
+    """
+  open System
+
+  let foo() =
+    let msg = String.Concat("Hello"," ","world")
+    if true then
+      printfn "%s" msg.
+  """
+// Split the input & define file name
+let inputLines = input.Split('\n')
+let file = "/home/user/Test.fsx"
+
+let projOptions, _diagnostics =
+    checker.GetProjectOptionsFromScript(file, SourceText.ofString input, assumeDotNetFramework=false)
+    |> Async.RunSynchronously
+
+let parsingOptions, _diagnostics2 =
+    checker.GetParsingOptionsFromProjectOptions(projOptions)
+
+

To perform type checking, we first need to parse the input using +ParseFile, which gives us access to the untyped AST. However, +then we need to call CheckFileInProject to perform the full type checking. This function +also requires the result of ParseFileInProject, so the two functions are often called +together.

+
// Perform parsing
+
+let parseFileResults =
+    checker.ParseFile(file, SourceText.ofString input, parsingOptions)
+    |> Async.RunSynchronously
+
+

Before we look at the interesting operations provided by TypeCheckResults, we +need to run the type checker on a sample input. On F# code with errors, you would get some type checking +result (but it may contain incorrectly "guessed" results).

+
// Perform type checking
+let checkFileAnswer =
+    checker.CheckFileInProject(parseFileResults, file, 0, SourceText.ofString input, projOptions)
+    |> Async.RunSynchronously
+
+

Alternatively you can use ParseAndCheckFileInProject to check both in one step:

+
let parseResults2, checkFileAnswer2 =
+    checker.ParseAndCheckFileInProject(file, 0, SourceText.ofString input, projOptions)
+    |> Async.RunSynchronously
+
+

The function returns both the untyped parse result (which we do not use in this +tutorial), but also a CheckFileAnswer value, which gives us access to all +the interesting functionality...

+
let checkFileResults =
+    match checkFileAnswer with
+    | FSharpCheckFileAnswer.Succeeded (res) -> res
+    | res -> failwithf "Parsing did not finish... (%A)" res
+
+

Here, we type check a simple function that (conditionally) prints "Hello world". +On the last line, we leave an additional dot in msg. so that we can get the +completion list on the msg value (we expect to see various methods on the string +type there).

+

Using type checking results

+

Let's now look at some of the API that is exposed by the TypeCheckResults type. In general, +this is the type that lets you implement most of the interesting F# source code editor services.

+

Getting a tool tip

+

To get a tool tip, you can use the GetToolTip method. The method takes a line number and character +offset. Both of the numbers are zero-based. In the sample code, we want to get a tooltip for the foo +function that is defined on line 3 (line 0 is blank) and the letter f starts at index 7 (the tooltip +would work anywhere inside the identifier).

+

In addition, the method takes a tag of token which is typically IDENT, when getting a tooltip for an +identifier (the other option lets you get a tooltip with full assembly location when using #r "...").

+
// Get tag of the IDENT token to be used as the last argument
+let identToken = FSharpTokenTag.Identifier
+
+// Get tool tip at the specified location
+let tip =
+    checkFileResults.GetToolTip(4, 7, inputLines.[1], [ "foo" ], identToken)
+
+printfn "%A" tip
+
+

Aside from the location and token kind, the function also requires the current contents of the line +(useful when the source code changes) and a Names value, which is a list of strings representing +the current long name. For example, to get a tooltip for the Random identifier in a long name +System.Random, you would use a location somewhere in the string Random and you would pass +["System"; "Random"] as the Names value.

+

The returned value is of type ToolTipText which contains a discriminated union ToolTipElement. +The union represents different kinds of tool tips that you can get from the compiler.

+

Getting auto-complete lists

+

The next method exposed by TypeCheckResults lets us perform auto-complete on a given location. +This can be called on any identifier or in any scope (in which case you get a list of names visible +in the scope) or immediately after . to get a list of members of some object. Here, we get a +list of members of the string value msg.

+

To do this, we call GetDeclarationListInfo with the location of the . symbol on the last line +(ending with printfn "%s" msg.). The offsets are one-based, so the location is 7, 23. +We also need to specify a function that says that the text has not changed and the current identifier +where we need to perform the completion.

+
// Get declarations (autocomplete) for a location
+let decls =
+    checkFileResults.GetDeclarationListInfo(
+        Some parseFileResults,
+        7,
+        inputLines.[6],
+        PartialLongName.Empty 23,
+        (fun () -> [])
+    )
+
+// Print the names of available items
+for item in decls.Items do
+    printfn " - %s" item.NameInList
+
+
+

NOTE: v is an alternative name for the old GetDeclarations. The old GetDeclarations was +deprecated because it accepted zero-based line numbers. At some point it will be removed, and GetDeclarationListInfo will be renamed back to GetDeclarations.

+
+

When you run the code, you should get a list containing the usual string methods such as +Substring, ToUpper, ToLower etc. The fourth argument of GetDeclarations, here ([], "msg"), +specifies the context for the auto-completion. Here, we want a completion on a complete name +msg, but you could for example use (["System"; "Collections"], "Generic") to get a completion list +for a fully qualified namespace.

+

Getting parameter information

+

The next common feature of editors is to provide information about overloads of a method. In our +sample code, we use String.Concat which has a number of overloads. We can get the list using +GetMethods operation. As previously, this takes the zero-indexed offset of the location that we are +interested in (here, right at the end of the String.Concat identifier) and we also need to provide +the identifier again (so that the compiler can provide up-to-date information when the source code +changes):

+
// Get overloads of the String.Concat method
+let methods =
+    checkFileResults.GetMethods(5, 27, inputLines.[4], Some [ "String"; "Concat" ])
+
+// Print concatenated parameter lists
+for mi in methods.Methods do
+    [ for p in mi.Parameters do
+          for tt in p.Display do
+              yield tt.Text ]
+    |> String.concat ", "
+    |> printfn "%s(%s)" methods.MethodName
+
+

The code uses the Display property to get the annotation for each parameter. This returns information +such as arg0: obj or params args: obj[] or str0: string, str1: string. We concatenate the parameters +and print a type annotation with the method name.

+

Asynchronous and immediate operations

+

You may have noticed that CheckFileInProject is an asynchronous operation. +This indicates that type checking of F# code can take some time. +The F# compiler performs the work in the background (automatically) and when +we call the CheckFileInProject method, it returns an asynchronous operation.

+

There is also the CheckFileInProjectIfReady method. This returns immediately if the +type checking operation can't be started immediately, e.g. if other files in the project +are not yet type-checked. In this case, a background worker might choose to do other +work in the meantime, or give up on type checking the file until the FileTypeCheckStateIsDirty event +is raised.

+
+

The fsharpbinding project has a more advanced +example of handling the background work where all requests are sent through an F# agent. +This may be more appropriate for implementing editor support.

+
+

Summary

+

The CheckFileAnswer object contains other useful methods that were not covered in this tutorial. You +can use it to get location of a declaration for a given identifier, additional colorization information +(the F# 3.1 colorizes computation builder identifiers & query operators) and others.

+

Using the FSharpChecker component in multi-project, incremental and interactive editing situations may involve +knowledge of the FSharpChecker operations queue and the FSharpChecker caches.

+

Finally, if you are implementing an editor support for an editor that cannot directly call the .NET API, +you can call many of the methods discussed here via a command line interface that is available in the +FSharp.AutoComplete project.

+ +
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.EditorServices
+
namespace FSharp.Compiler.Text
+
namespace FSharp.Compiler.Tokenization
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val input: string
+
val inputLines: string array
+
System.String.Split([<System.ParamArray>] separator: char array) : string array
System.String.Split(separator: string array, options: System.StringSplitOptions) : string array
System.String.Split(separator: string, ?options: System.StringSplitOptions) : string array
System.String.Split(separator: char array, options: System.StringSplitOptions) : string array
System.String.Split(separator: char array, count: int) : string array
System.String.Split(separator: char, ?options: System.StringSplitOptions) : string array
System.String.Split(separator: string array, count: int, options: System.StringSplitOptions) : string array
System.String.Split(separator: string, count: int, ?options: System.StringSplitOptions) : string array
System.String.Split(separator: char array, count: int, options: System.StringSplitOptions) : string array
System.String.Split(separator: char, count: int, ?options: System.StringSplitOptions) : string array
+
val file: string
+
val projOptions: FSharpProjectOptions
+
val _diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
member FSharpChecker.GetProjectOptionsFromScript: fileName: string * source: ISourceText * ?previewEnabled: bool * ?loadedTimeStamp: System.DateTime * ?otherFlags: string array * ?useFsiAuxLib: bool * ?useSdkRefs: bool * ?assumeDotNetFramework: bool * ?sdkDirOverride: string * ?optionsStamp: int64 * ?userOpName: string -> Async<FSharpProjectOptions * FSharp.Compiler.Diagnostics.FSharpDiagnostic list>
+
module SourceText + +from FSharp.Compiler.Text
<summary> + Functions related to ISourceText objects +</summary>
+
val ofString: string -> ISourceText
<summary> + Creates an ISourceText object from the given string +</summary>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
+
val parsingOptions: FSharpParsingOptions
+
val _diagnostics2: FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
member FSharpChecker.GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
val parseFileResults: FSharpParseFileResults
+
member FSharpChecker.ParseFile: fileName: string * sourceText: ISourceText * options: FSharpParsingOptions * ?cache: bool * ?userOpName: string -> Async<FSharpParseFileResults>
+
val checkFileAnswer: FSharpCheckFileAnswer
+
member FSharpChecker.CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer>
+
val parseResults2: FSharpParseFileResults
+
val checkFileAnswer2: FSharpCheckFileAnswer
+
member FSharpChecker.ParseAndCheckFileInProject: fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
+
val checkFileResults: FSharpCheckFileResults
+
type FSharpCheckFileAnswer = + | Aborted + | Succeeded of FSharpCheckFileResults
<summary> + The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. +</summary>
+
union case FSharpCheckFileAnswer.Succeeded: FSharpCheckFileResults -> FSharpCheckFileAnswer
<summary> + Success +</summary>
+
val res: FSharpCheckFileResults
+
val res: FSharpCheckFileAnswer
+
val failwithf: format: Printf.StringFormat<'T,'Result> -> 'T
+
val identToken: int
+
module FSharpTokenTag + +from FSharp.Compiler.Tokenization
<summary> + Some of the values in the field FSharpTokenInfo.Tag +</summary>
+
val Identifier: int
<summary> + Indicates the token is an identifier +</summary>
+
val tip: ToolTipText
+
member FSharpCheckFileResults.GetToolTip: line: int * colAtEndOfNames: int * lineText: string * names: string list * tokenTag: int * ?width: int -> ToolTipText
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
val decls: DeclarationListInfo
+
member FSharpCheckFileResults.GetDeclarationListInfo: parsedFileResults: FSharpParseFileResults option * line: int * lineText: string * partialName: PartialLongName * ?getAllEntities: (unit -> AssemblySymbol list) * ?completionContextAtPos: (pos * CompletionContext option) -> DeclarationListInfo
+
union case Option.Some: Value: 'T -> Option<'T>
+
type PartialLongName = + { + QualifyingIdents: string list + PartialIdent: string + EndColumn: int + LastDotPos: int option + } + static member Empty: endColumn: int -> PartialLongName
<summary> + Qualified long name. +</summary>
+
static member PartialLongName.Empty: endColumn: int -> PartialLongName
+
val item: DeclarationListItem
+
property DeclarationListInfo.Items: DeclarationListItem array with get
+
property DeclarationListItem.NameInList: string with get
<summary> + Get the text to display in the declaration list for the declaration. + + This is a display name without backticks. +</summary>
+
val methods: MethodGroup
+
member FSharpCheckFileResults.GetMethods: line: int * colAtEndOfNames: int * lineText: string * names: string list option -> MethodGroup
+
val mi: MethodGroupItem
+
property MethodGroup.Methods: MethodGroupItem array with get
<summary> + The methods (or other items) in the group +</summary>
+
val p: MethodGroupItemParameter
+
property MethodGroupItem.Parameters: MethodGroupItemParameter array with get
<summary> + The parameters of the method in the overload set +</summary>
+
val tt: TaggedText
+
property MethodGroupItemParameter.Display: TaggedText array with get
<summary> + The representation for the parameter including its name, its type and visual indicators of other + information such as whether it is optional. +</summary>
+
property TaggedText.Text: string with get
<summary> + Gets the text +</summary>
+
module String + +from Microsoft.FSharp.Core
+
val concat: sep: string -> strings: string seq -> string
+
property MethodGroup.MethodName: string with get
<summary> + The shared name of the methods (or other items) in the group +</summary>
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/filesystem.html b/fcs/filesystem.html new file mode 100644 index 0000000000..c6c6caf4a9 --- /dev/null +++ b/fcs/filesystem.html @@ -0,0 +1,1002 @@ + + + + + + + + + + + + + + + + + + IFileSystem | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Virtualized File System

+

The FSharp.Compiler.Service component has a global variable +representing the file system. By setting this variable you can host the compiler in situations where a file system +is not available.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.

+
+

Setting the FileSystem

+

In the example below, we set the file system to an implementation which reads from disk

+
#r "FSharp.Compiler.Service.dll"
+
+open System.IO
+open System.Text
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.IO
+
+let defaultFileSystem = FileSystem
+
+let fileName1 = @"c:\mycode\test1.fs" // note, the path doesn't exist
+let fileName2 = @"c:\mycode\test2.fs" // note, the path doesn't exist
+
+type MyFileSystem() =
+    let file1 =
+        """
+module File1
+
+let A = 1"""
+
+    let file2 =
+        """
+module File2
+let B = File1.A + File1.A"""
+
+    let files =
+        dict [ (fileName1, file1)
+               (fileName2, file2) ]
+
+    interface IFileSystem with
+        // Implement the service to open files for reading and writing
+        member _.OpenFileForReadShim(fileName, ?useMemoryMappedFile: bool, ?shouldShadowCopy: bool) =
+            match files.TryGetValue fileName with
+            | true, text -> new MemoryStream(Encoding.UTF8.GetBytes(text)) :> Stream
+            | _ ->
+                defaultFileSystem.OpenFileForReadShim(
+                    fileName,
+                    ?useMemoryMappedFile = useMemoryMappedFile,
+                    ?shouldShadowCopy = shouldShadowCopy
+                )
+
+        member _.OpenFileForWriteShim(fileName, ?fileMode: FileMode, ?fileAccess: FileAccess, ?fileShare: FileShare) =
+            defaultFileSystem.OpenFileForWriteShim(
+                fileName,
+                ?fileMode = fileMode,
+                ?fileAccess = fileAccess,
+                ?fileShare = fileShare
+            )
+
+        // Implement the service related to file existence and deletion
+        member _.FileExistsShim(fileName) =
+            files.ContainsKey(fileName)
+            || defaultFileSystem.FileExistsShim(fileName)
+
+        // Implement the service related to temporary paths and file time stamps
+        member _.GetTempPathShim() = defaultFileSystem.GetTempPathShim()
+
+        member _.GetLastWriteTimeShim(fileName) =
+            defaultFileSystem.GetLastWriteTimeShim(fileName)
+
+        member _.GetFullPathShim(fileName) =
+            defaultFileSystem.GetFullPathShim(fileName)
+
+        member _.IsInvalidPathShim(fileName) =
+            defaultFileSystem.IsInvalidPathShim(fileName)
+
+        member _.IsPathRootedShim(fileName) =
+            defaultFileSystem.IsPathRootedShim(fileName)
+
+        member _.FileDeleteShim(fileName) =
+            defaultFileSystem.FileDeleteShim(fileName)
+
+        member _.AssemblyLoader = defaultFileSystem.AssemblyLoader
+
+        member _.GetFullFilePathInDirectoryShim dir fileName =
+            defaultFileSystem.GetFullFilePathInDirectoryShim dir fileName
+
+        member _.NormalizePathShim(path) =
+            defaultFileSystem.NormalizePathShim(path)
+
+        member _.GetDirectoryNameShim(path) =
+            defaultFileSystem.GetDirectoryNameShim(path)
+
+        member _.GetCreationTimeShim(path) =
+            defaultFileSystem.GetCreationTimeShim(path)
+
+        member _.CopyShim(src, dest, overwrite) =
+            defaultFileSystem.CopyShim(src, dest, overwrite)
+
+        member _.DirectoryCreateShim(path) =
+            defaultFileSystem.DirectoryCreateShim(path)
+
+        member _.DirectoryExistsShim(path) =
+            defaultFileSystem.DirectoryExistsShim(path)
+
+        member _.DirectoryDeleteShim(path) =
+            defaultFileSystem.DirectoryDeleteShim(path)
+
+        member _.EnumerateFilesShim(path, pattern) =
+            defaultFileSystem.EnumerateFilesShim(path, pattern)
+
+        member _.EnumerateDirectoriesShim(path) =
+            defaultFileSystem.EnumerateDirectoriesShim(path)
+
+        member _.IsStableFileHeuristic(path) =
+            defaultFileSystem.IsStableFileHeuristic(path)
+
+        member this.ChangeExtensionShim(path, extension) =
+            defaultFileSystem.ChangeExtensionShim(path, extension)
+
+let myFileSystem = MyFileSystem()
+FileSystem <- MyFileSystem()
+
+

Doing a compilation with the FileSystem

+
let checker = FSharpChecker.Create()
+
+let projectOptions =
+    let sysLib nm =
+        if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then // file references only valid on Windows
+            System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
+            + @"\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\"
+            + nm
+            + ".dll"
+        else
+            let sysDir =
+                System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()
+
+            let (++) a b = System.IO.Path.Combine(a, b)
+            sysDir ++ nm + ".dll"
+
+    let fsCore4300 () =
+        if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then // file references only valid on Windows
+            System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
+            + @"\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0\FSharp.Core.dll"
+        else
+            sysLib "FSharp.Core"
+
+    let allFlags =
+        [| "--simpleresolution"
+           "--noframework"
+           "--debug:full"
+           "--define:DEBUG"
+           "--optimize-"
+           "--doc:test.xml"
+           "--warn:3"
+           "--fullpaths"
+           "--flaterrors"
+           "--target:library"
+           let references =
+               [ sysLib "mscorlib"
+                 sysLib "System"
+                 sysLib "System.Core"
+                 fsCore4300 () ]
+
+           for r in references do
+               "-r:" + r |]
+
+    { ProjectFileName = @"c:\mycode\compilation.fsproj" // Make a name that is unique in this directory.
+      ProjectId = None
+      SourceFiles = [| fileName1; fileName2 |]
+      OriginalLoadReferences = []
+      Stamp = None
+      OtherOptions = allFlags
+      ReferencedProjects = [||]
+      IsIncompleteTypeCheckEnvironment = false
+      UseScriptResolutionRules = true
+      LoadTime = System.DateTime.Now // Note using 'Now' forces reloading
+      UnresolvedReferences = None }
+
+let results =
+    checker.ParseAndCheckProject(projectOptions)
+    |> Async.RunSynchronously
+
+results.Diagnostics
+results.AssemblySignature.Entities.Count //2
+
+results.AssemblySignature.Entities.[0]
+    .MembersFunctionsAndValues
+    .Count
+
+results.AssemblySignature.Entities.[0]
+    .MembersFunctionsAndValues.[0]
+    .DisplayName
+
+

Summary

+

In this tutorial, we've seen how to globally customize the view of the file system used by the FSharp.Compiler.Service +component.

+

At the time of writing, the following System.IO operations are not considered part of the virtualized file system API. +Future iterations on the compiler service implementation may add these to the API.

+ +

NOTE: Several operations in the SourceCodeServices API accept the contents of a file to parse +or check as a parameter, in addition to a file name. In these cases, the file name is only used for +error reporting.

+

NOTE: Type provider components do not use the virtualized file system.

+

NOTE: The compiler service may use MSBuild for assembly resolutions unless --simpleresolution is +provided. When using the FileSystem API you will normally want to specify --simpleresolution as one +of your compiler flags. Also specify --noframework. You will need to supply explicit resolutions of all +referenced .NET assemblies.

+ +
namespace System
+
namespace System.IO
+
namespace System.Text
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.IO
+
val defaultFileSystem: IFileSystem
+
val mutable FileSystem: IFileSystem
<summary> + The global hook into the file system +</summary>
+
val fileName1: string
+
val fileName2: string
+
Multiple items
type MyFileSystem = + interface IFileSystem + new: unit -> MyFileSystem

--------------------
new: unit -> MyFileSystem
+
val file1: string
+
val file2: string
+
val files: System.Collections.Generic.IDictionary<string,string>
+
val dict: keyValuePairs: ('Key * 'Value) seq -> System.Collections.Generic.IDictionary<'Key,'Value> (requires equality)
+
type IFileSystem = + abstract ChangeExtensionShim: path: string * extension: string -> string + abstract CopyShim: src: string * dest: string * overwrite: bool -> unit + abstract DirectoryCreateShim: path: string -> string + abstract DirectoryDeleteShim: path: string -> unit + abstract DirectoryExistsShim: path: string -> bool + abstract EnumerateDirectoriesShim: path: string -> string seq + abstract EnumerateFilesShim: path: string * pattern: string -> string seq + abstract FileDeleteShim: fileName: string -> unit + abstract FileExistsShim: fileName: string -> bool + abstract GetCreationTimeShim: path: string -> DateTime + ...
<summary> + Represents a shim for the file system +</summary>
+
val fileName: string
+
val useMemoryMappedFile: bool option
+
type bool = System.Boolean
+
val shouldShadowCopy: bool option
+
System.Collections.Generic.IDictionary.TryGetValue(key: string, value: byref<string>) : bool
+
val text: string
+
Multiple items
type MemoryStream = + inherit Stream + new: unit -> unit + 6 overloads + member BeginRead: buffer: byte array * offset: int * count: int * callback: AsyncCallback * state: obj -> IAsyncResult + member BeginWrite: buffer: byte array * offset: int * count: int * callback: AsyncCallback * state: obj -> IAsyncResult + member CopyTo: destination: Stream * bufferSize: int -> unit + member CopyToAsync: destination: Stream * bufferSize: int * cancellationToken: CancellationToken -> Task + member EndRead: asyncResult: IAsyncResult -> int + member EndWrite: asyncResult: IAsyncResult -> unit + member Flush: unit -> unit + member FlushAsync: cancellationToken: CancellationToken -> Task + ...
<summary>Creates a stream whose backing store is memory.</summary>

--------------------
MemoryStream() : MemoryStream
MemoryStream(buffer: byte array) : MemoryStream
MemoryStream(capacity: int) : MemoryStream
MemoryStream(buffer: byte array, writable: bool) : MemoryStream
MemoryStream(buffer: byte array, index: int, count: int) : MemoryStream
MemoryStream(buffer: byte array, index: int, count: int, writable: bool) : MemoryStream
MemoryStream(buffer: byte array, index: int, count: int, writable: bool, publiclyVisible: bool) : MemoryStream
+
type Encoding = + interface ICloneable + member Clone: unit -> obj + member Equals: value: obj -> bool + member GetByteCount: chars: nativeptr<char> * count: int -> int + 5 overloads + member GetBytes: chars: nativeptr<char> * charCount: int * bytes: nativeptr<byte> * byteCount: int -> int + 7 overloads + member GetCharCount: bytes: nativeptr<byte> * count: int -> int + 3 overloads + member GetChars: bytes: nativeptr<byte> * byteCount: int * chars: nativeptr<char> * charCount: int -> int + 4 overloads + member GetDecoder: unit -> Decoder + member GetEncoder: unit -> Encoder + member GetHashCode: unit -> int + ...
<summary>Represents a character encoding.</summary>
+
property Encoding.UTF8: Encoding with get
<summary>Gets an encoding for the UTF-8 format.</summary>
<returns>An encoding for the UTF-8 format.</returns>
+
(extension) Encoding.GetBytes(chars: inref<System.Buffers.ReadOnlySequence<char>>) : byte array
   (+0 other overloads)
Encoding.GetBytes(s: string) : byte array
   (+0 other overloads)
Encoding.GetBytes(chars: char array) : byte array
   (+0 other overloads)
(extension) Encoding.GetBytes(chars: inref<System.Buffers.ReadOnlySequence<char>>, writer: System.Buffers.IBufferWriter<byte>) : int64
   (+0 other overloads)
(extension) Encoding.GetBytes(chars: inref<System.Buffers.ReadOnlySequence<char>>, bytes: System.Span<byte>) : int
   (+0 other overloads)
(extension) Encoding.GetBytes(chars: System.ReadOnlySpan<char>, writer: System.Buffers.IBufferWriter<byte>) : int64
   (+0 other overloads)
Encoding.GetBytes(chars: System.ReadOnlySpan<char>, bytes: System.Span<byte>) : int
   (+0 other overloads)
Encoding.GetBytes(s: string, index: int, count: int) : byte array
   (+0 other overloads)
Encoding.GetBytes(chars: char array, index: int, count: int) : byte array
   (+0 other overloads)
Encoding.GetBytes(chars: nativeptr<char>, charCount: int, bytes: nativeptr<byte>, byteCount: int) : int
   (+0 other overloads)
+
type Stream = + inherit MarshalByRefObject + interface IAsyncDisposable + interface IDisposable + member BeginRead: buffer: byte array * offset: int * count: int * callback: AsyncCallback * state: obj -> IAsyncResult + member BeginWrite: buffer: byte array * offset: int * count: int * callback: AsyncCallback * state: obj -> IAsyncResult + member Close: unit -> unit + member CopyTo: destination: Stream -> unit + 1 overload + member CopyToAsync: destination: Stream -> Task + 3 overloads + member Dispose: unit -> unit + member DisposeAsync: unit -> ValueTask + ...
<summary>Provides a generic view of a sequence of bytes. This is an abstract class.</summary>
+
abstract IFileSystem.OpenFileForReadShim: filePath: string * ?useMemoryMappedFile: bool * ?shouldShadowCopy: bool -> Stream
+
val fileMode: FileMode option
+
[<Struct>] +type FileMode = + | CreateNew = 1 + | Create = 2 + | Open = 3 + | OpenOrCreate = 4 + | Truncate = 5 + | Append = 6
<summary>Specifies how the operating system should open a file.</summary>
+
val fileAccess: FileAccess option
+
[<Struct>] +type FileAccess = + | Read = 1 + | Write = 2 + | ReadWrite = 3
<summary>Defines constants for read, write, or read/write access to a file.</summary>
+
val fileShare: FileShare option
+
[<Struct>] +type FileShare = + | None = 0 + | Read = 1 + | Write = 2 + | ReadWrite = 3 + | Delete = 4 + | Inheritable = 16
<summary>Contains constants for controlling the kind of access other operations can have to the same file.</summary>
+
abstract IFileSystem.OpenFileForWriteShim: filePath: string * ?fileMode: FileMode * ?fileAccess: FileAccess * ?fileShare: FileShare -> Stream
+
System.Collections.Generic.IDictionary.ContainsKey(key: string) : bool
+
abstract IFileSystem.FileExistsShim: fileName: string -> bool
+
abstract IFileSystem.GetTempPathShim: unit -> string
+
abstract IFileSystem.GetLastWriteTimeShim: fileName: string -> System.DateTime
+
abstract IFileSystem.GetFullPathShim: fileName: string -> string
+
abstract IFileSystem.IsInvalidPathShim: path: string -> bool
+
abstract IFileSystem.IsPathRootedShim: path: string -> bool
+
abstract IFileSystem.FileDeleteShim: fileName: string -> unit
+
property IFileSystem.AssemblyLoader: IAssemblyLoader with get
+
val dir: string
+
abstract IFileSystem.GetFullFilePathInDirectoryShim: dir: string -> fileName: string -> string
+
val path: string
+
abstract IFileSystem.NormalizePathShim: path: string -> string
+
abstract IFileSystem.GetDirectoryNameShim: path: string -> string
+
abstract IFileSystem.GetCreationTimeShim: path: string -> System.DateTime
+
val src: string
+
val dest: string
+
val overwrite: bool
+
abstract IFileSystem.CopyShim: src: string * dest: string * overwrite: bool -> unit
+
abstract IFileSystem.DirectoryCreateShim: path: string -> string
+
abstract IFileSystem.DirectoryExistsShim: path: string -> bool
+
abstract IFileSystem.DirectoryDeleteShim: path: string -> unit
+
val pattern: string
+
abstract IFileSystem.EnumerateFilesShim: path: string * pattern: string -> string seq
+
abstract IFileSystem.EnumerateDirectoriesShim: path: string -> string seq
+
abstract IFileSystem.IsStableFileHeuristic: fileName: string -> bool
+
val this: MyFileSystem
+
val extension: string
+
abstract IFileSystem.ChangeExtensionShim: path: string * extension: string -> string
+
val myFileSystem: MyFileSystem
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val projectOptions: FSharpProjectOptions
+
val sysLib: nm: string -> string
+
val nm: string
+
type Environment = + static member Exit: exitCode: int -> unit + static member ExpandEnvironmentVariables: name: string -> string + static member FailFast: message: string -> unit + 1 overload + static member GetCommandLineArgs: unit -> string array + static member GetEnvironmentVariable: variable: string -> string + 1 overload + static member GetEnvironmentVariables: unit -> IDictionary + 1 overload + static member GetFolderPath: folder: SpecialFolder -> string + 1 overload + static member GetLogicalDrives: unit -> string array + static member SetEnvironmentVariable: variable: string * value: string -> unit + 1 overload + static member CommandLine: string + ...
<summary>Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.</summary>
+
property System.Environment.OSVersion: System.OperatingSystem with get
<summary>Gets the current platform identifier and version number.</summary>
<exception cref="T:System.InvalidOperationException">This property was unable to obtain the system version. + + -or- + + The obtained platform identifier is not a member of <see cref="T:System.PlatformID" /></exception>
<returns>The platform identifier and version number.</returns>
+
property System.OperatingSystem.Platform: System.PlatformID with get
<summary>Gets a <see cref="T:System.PlatformID" /> enumeration value that identifies the operating system platform.</summary>
<returns>One of the <see cref="T:System.PlatformID" /> values.</returns>
+
[<Struct>] +type PlatformID = + | Win32S = 0 + | Win32Windows = 1 + | Win32NT = 2 + | WinCE = 3 + | Unix = 4 + | Xbox = 5 + | MacOSX = 6 + | Other = 7
<summary>Identifies the operating system, or platform, supported by an assembly.</summary>
+
field System.PlatformID.Win32NT: System.PlatformID = 2
+
System.Environment.GetFolderPath(folder: System.Environment.SpecialFolder) : string
System.Environment.GetFolderPath(folder: System.Environment.SpecialFolder, option: System.Environment.SpecialFolderOption) : string
+
[<Struct>] +type SpecialFolder = + | Desktop = 0 + | Programs = 2 + | MyDocuments = 5 + | Personal = 5 + | Favorites = 6 + | Startup = 7 + | Recent = 8 + | SendTo = 9 + | StartMenu = 11 + | MyMusic = 13 + ...
<summary>Specifies enumerated constants used to retrieve directory paths to system special folders.</summary>
+
field System.Environment.SpecialFolder.ProgramFilesX86: System.Environment.SpecialFolder = 42
+
val sysDir: string
+
namespace System.Runtime
+
namespace System.Runtime.InteropServices
+
type RuntimeEnvironment = + static member FromGlobalAccessCache: a: Assembly -> bool + static member GetRuntimeDirectory: unit -> string + static member GetRuntimeInterfaceAsIntPtr: clsid: Guid * riid: Guid -> nativeint + static member GetRuntimeInterfaceAsObject: clsid: Guid * riid: Guid -> obj + static member GetSystemVersion: unit -> string + static member SystemConfigurationFile: string
<summary>Provides a collection of <see langword="static" /> methods that return information about the common language runtime environment.</summary>
+
System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory() : string
+
val a: string
+
val b: 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 fsCore4300: unit -> string
+
val allFlags: string array
+
val references: string list
+
val r: string
+
union case Option.None: Option<'T>
+
Multiple items
[<Struct>] +type DateTime = + new: year: int * month: int * day: int -> unit + 16 overloads + member Add: value: TimeSpan -> DateTime + member AddDays: value: float -> DateTime + member AddHours: value: float -> DateTime + member AddMicroseconds: value: float -> DateTime + member AddMilliseconds: value: float -> DateTime + member AddMinutes: value: float -> DateTime + member AddMonths: months: int -> DateTime + member AddSeconds: value: float -> DateTime + member AddTicks: value: int64 -> DateTime + ...
<summary>Represents an instant in time, typically expressed as a date and time of day.</summary>

--------------------
System.DateTime ()
   (+0 other overloads)
System.DateTime(ticks: int64) : System.DateTime
   (+0 other overloads)
System.DateTime(ticks: int64, kind: System.DateTimeKind) : System.DateTime
   (+0 other overloads)
System.DateTime(date: System.DateOnly, time: System.TimeOnly) : System.DateTime
   (+0 other overloads)
System.DateTime(year: int, month: int, day: int) : System.DateTime
   (+0 other overloads)
System.DateTime(date: System.DateOnly, time: System.TimeOnly, kind: System.DateTimeKind) : System.DateTime
   (+0 other overloads)
System.DateTime(year: int, month: int, day: int, calendar: System.Globalization.Calendar) : System.DateTime
   (+0 other overloads)
System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : System.DateTime
   (+0 other overloads)
System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: System.DateTimeKind) : System.DateTime
   (+0 other overloads)
System.DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: System.Globalization.Calendar) : System.DateTime
   (+0 other overloads)
+
property System.DateTime.Now: System.DateTime with get
<summary>Gets a <see cref="T:System.DateTime" /> object that is set to the current date and time on this computer, expressed as the local time.</summary>
<returns>An object whose value is the current local date and time.</returns>
+
val results: FSharpCheckProjectResults
+
member FSharpChecker.ParseAndCheckProject: options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckProjectResults>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
+
property FSharpCheckProjectResults.Diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic array with get
<summary> + The errors returned by processing the project +</summary>
+
property FSharpCheckProjectResults.AssemblySignature: FSharp.Compiler.Symbols.FSharpAssemblySignature with get
<summary> + Get a view of the overall signature of the assembly. Only valid to use if HasCriticalErrors is false. +</summary>
+
property FSharp.Compiler.Symbols.FSharpAssemblySignature.Entities: System.Collections.Generic.IList<FSharp.Compiler.Symbols.FSharpEntity> with get
<summary> + The (non-nested) module and type definitions in this signature +</summary>
+
property System.Collections.Generic.ICollection.Count: int with get
<summary>Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.</summary>
<returns>The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.</returns>
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/index.html b/fcs/index.html new file mode 100644 index 0000000000..6e571bc309 --- /dev/null +++ b/fcs/index.html @@ -0,0 +1,661 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Service | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

FSharp.Compiler.Service

+

The FSharp.Compiler.Service package is a component derived from the F# compiler source code that +exposes additional functionality for implementing F# language bindings, additional +tools based on the compiler or refactoring tools. The package also includes +dynamic execution of F# code that can be used for embedding F# scripting into your applications.

+

Available services

+

The project currently exposes the following services that are tested & documented on this page. +The libraries contain additional public API that can be used, but is not documented here.

+ +
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published

+
+

The Public Surface Area

+

We are in the process of cleaning up the surface area of FCS to allow it to be fully binary compatible going forward.

+

The full current surface area can be seen at: https://fsharp.github.io/fsharp-compiler-docs/reference/index.html

+

The API is generally designed with F#/.NET design conventions (e.g. types in namespaces, not modules, no nesting of modules etc.) and we must continue to iterate to make this so.

+

The parts of the compiler under FSharp.Compiler.AbstractIL.* are "incidental" and not really designed for public use apart from the hook for JetBrains Rider (Aside: In theory all these other parts could be renamed to FSharp.Compiler though there's no need to do that right now). These internal parts tend to be implemented with the "module containing lots of stuff in one big file" approach for layers of the compiler.

+

Basics - Syntax, Text and Diagnostics

+ +

Tokenization

+ +

Symbols and Code Analysis

+ +

Editor Services

+ +

Interactive Execution

+ +

Internal extension points

+ +

Projects using the F# Compiler Services

+

Some of the projects using the F# Compiler Services are:

+ +

Older things:

+ +

Contributing and copyright

+

The F# source code is copyright by Microsoft Corporation and contributors.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/interactive.html b/fcs/interactive.html new file mode 100644 index 0000000000..d2fcdc4097 --- /dev/null +++ b/fcs/interactive.html @@ -0,0 +1,954 @@ + + + + + + + + + + + + + + + + + + Tutorial: Hosted execution | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Interactive Service: Embedding F# Interactive

+

This tutorial demonstrates how to embed F# interactive in your application. F# interactive +is an interactive scripting environment that compiles F# code into highly efficient IL code +and executes it on the fly. The F# interactive service allows you to embed F# evaluation in +your application.

+
+

NOTE: There is a number of options for embedding F# Interactive. The easiest one is to use the +fsi.exe process and communicate with it using standard input and standard output. In this +tutorial, we look at calling F# Interactive directly through .NET API. However, if you have +no control over the input, it is a good idea to run F# interactive in a separate process. +One reason is that there is no way to handle StackOverflowException and so a poorly written +script can terminate the host process. Remember that while calling F# Interactive through .NET API, +--shadowcopyreferences option will be ignored. For detailed discussion, please take a look at +this thread. +NOTE: If FsiEvaluationSession.Create fails with an error saying that FSharp.Core.dll cannot be found, +add the FSharp.Core.sigdata and FSharp.Core.optdata files. More info here.

+
+

However, the F# interactive service is still useful, because you might want to wrap it in your +own executable that is then executed (and communicates with the rest of your application), or +if you only need to execute a limited subset of F# code (e.g. generated by your own DSL).

+

Starting the F# interactive

+

First, we need to reference the libraries that contain the F# interactive service:

+
#r "FSharp.Compiler.Service.dll"
+
+open FSharp.Compiler.Interactive.Shell
+open FSharp.Compiler.Tokenization
+
+

To communicate with F# interactive, we need to create streams that represent input and +output. We will use those later to read the output printed as a result of evaluating some +F# code that prints:

+
open System
+open System.IO
+open System.Text
+
+// Initialize output and input streams
+let sbOut = new StringBuilder()
+let sbErr = new StringBuilder()
+let inStream = new StringReader("")
+let outStream = new StringWriter(sbOut)
+let errStream = new StringWriter(sbErr)
+
+// Build command line arguments & start FSI session
+let argv = [| "C:\\fsi.exe" |]
+
+let allArgs =
+    Array.append argv [| "--noninteractive" |]
+
+let fsiConfig =
+    FsiEvaluationSession.GetDefaultConfiguration()
+
+let fsiSession =
+    FsiEvaluationSession.Create(fsiConfig, allArgs, inStream, outStream, errStream)
+
+

Evaluating and executing code

+

The F# interactive service exposes several methods that can be used for evaluation. The first +is EvalExpression which evaluates an expression and returns its result. The result contains +the returned value (as obj) and the statically inferred type of the value:

+
/// Evaluate expression & return the result
+let evalExpression text =
+    match fsiSession.EvalExpression(text) with
+    | Some value -> printfn "%A" value.ReflectionValue
+    | None -> printfn "Got no result!"
+
+

This takes a string as an argument and evaluates (i.e. executes) it as F# code.

+
evalExpression "42+1" // prints '43'
+
+

This can be used in a strongly typed way as follows:

+
/// Evaluate expression & return the result, strongly typed
+let evalExpressionTyped<'T> (text) =
+    match fsiSession.EvalExpression(text) with
+    | Some value -> value.ReflectionValue |> unbox<'T>
+    | None -> failwith "Got no result!"
+
+evalExpressionTyped<int> "42+1" // gives '43'
+
+

The EvalInteraction method can be used to evaluate side-effectful operations +such as printing, declarations, or other interactions that are not valid F# expressions, but can be entered in +the F# Interactive console. Such commands include #time "on" (and other directives), open System +all declarations and other top-level statements. The code +does not require ;; at the end. Just enter the code that you want to execute:

+
fsiSession.EvalInteraction "printfn \"bye\""
+
+

The EvalScript method allows to evaluate a complete .fsx script.

+
File.WriteAllText("sample.fsx", "let twenty = 10 + 10")
+fsiSession.EvalScript "sample.fsx"
+
+

Catching errors

+

EvalExpression, EvalInteraction and EvalScript are awkward if the +code has type checking warnings or errors, or if evaluation fails with an exception. +In these cases you can use EvalExpressionNonThrowing, EvalInteractionNonThrowing +and EvalScriptNonThrowing. These return a tuple of a result and an array of FSharpDiagnostic values. +These represent the errors and warnings. The result part is a Choice<_,_> between an actual +result and an exception.

+

The result part of EvalExpression and EvalExpressionNonThrowing is an optional FSharpValue. +If that value is not present then it just indicates that the expression didn't have a tangible +result that could be represented as a .NET object. This situation shouldn't actually +occur for any normal input expressions, and only for primitives used in libraries.

+
File.WriteAllText("sample.fsx", "let twenty = 'a' + 10.0")
+
+let result, warnings =
+    fsiSession.EvalScriptNonThrowing "sample.fsx"
+
+// show the result
+match result with
+| Choice1Of2 () -> printfn "checked and executed ok"
+| Choice2Of2 exn -> printfn "execution exception: %s" exn.Message
+
+

Gives:

+
execution exception: Operation could not be completed due to earlier error
+
+
// show the errors and warnings
+for w in warnings do
+    printfn "Warning %s at %d,%d" w.Message w.StartLine w.StartColumn
+
+

Gives:

+
Warning The type 'float' does not match the type 'char' at 1,19
+Warning The type 'float' does not match the type 'char' at 1,17
+
+

For expressions:

+
let evalExpressionTyped2<'T> text =
+    let res, warnings =
+        fsiSession.EvalExpressionNonThrowing(text)
+
+    for w in warnings do
+        printfn "Warning %s at %d,%d" w.Message w.StartLine w.StartColumn
+
+    match res with
+    | Choice1Of2 (Some value) -> value.ReflectionValue |> unbox<'T>
+    | Choice1Of2 None -> failwith "null or no result"
+    | Choice2Of2 (exn: exn) -> failwith (sprintf "exception %s" exn.Message)
+
+evalExpressionTyped2<int> "42+1" // gives '43'
+
+

Executing in parallel

+

By default the code passed to EvalExpression is executed immediately. To execute in parallel, submit a computation that starts a task:

+
open System.Threading.Tasks
+
+let sampleLongRunningExpr =
+    """
+async {
+    // The code of what you want to run
+    do System.Threading.Thread.Sleep 5000
+    return 10
+}
+  |> Async.StartAsTask"""
+
+let task1 =
+    evalExpressionTyped<Task<int>> (sampleLongRunningExpr)
+
+let task2 =
+    evalExpressionTyped<Task<int>> (sampleLongRunningExpr)
+
+

Both computations have now started. You can now fetch the results:

+
task1.Result // gives the result after completion (up to 5 seconds)
+task2.Result // gives the result after completion (up to 5 seconds)
+
+

Type checking in the evaluation context

+

Let's assume you have a situation where you would like to typecheck code +in the context of the F# Interactive scripting session. For example, you first +evaluate a declaration:

+
fsiSession.EvalInteraction "let xxx = 1 + 1"
+
+

Now you want to typecheck the partially complete code xxx + xx

+
let parseResults, checkResults, checkProjectResults =
+    fsiSession.ParseAndCheckInteraction("xxx + xx")
+
+

The parseResults and checkResults have types ParseFileResults and CheckFileResults +explained in Editor. You can, for example, look at the type errors in the code:

+
checkResults.Diagnostics.Length // 1
+
+

The code is checked with respect to the logical type context available in the F# interactive session +based on the declarations executed so far.

+

You can also request declaration list information, tooltip text and symbol resolution:

+
// get a tooltip
+checkResults.GetToolTip(1, 2, "xxx + xx", [ "xxx" ], FSharpTokenTag.IDENT)
+
+checkResults.GetSymbolUseAtLocation(1, 2, "xxx + xx", [ "xxx" ]) // symbol xxx
+
+

The 'fsi' object

+

If you want your scripting code to be able to access the 'fsi' object, you should pass in an implementation of this object explicitly. +Normally the one from FSharp.Compiler.Interactive.Settings.dll is used.

+
let fsiConfig2 =
+    FsiEvaluationSession.GetDefaultConfiguration(fsiSession)
+
+

Collectible code generation

+

Evaluating code in using FsiEvaluationSession generates a .NET dynamic assembly and uses other resources. +You can make generated code collectible by passing collectible=true. However, code will only +be collected if there are no outstanding object references involving types, for example +FsiValue objects returned by EvalExpression, and you must have disposed the FsiEvaluationSession. +See also Restrictions on Collectible Assemblies.

+

The example below shows the creation of 200 evaluation sessions. Note that collectible=true and +use session = ... are both used.

+

If collectible code is working correctly, +overall resource usage will not increase linearly as the evaluation progresses.

+
let collectionTest () =
+
+    for i in 1 .. 200 do
+        let defaultArgs =
+            [| "fsi.exe"
+               "--noninteractive"
+               "--nologo"
+               "--gui-" |]
+
+        use inStream = new StringReader("")
+        use outStream = new StringWriter()
+        use errStream = new StringWriter()
+
+        let fsiConfig =
+            FsiEvaluationSession.GetDefaultConfiguration()
+
+        use session =
+            FsiEvaluationSession.Create(fsiConfig, defaultArgs, inStream, outStream, errStream, collectible = true)
+
+        session.EvalInteraction(sprintf "type D = { v : int }")
+
+        let v =
+            session.EvalExpression(sprintf "{ v = 42 * %d }" i)
+
+        printfn "iteration %d, result = %A" i v.Value.ReflectionValue
+
+// collectionTest()  <-- run the test like this
+
+ +
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.Interactive
+
module Shell + +from FSharp.Compiler.Interactive
+
namespace FSharp.Compiler.Tokenization
+
namespace System
+
namespace System.IO
+
namespace System.Text
+
val sbOut: StringBuilder
+
Multiple items
type StringBuilder = + interface ISerializable + new: unit -> unit + 5 overloads + member Append: value: bool -> StringBuilder + 25 overloads + member AppendFormat: provider: IFormatProvider * format: string * arg0: obj -> StringBuilder + 12 overloads + member AppendJoin: separator: char * [<ParamArray>] values: obj array -> StringBuilder + 5 overloads + member AppendLine: unit -> StringBuilder + 3 overloads + member Clear: unit -> StringBuilder + member CopyTo: sourceIndex: int * destination: char array * destinationIndex: int * count: int -> unit + 1 overload + member EnsureCapacity: capacity: int -> int + member Equals: span: ReadOnlySpan<char> -> bool + 1 overload + ...
<summary>Represents a mutable string of characters. This class cannot be inherited.</summary>

--------------------
StringBuilder() : StringBuilder
StringBuilder(capacity: int) : StringBuilder
StringBuilder(value: string) : StringBuilder
StringBuilder(capacity: int, maxCapacity: int) : StringBuilder
StringBuilder(value: string, capacity: int) : StringBuilder
StringBuilder(value: string, startIndex: int, length: int, capacity: int) : StringBuilder
+
val sbErr: StringBuilder
+
val inStream: StringReader
+
Multiple items
type StringReader = + inherit TextReader + new: s: string -> unit + member Close: unit -> unit + member Peek: unit -> int + member Read: unit -> int + 2 overloads + member ReadAsync: buffer: char array * index: int * count: int -> Task<int> + 1 overload + member ReadBlock: buffer: Span<char> -> int + member ReadBlockAsync: buffer: char array * index: int * count: int -> Task<int> + 1 overload + member ReadLine: unit -> string + member ReadLineAsync: unit -> Task<string> + 1 overload + ...
<summary>Implements a <see cref="T:System.IO.TextReader" /> that reads from a string.</summary>

--------------------
StringReader(s: string) : StringReader
+
val outStream: StringWriter
+
Multiple items
type StringWriter = + inherit TextWriter + new: unit -> unit + 3 overloads + member Close: unit -> unit + member FlushAsync: unit -> Task + member GetStringBuilder: unit -> StringBuilder + member ToString: unit -> string + member Write: value: char -> unit + 4 overloads + member WriteAsync: value: char -> Task + 4 overloads + member WriteLine: buffer: ReadOnlySpan<char> -> unit + 1 overload + member WriteLineAsync: value: char -> Task + 4 overloads + ...
<summary>Implements a <see cref="T:System.IO.TextWriter" /> for writing information to a string. The information is stored in an underlying <see cref="T:System.Text.StringBuilder" />.</summary>

--------------------
StringWriter() : StringWriter
StringWriter(formatProvider: IFormatProvider) : StringWriter
StringWriter(sb: StringBuilder) : StringWriter
StringWriter(sb: StringBuilder, formatProvider: IFormatProvider) : StringWriter
+
val errStream: StringWriter
+
val argv: string array
+
val allArgs: string array
+
type Array = + interface ICollection + interface IEnumerable + interface IList + interface IStructuralComparable + interface IStructuralEquatable + interface ICloneable + member Clone: unit -> obj + member CopyTo: array: Array * index: int -> unit + 1 overload + member GetEnumerator: unit -> IEnumerator + member GetLength: dimension: int -> int + ...
<summary>Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.</summary>
+
val append: array1: 'T array -> array2: 'T array -> 'T array
+
val fsiConfig: FsiEvaluationSessionHostConfig
+
type FsiEvaluationSession = + interface IDisposable + member AddBoundValue: name: string * value: obj -> unit + member EvalExpression: code: string -> FsiValue option + 1 overload + member EvalExpressionNonThrowing: code: string -> Choice<FsiValue option,exn> * FSharpDiagnostic array + 1 overload + member EvalInteraction: code: string * ?cancellationToken: CancellationToken -> unit + 1 overload + member EvalInteractionNonThrowing: code: string * ?cancellationToken: CancellationToken -> Choice<FsiValue option,exn> * FSharpDiagnostic array + 1 overload + member EvalScript: filePath: string -> unit + member EvalScriptNonThrowing: filePath: string -> Choice<unit,exn> * FSharpDiagnostic array + member FormatValue: reflectionValue: obj * reflectionType: Type -> string + member GetBoundValues: unit -> FsiBoundValue list + ...
<summary> + Represents an F# Interactive evaluation session. +</summary>
+
static member FsiEvaluationSession.GetDefaultConfiguration: unit -> FsiEvaluationSessionHostConfig
static member FsiEvaluationSession.GetDefaultConfiguration: fsiObj: obj -> FsiEvaluationSessionHostConfig
static member FsiEvaluationSession.GetDefaultConfiguration: fsiObj: obj * useFsiAuxLib: bool -> FsiEvaluationSessionHostConfig
+
val fsiSession: FsiEvaluationSession
+
static member FsiEvaluationSession.Create: fsiConfig: FsiEvaluationSessionHostConfig * argv: string array * inReader: TextReader * outWriter: TextWriter * errorWriter: TextWriter * ?collectible: bool * ?legacyReferenceResolver: FSharp.Compiler.CodeAnalysis.LegacyReferenceResolver -> FsiEvaluationSession
+
val evalExpression: text: string -> unit
 Evaluate expression & return the result
+
val text: string
+
member FsiEvaluationSession.EvalExpression: code: string -> FsiValue option
member FsiEvaluationSession.EvalExpression: code: string * scriptFileName: string -> FsiValue option
+
union case Option.Some: Value: 'T -> Option<'T>
+
val value: FsiValue
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
property FsiValue.ReflectionValue: obj with get
<summary> + The value, as an object +</summary>
+
union case Option.None: Option<'T>
+
val evalExpressionTyped: text: string -> 'T
 Evaluate expression & return the result, strongly typed
+
'T
+
val unbox: value: obj -> 'T
+
val failwith: message: string -> 'T
+
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+
member FsiEvaluationSession.EvalInteraction: code: string * ?cancellationToken: Threading.CancellationToken -> unit
member FsiEvaluationSession.EvalInteraction: code: string * scriptFileName: string * ?cancellationToken: Threading.CancellationToken -> unit
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: Encoding) : unit
+
member FsiEvaluationSession.EvalScript: filePath: string -> unit
+
val result: Choice<unit,exn>
+
val warnings: FSharp.Compiler.Diagnostics.FSharpDiagnostic array
+
member FsiEvaluationSession.EvalScriptNonThrowing: filePath: string -> Choice<unit,exn> * FSharp.Compiler.Diagnostics.FSharpDiagnostic array
+
union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>
+
union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>
+
Multiple items
val exn: exn

--------------------
type exn = Exception
+
property Exception.Message: string with get
+
val w: FSharp.Compiler.Diagnostics.FSharpDiagnostic
+
property FSharp.Compiler.Diagnostics.FSharpDiagnostic.Message: string with get
<summary> + Gets the message for the diagnostic +</summary>
+
property FSharp.Compiler.Diagnostics.FSharpDiagnostic.StartLine: int with get
<summary> + Gets the start line for the diagnostic +</summary>
+
property FSharp.Compiler.Diagnostics.FSharpDiagnostic.StartColumn: int with get
<summary> + Gets the start column for the diagnostic +</summary>
+
val evalExpressionTyped2: text: string -> 'T
+
val res: Choice<FsiValue option,exn>
+
member FsiEvaluationSession.EvalExpressionNonThrowing: code: string -> Choice<FsiValue option,exn> * FSharp.Compiler.Diagnostics.FSharpDiagnostic array
member FsiEvaluationSession.EvalExpressionNonThrowing: code: string * scriptFileName: string -> Choice<FsiValue option,exn> * FSharp.Compiler.Diagnostics.FSharpDiagnostic array
+
val sprintf: format: Printf.StringFormat<'T> -> 'T
+
namespace System.Threading
+
namespace System.Threading.Tasks
+
val sampleLongRunningExpr: string
+
val task1: Task<int>
+
Multiple items
type Task = + interface IAsyncResult + interface IDisposable + new: action: Action -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable + 1 overload + member ContinueWith: continuationAction: Action<Task,obj> * state: obj -> Task + 19 overloads + member Dispose: unit -> unit + member GetAwaiter: unit -> TaskAwaiter + member RunSynchronously: unit -> unit + 1 overload + member Start: unit -> unit + 1 overload + member Wait: unit -> unit + 5 overloads + ...
<summary>Represents an asynchronous operation.</summary>

--------------------
type Task<'TResult> = + inherit Task + new: ``function`` : Func<obj,'TResult> * state: obj -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable<'TResult> + 1 overload + member ContinueWith: continuationAction: Action<Task<'TResult>,obj> * state: obj -> Task + 19 overloads + member GetAwaiter: unit -> TaskAwaiter<'TResult> + member WaitAsync: cancellationToken: CancellationToken -> Task<'TResult> + 4 overloads + member Result: 'TResult + static member Factory: TaskFactory<'TResult>
<summary>Represents an asynchronous operation that can return a value.</summary>
<typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>

--------------------
Task(action: Action) : Task
Task(action: Action, cancellationToken: Threading.CancellationToken) : Task
Task(action: Action, creationOptions: TaskCreationOptions) : Task
Task(action: Action<obj>, state: obj) : Task
Task(action: Action, cancellationToken: Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task
Task(action: Action<obj>, state: obj, cancellationToken: Threading.CancellationToken) : Task
Task(action: Action<obj>, state: obj, creationOptions: TaskCreationOptions) : Task
Task(action: Action<obj>, state: obj, cancellationToken: Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task

--------------------
Task(``function`` : Func<'TResult>) : Task<'TResult>
Task(``function`` : Func<obj,'TResult>, state: obj) : Task<'TResult>
Task(``function`` : Func<'TResult>, cancellationToken: Threading.CancellationToken) : Task<'TResult>
Task(``function`` : Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : Func<obj,'TResult>, state: obj, cancellationToken: Threading.CancellationToken) : Task<'TResult>
Task(``function`` : Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : Func<'TResult>, cancellationToken: Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : Func<obj,'TResult>, state: obj, cancellationToken: Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
+
val task2: Task<int>
+
property Task.Result: int with get
<summary>Gets the result value of this <see cref="T:System.Threading.Tasks.Task`1" />.</summary>
<exception cref="T:System.AggregateException">The task was canceled. The <see cref="P:System.AggregateException.InnerExceptions" /> collection contains a <see cref="T:System.Threading.Tasks.TaskCanceledException" /> object. + + -or- + + An exception was thrown during the execution of the task. The <see cref="P:System.AggregateException.InnerExceptions" /> collection contains information about the exception or exceptions.</exception>
<returns>The result value of this <see cref="T:System.Threading.Tasks.Task`1" />, which is of the same type as the task's type parameter.</returns>
+
val parseResults: FSharp.Compiler.CodeAnalysis.FSharpParseFileResults
+
val checkResults: FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults
+
val checkProjectResults: FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults
+
member FsiEvaluationSession.ParseAndCheckInteraction: code: string -> FSharp.Compiler.CodeAnalysis.FSharpParseFileResults * FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults * FSharp.Compiler.CodeAnalysis.FSharpCheckProjectResults
+
property FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults.Diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic array with get
<summary> + The errors returned by parsing a source file. +</summary>
+
property Array.Length: int with get
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue">Int32.MaxValue</see> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
+
member FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults.GetToolTip: line: int * colAtEndOfNames: int * lineText: string * names: string list * tokenTag: int * ?width: int -> FSharp.Compiler.EditorServices.ToolTipText
+
module FSharpTokenTag + +from FSharp.Compiler.Tokenization
<summary> + Some of the values in the field FSharpTokenInfo.Tag +</summary>
+
val IDENT: int
<summary> + Indicates the token is an identifier (synonym for FSharpTokenTag.Identifier) +</summary>
+
member FSharp.Compiler.CodeAnalysis.FSharpCheckFileResults.GetSymbolUseAtLocation: line: int * colAtEndOfNames: int * lineText: string * names: string list -> FSharp.Compiler.CodeAnalysis.FSharpSymbolUse option
+
val fsiConfig2: FsiEvaluationSessionHostConfig
+
val collectionTest: unit -> unit
+
val i: int32
+
val defaultArgs: string array
+
val session: FsiEvaluationSession
+
val v: FsiValue option
+
property Option.Value: FsiValue with get
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/project.html b/fcs/project.html new file mode 100644 index 0000000000..650e5b744a --- /dev/null +++ b/fcs/project.html @@ -0,0 +1,1084 @@ + + + + + + + + + + + + + + + + + + Tutorial: Project analysis | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Project Analysis

+

This tutorial demonstrates how you can analyze a whole project using services provided by the F# compiler.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.

+
+

Getting whole-project results

+

As in the previous tutorial (using untyped AST), we start by referencing +FSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance +of InteractiveChecker:

+
// Reference F# compiler API
+#r "FSharp.Compiler.Service.dll"
+
+open System
+open System.Collections.Generic
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Text
+
+// Create an interactive checker instance
+let checker = FSharpChecker.Create()
+
+

Here are our sample inputs:

+
module Inputs =
+    open System.IO
+
+    let base1 = Path.GetTempFileName()
+    let fileName1 = Path.ChangeExtension(base1, ".fs")
+    let base2 = Path.GetTempFileName()
+    let fileName2 = Path.ChangeExtension(base2, ".fs")
+    let dllName = Path.ChangeExtension(base2, ".dll")
+    let projFileName = Path.ChangeExtension(base2, ".fsproj")
+
+    let fileSource1 =
+        """
+module M
+
+type C() =
+    member x.P = 1
+
+let xxx = 3 + 4
+let fff () = xxx + xxx
+    """
+
+    File.WriteAllText(fileName1, fileSource1)
+
+    let fileSource2 =
+        """
+module N
+
+open M
+
+type D1() =
+    member x.SomeProperty = M.xxx
+
+type D2() =
+    member x.SomeProperty = M.fff() + D1().P
+
+// Generate a warning
+let y2 = match 1 with 1 -> M.xxx
+    """
+
+    File.WriteAllText(fileName2, fileSource2)
+
+

We use GetProjectOptionsFromCommandLineArgs to treat two files as a project:

+
let projectOptions =
+    let sysLib nm =
+        if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then
+            // file references only valid on Windows
+            System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
+            + @"\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\"
+            + nm
+            + ".dll"
+        else
+            let sysDir =
+                System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()
+
+            let (++) a b = System.IO.Path.Combine(a, b)
+            sysDir ++ nm + ".dll"
+
+    let fsCore4300 () =
+        if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then
+            // file references only valid on Windows
+            System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
+            + @"\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0\FSharp.Core.dll"
+        else
+            sysLib "FSharp.Core"
+
+    checker.GetProjectOptionsFromCommandLineArgs(
+        Inputs.projFileName,
+        [| yield "--simpleresolution"
+           yield "--noframework"
+           yield "--debug:full"
+           yield "--define:DEBUG"
+           yield "--optimize-"
+           yield "--out:" + Inputs.dllName
+           yield "--doc:test.xml"
+           yield "--warn:3"
+           yield "--fullpaths"
+           yield "--flaterrors"
+           yield "--target:library"
+           yield Inputs.fileName1
+           yield Inputs.fileName2
+           let references =
+               [ sysLib "mscorlib"
+                 sysLib "System"
+                 sysLib "System.Core"
+                 fsCore4300 () ]
+
+           for r in references do
+               yield "-r:" + r |]
+    )
+
+

Now check the entire project (using the files saved on disk):

+
let wholeProjectResults =
+    checker.ParseAndCheckProject(projectOptions)
+    |> Async.RunSynchronously
+
+

Now look at the errors and warnings:

+
wholeProjectResults.Diagnostics.Length // 1
+
+wholeProjectResults.Diagnostics.[0]
+    .Message.Contains("Incomplete pattern matches on this expression") // yes it does
+
+wholeProjectResults.Diagnostics.[0].StartLine
+wholeProjectResults.Diagnostics.[0].EndLine
+wholeProjectResults.Diagnostics.[0].StartColumn
+wholeProjectResults.Diagnostics.[0].EndColumn
+
+

Now look at the inferred signature for the project:

+
[ for x in wholeProjectResults.AssemblySignature.Entities -> x.DisplayName ] // ["N"; "M"]
+
+[ for x in
+      wholeProjectResults.AssemblySignature.Entities.[0]
+          .NestedEntities -> x.DisplayName ] // ["D1"; "D2"]
+
+[ for x in
+      wholeProjectResults.AssemblySignature.Entities.[1]
+          .NestedEntities -> x.DisplayName ] // ["C"]
+
+[ for x in
+      wholeProjectResults.AssemblySignature.Entities.[0]
+          .MembersFunctionsAndValues -> x.DisplayName ] // ["y"; "y2"]
+
+

You can also get all symbols in the project:

+
let rec allSymbolsInEntities (entities: IList<FSharpEntity>) =
+    [ for e in entities do
+          yield (e :> FSharpSymbol)
+
+          for x in e.MembersFunctionsAndValues do
+              yield (x :> FSharpSymbol)
+
+          for x in e.UnionCases do
+              yield (x :> FSharpSymbol)
+
+          for x in e.FSharpFields do
+              yield (x :> FSharpSymbol)
+
+          yield! allSymbolsInEntities e.NestedEntities ]
+
+let allSymbols =
+    allSymbolsInEntities wholeProjectResults.AssemblySignature.Entities
+
+

After checking the whole project, you can access the background results for individual files +in the project. This will be fast and will not involve any additional checking.

+
let backgroundParseResults1, backgroundTypedParse1 =
+    checker.GetBackgroundCheckResultsForFileInProject(Inputs.fileName1, projectOptions)
+    |> Async.RunSynchronously
+
+

You can now resolve symbols in each file:

+
let xSymbolUseOpt =
+    backgroundTypedParse1.GetSymbolUseAtLocation(9, 9, "", [ "xxx" ])
+
+let xSymbolUse = xSymbolUseOpt.Value
+
+let xSymbol = xSymbolUse.Symbol
+
+

You can find out more about a symbol by doing type checks on various symbol kinds:

+
let xSymbolAsValue =
+    match xSymbol with
+    | :? FSharpMemberOrFunctionOrValue as xSymbolAsVal -> xSymbolAsVal
+    | _ -> failwith "we expected this to be a member, function or value"
+
+

For each symbol, you can look up the references to that symbol:

+
let usesOfXSymbol =
+    wholeProjectResults.GetUsesOfSymbol(xSymbol)
+
+

You can iterate all the defined symbols in the inferred signature and find where they are used:

+
let allUsesOfAllSignatureSymbols =
+    [ for s in allSymbols do
+          let uses = wholeProjectResults.GetUsesOfSymbol(s)
+          yield s.ToString(), uses ]
+
+

You can also look at all the symbols uses in the whole project (including uses of symbols with local scope)

+
let allUsesOfAllSymbols =
+    wholeProjectResults.GetAllUsesOfAllSymbols()
+
+

You can also request checks of updated versions of files within the project (note that the other files +in the project are still read from disk, unless you are using the FileSystem API):

+
let parseResults1, checkAnswer1 =
+    checker.ParseAndCheckFileInProject(Inputs.fileName1, 0, SourceText.ofString Inputs.fileSource1, projectOptions)
+    |> Async.RunSynchronously
+
+let checkResults1 =
+    match checkAnswer1 with
+    | FSharpCheckFileAnswer.Succeeded x -> x
+    | _ -> failwith "unexpected aborted"
+
+let parseResults2, checkAnswer2 =
+    checker.ParseAndCheckFileInProject(Inputs.fileName2, 0, SourceText.ofString Inputs.fileSource2, projectOptions)
+    |> Async.RunSynchronously
+
+let checkResults2 =
+    match checkAnswer2 with
+    | FSharpCheckFileAnswer.Succeeded x -> x
+    | _ -> failwith "unexpected aborted"
+
+

Again, you can resolve symbols and ask for references:

+
let xSymbolUse2Opt =
+    checkResults1.GetSymbolUseAtLocation(9, 9, "", [ "xxx" ])
+
+let xSymbolUse2 = xSymbolUse2Opt.Value
+
+let xSymbol2 = xSymbolUse2.Symbol
+
+let usesOfXSymbol2 =
+    wholeProjectResults.GetUsesOfSymbol(xSymbol2)
+
+

Or ask for all the symbols uses in the file (including uses of symbols with local scope)

+
let allUsesOfAllSymbolsInFile1 =
+    checkResults1.GetAllUsesOfAllSymbolsInFile()
+
+

Or ask for all the uses of one symbol in one file:

+
let allUsesOfXSymbolInFile1 =
+    checkResults1.GetUsesOfSymbolInFile(xSymbol2)
+
+let allUsesOfXSymbolInFile2 =
+    checkResults2.GetUsesOfSymbolInFile(xSymbol2)
+
+

Analyzing multiple projects

+

If you have multiple F# projects to analyze which include references from some projects to others, +then the simplest way to do this is to build the projects and specify the cross-project references using +a -r:path-to-output-of-project.dll argument in the ProjectOptions. However, this requires the build +of each project to succeed, producing the DLL file on disk which can be referred to.

+

In some situations, e.g. in an IDE, you may wish to allow references to other F# projects prior to successful compilation to +a DLL. To do this, fill in the ProjectReferences entry in ProjectOptions, which recursively specifies the project +options for dependent projects. Each project reference still needs a corresponding -r:path-to-output-of-project.dll +command line argument in ProjectOptions, along with an entry in ProjectReferences. +The first element of each tuple in the ProjectReferences entry should be the DLL name, i.e. path-to-output-of-project.dll. +This should be the same as the text used in the -r project reference.

+

When a project reference is used, the analysis will make use of the results of incremental +analysis of the referenced F# project from source files, without requiring the compilation of these files to DLLs.

+

To efficiently analyze a set of F# projects which include cross-references, you should populate the ProjectReferences +correctly and then analyze each project in turn.

+
+

NOTE: Project references are disabled if the assembly being referred to contains type provider components - +specifying the project reference will have no effect beyond forcing the analysis of the project, and the DLL will +still be required on disk.

+
+

Summary

+

As you have seen, the ParseAndCheckProject lets you access results of project-wide analysis +such as symbol references. To learn more about working with symbols, see Symbols.

+

Using the FSharpChecker component in multi-project, incremental and interactive editing situations may involve +knowledge of the FSharpChecker operations queue and the FSharpChecker caches.

+ +
namespace System
+
namespace System.Collections
+
namespace System.Collections.Generic
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.Symbols
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

--------------------
type FSharpAttribute = + member Format: context: FSharpDisplayContext -> string + member IsAttribute: unit -> bool + member AttributeType: FSharpEntity + member ConstructorArguments: IList<FSharpType * obj> + member IsUnresolved: bool + member NamedArguments: IList<FSharpType * string * bool * obj> + member Range: range
<summary> + Represents a custom attribute attached to F# source code or a compiler .NET component +</summary>
+
namespace FSharp.Compiler.Text
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
namespace System.IO
+
val base1: 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.GetTempFileName() : string
+
val fileName1: string
+
Path.ChangeExtension(path: string, extension: string) : string
+
val base2: string
+
val fileName2: string
+
val dllName: string
+
val projFileName: string
+
val fileSource1: string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit
+
val fileSource2: string
+
val projectOptions: FSharpProjectOptions
+
val sysLib: nm: string -> string
+
val nm: string
+
type Environment = + static member Exit: exitCode: int -> unit + static member ExpandEnvironmentVariables: name: string -> string + static member FailFast: message: string -> unit + 1 overload + static member GetCommandLineArgs: unit -> string array + static member GetEnvironmentVariable: variable: string -> string + 1 overload + static member GetEnvironmentVariables: unit -> IDictionary + 1 overload + static member GetFolderPath: folder: SpecialFolder -> string + 1 overload + static member GetLogicalDrives: unit -> string array + static member SetEnvironmentVariable: variable: string * value: string -> unit + 1 overload + static member CommandLine: string + ...
<summary>Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.</summary>
+
property Environment.OSVersion: OperatingSystem with get
<summary>Gets the current platform identifier and version number.</summary>
<exception cref="T:System.InvalidOperationException">This property was unable to obtain the system version. + + -or- + + The obtained platform identifier is not a member of <see cref="T:System.PlatformID" /></exception>
<returns>The platform identifier and version number.</returns>
+
property OperatingSystem.Platform: PlatformID with get
<summary>Gets a <see cref="T:System.PlatformID" /> enumeration value that identifies the operating system platform.</summary>
<returns>One of the <see cref="T:System.PlatformID" /> values.</returns>
+
[<Struct>] +type PlatformID = + | Win32S = 0 + | Win32Windows = 1 + | Win32NT = 2 + | WinCE = 3 + | Unix = 4 + | Xbox = 5 + | MacOSX = 6 + | Other = 7
<summary>Identifies the operating system, or platform, supported by an assembly.</summary>
+
field PlatformID.Win32NT: PlatformID = 2
+
Environment.GetFolderPath(folder: Environment.SpecialFolder) : string
Environment.GetFolderPath(folder: Environment.SpecialFolder, option: Environment.SpecialFolderOption) : string
+
[<Struct>] +type SpecialFolder = + | Desktop = 0 + | Programs = 2 + | MyDocuments = 5 + | Personal = 5 + | Favorites = 6 + | Startup = 7 + | Recent = 8 + | SendTo = 9 + | StartMenu = 11 + | MyMusic = 13 + ...
<summary>Specifies enumerated constants used to retrieve directory paths to system special folders.</summary>
+
field Environment.SpecialFolder.ProgramFilesX86: Environment.SpecialFolder = 42
+
val sysDir: string
+
namespace System.Runtime
+
namespace System.Runtime.InteropServices
+
type RuntimeEnvironment = + static member FromGlobalAccessCache: a: Assembly -> bool + static member GetRuntimeDirectory: unit -> string + static member GetRuntimeInterfaceAsIntPtr: clsid: Guid * riid: Guid -> nativeint + static member GetRuntimeInterfaceAsObject: clsid: Guid * riid: Guid -> obj + static member GetSystemVersion: unit -> string + static member SystemConfigurationFile: string
<summary>Provides a collection of <see langword="static" /> methods that return information about the common language runtime environment.</summary>
+
Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory() : string
+
val a: string
+
val b: string
+
IO.Path.Combine([<ParamArray>] paths: string array) : string
IO.Path.Combine(path1: string, path2: string) : string
IO.Path.Combine(path1: string, path2: string, path3: string) : string
IO.Path.Combine(path1: string, path2: string, path3: string, path4: string) : string
+
val fsCore4300: unit -> string
+
member FSharpChecker.GetProjectOptionsFromCommandLineArgs: projectFileName: string * argv: string array * ?loadedTimeStamp: DateTime * ?isInteractive: bool * ?isEditing: bool -> FSharpProjectOptions
+
module Inputs + +from Project
+
val references: string list
+
val r: string
+
val wholeProjectResults: FSharpCheckProjectResults
+
member FSharpChecker.ParseAndCheckProject: options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckProjectResults>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: Threading.CancellationToken -> 'T
+
property FSharpCheckProjectResults.Diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic array with get
<summary> + The errors returned by processing the project +</summary>
+
property Array.Length: int with get
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue">Int32.MaxValue</see> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
+
val x: FSharpEntity
+
property FSharpCheckProjectResults.AssemblySignature: FSharpAssemblySignature with get
<summary> + Get a view of the overall signature of the assembly. Only valid to use if HasCriticalErrors is false. +</summary>
+
property FSharpAssemblySignature.Entities: IList<FSharpEntity> with get
<summary> + The (non-nested) module and type definitions in this signature +</summary>
+
property FSharpEntity.DisplayName: string with get
<summary> + Get the name of the type or module as displayed in F# code +</summary>
+
val x: FSharpMemberOrFunctionOrValue
+
property FSharpMemberOrFunctionOrValue.DisplayName: string with get
<summary> + Get the name as presented in F# error messages and documentation +</summary>
+
val allSymbolsInEntities: entities: IList<FSharpEntity> -> FSharpSymbol list
+
val entities: IList<FSharpEntity>
+
type IList<'T> = + inherit ICollection<'T> + inherit IEnumerable<'T> + inherit IEnumerable + override IndexOf: item: 'T -> int + override Insert: index: int * item: 'T -> unit + override RemoveAt: index: int -> unit + member Item: 'T
<summary>Represents a collection of objects that can be individually accessed by index.</summary>
<typeparam name="T">The type of elements in the list.</typeparam>
+
type FSharpEntity = + inherit FSharpSymbol + member AsType: unit -> FSharpType + member GetPublicNestedEntities: unit -> FSharpEntity seq + member TryGetFullCompiledName: unit -> string option + member TryGetFullDisplayName: unit -> string option + member TryGetFullName: unit -> string option + member TryGetMembersFunctionsAndValues: unit -> IList<FSharpMemberOrFunctionOrValue> + member TryGetMetadataText: unit -> ISourceText option + member AbbreviatedType: FSharpType + member AccessPath: string + ...
<summary> + A subtype of FSharpSymbol that represents a type definition or module as seen by the F# language +</summary>
+
val e: FSharpEntity
+
type FSharpSymbol = + member GetEffectivelySameAsHash: unit -> int + member HasAttribute: unit -> bool + member IsAccessible: FSharpAccessibilityRights -> bool + member IsEffectivelySameAs: other: FSharpSymbol -> bool + member TryGetAttribute: unit -> FSharpAttribute option + abstract Accessibility: FSharpAccessibility + member Assembly: FSharpAssembly + abstract Attributes: IList<FSharpAttribute> + member DeclarationLocation: range option + member DisplayName: string + ...
<summary> + Represents a symbol in checked F# source code or a compiled .NET component. + + The subtype of the symbol may reveal further information and can be one of FSharpEntity, FSharpUnionCase + FSharpField, FSharpGenericParameter, FSharpStaticParameter, FSharpMemberOrFunctionOrValue, FSharpParameter, + or FSharpActivePatternCase. +</summary>
+
property FSharpEntity.MembersFunctionsAndValues: IList<FSharpMemberOrFunctionOrValue> with get
<summary> + Get the properties, events and methods of a type definitions, or the functions and values of a module +</summary>
+
val x: FSharpUnionCase
+
property FSharpEntity.UnionCases: IList<FSharpUnionCase> with get
<summary> + Get the cases of a union type +</summary>
+
val x: FSharpField
+
property FSharpEntity.FSharpFields: IList<FSharpField> with get
<summary> + Get the fields of a record, class, struct or enum from the perspective of the F# language. + This includes static fields, the 'val' bindings in classes and structs, and the value definitions in enums. + For classes, the list may include compiler generated fields implied by the use of primary constructors. +</summary>
+
property FSharpEntity.NestedEntities: IList<FSharpEntity> with get
<summary> + Get the modules and types defined in a module, or the nested types of a type +</summary>
+
val allSymbols: FSharpSymbol list
+
val backgroundParseResults1: FSharpParseFileResults
+
val backgroundTypedParse1: FSharpCheckFileResults
+
member FSharpChecker.GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults>
+
val xSymbolUseOpt: FSharpSymbolUse option
+
member FSharpCheckFileResults.GetSymbolUseAtLocation: line: int * colAtEndOfNames: int * lineText: string * names: string list -> FSharpSymbolUse option
+
val xSymbolUse: FSharpSymbolUse
+
property Option.Value: FSharpSymbolUse with get
+
val xSymbol: FSharpSymbol
+
property FSharpSymbolUse.Symbol: FSharpSymbol with get
<summary> + The symbol referenced +</summary>
+
val xSymbolAsValue: FSharpMemberOrFunctionOrValue
+
type FSharpMemberOrFunctionOrValue = + inherit FSharpSymbol + member FormatLayout: displayContext: FSharpDisplayContext -> TaggedText array + member GetOverloads: matchParameterNumber: bool -> IList<FSharpMemberOrFunctionOrValue> option + member GetReturnTypeLayout: displayContext: FSharpDisplayContext -> TaggedText array option + member GetValSignatureText: displayContext: FSharpDisplayContext * m: range -> string option + member GetWitnessPassingInfo: unit -> (string * IList<FSharpParameter>) option + member TryGetFullCompiledOperatorNameIdents: unit -> string array option + member TryGetFullDisplayName: unit -> string option + override Accessibility: FSharpAccessibility + member ApparentEnclosingEntity: FSharpEntity + ...
<summary> + A subtype of F# symbol that represents an F# method, property, event, function or value, including extension members. +</summary>
+
val xSymbolAsVal: FSharpMemberOrFunctionOrValue
+
val failwith: message: string -> 'T
+
val usesOfXSymbol: FSharpSymbolUse array
+
member FSharpCheckProjectResults.GetUsesOfSymbol: symbol: FSharpSymbol * ?cancellationToken: Threading.CancellationToken -> FSharpSymbolUse array
+
val allUsesOfAllSignatureSymbols: (string * FSharpSymbolUse array) list
+
val s: FSharpSymbol
+
val uses: FSharpSymbolUse array
+
Object.ToString() : string
+
val allUsesOfAllSymbols: FSharpSymbolUse array
+
member FSharpCheckProjectResults.GetAllUsesOfAllSymbols: ?cancellationToken: Threading.CancellationToken -> FSharpSymbolUse array
+
val parseResults1: FSharpParseFileResults
+
val checkAnswer1: FSharpCheckFileAnswer
+
member FSharpChecker.ParseAndCheckFileInProject: fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
+
module SourceText + +from FSharp.Compiler.Text
<summary> + Functions related to ISourceText objects +</summary>
+
val ofString: string -> ISourceText
<summary> + Creates an ISourceText object from the given string +</summary>
+
val checkResults1: FSharpCheckFileResults
+
type FSharpCheckFileAnswer = + | Aborted + | Succeeded of FSharpCheckFileResults
<summary> + The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. +</summary>
+
union case FSharpCheckFileAnswer.Succeeded: FSharpCheckFileResults -> FSharpCheckFileAnswer
<summary> + Success +</summary>
+
val x: FSharpCheckFileResults
+
val parseResults2: FSharpParseFileResults
+
val checkAnswer2: FSharpCheckFileAnswer
+
val checkResults2: FSharpCheckFileResults
+
val xSymbolUse2Opt: FSharpSymbolUse option
+
val xSymbolUse2: FSharpSymbolUse
+
val xSymbol2: FSharpSymbol
+
val usesOfXSymbol2: FSharpSymbolUse array
+
val allUsesOfAllSymbolsInFile1: FSharpSymbolUse seq
+
member FSharpCheckFileResults.GetAllUsesOfAllSymbolsInFile: ?cancellationToken: Threading.CancellationToken -> FSharpSymbolUse seq
+
val allUsesOfXSymbolInFile1: FSharpSymbolUse array
+
member FSharpCheckFileResults.GetUsesOfSymbolInFile: symbol: FSharpSymbol * ?cancellationToken: Threading.CancellationToken -> FSharpSymbolUse array
+
val allUsesOfXSymbolInFile2: FSharpSymbolUse array
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/react.html b/fcs/react.html new file mode 100644 index 0000000000..b00b58425b --- /dev/null +++ b/fcs/react.html @@ -0,0 +1,519 @@ + + + + + + + + + + + + + + + + + + Incrementality | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Snapshots, incrementality and reacting to changes

+

FCS is an incremental execution engine. The aim is to make it Roslyn-like. We're not quite there.

+

There are two dimensions of incrementality:

+ +

The logical results of all "Check" routines (ParseAndCheckFileInProject, GetBackgroundCheckResultsForFileInProject, +TryGetRecentTypeCheckResultsForFile, ParseAndCheckProject) depend on results reported by the file system, +especially the IFileSystem implementation described in the tutorial on project wide analysis. +Logically speaking, these results would be different if file system changes occur. For example, +referenced DLLs may change on disk, or referenced files may change.

+

There is work-in-progress to make all parsing and checking deliver results based on immutable snapshots of inputs.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/symbols.html b/fcs/symbols.html new file mode 100644 index 0000000000..3be496c6ce --- /dev/null +++ b/fcs/symbols.html @@ -0,0 +1,931 @@ + + + + + + + + + + + + + + + + + + Tutorial: Symbols | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Working with symbols

+

This tutorial demonstrates how to work with symbols provided by the F# compiler. See also project wide analysis +for information on symbol references.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.

+
+

As usual we start by referencing FSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance +of FSharpChecker:

+
// Reference F# compiler API
+#r "FSharp.Compiler.Service.dll"
+
+open System
+open System.IO
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Text
+
+// Create an interactive checker instance 
+let checker = FSharpChecker.Create()
+
+

We now perform type checking on the specified input:

+
let parseAndTypeCheckSingleFile (file, input) = 
+    // Get context representing a stand-alone (script) file
+    let projOptions, errors = 
+        checker.GetProjectOptionsFromScript(file, input, assumeDotNetFramework=false)
+        |> Async.RunSynchronously
+
+    let parseFileResults, checkFileResults = 
+        checker.ParseAndCheckFileInProject(file, 0, input, projOptions) 
+        |> Async.RunSynchronously
+
+    // Wait until type checking succeeds (or 100 attempts)
+    match checkFileResults with
+    | FSharpCheckFileAnswer.Succeeded(res) -> parseFileResults, res
+    | res -> failwithf "Parsing did not finish... (%A)" res
+
+let file = "/home/user/Test.fsx"
+
+

Getting resolved signature information about the file

+

After type checking a file, you can access the inferred signature of a project up to and including the +checking of the given file through the PartialAssemblySignature property of the TypeCheckResults.

+

The full signature information is available for modules, types, attributes, members, values, functions, +union cases, record types, units of measure and other F# language constructs.

+

The typed expression trees are also available, see typed tree tutorial.

+
let input2 = 
+      """
+[<System.CLSCompliant(true)>]
+let foo(x, y) = 
+    let msg = String.Concat("Hello"," ","world")
+    if true then 
+        printfn "x = %d, y = %d" x y 
+        printfn "%s" msg
+
+type C() = 
+    member x.P = 1
+      """
+let parseFileResults, checkFileResults = 
+    parseAndTypeCheckSingleFile(file, SourceText.ofString input2)
+
+

Now get the partial assembly signature for the code:

+
let partialAssemblySignature = checkFileResults.PartialAssemblySignature
+    
+partialAssemblySignature.Entities.Count = 1  // one entity
+    
+
+

Now get the entity that corresponds to the module containing the code:

+
let moduleEntity = partialAssemblySignature.Entities.[0]
+
+moduleEntity.DisplayName = "Test"
+
+

Now get the entity that corresponds to the type definition in the code:

+
let classEntity = moduleEntity.NestedEntities.[0]
+
+

Now get the value that corresponds to the function defined in the code:

+
let fnVal = moduleEntity.MembersFunctionsAndValues.[0]
+
+

Now look around at the properties describing the function value:

+
fnVal.Attributes.Count // 1
+fnVal.CurriedParameterGroups.Count // 1
+fnVal.CurriedParameterGroups.[0].Count // 2
+fnVal.CurriedParameterGroups.[0].[0].Name // Some "x"
+fnVal.CurriedParameterGroups.[0].[1].Name // Some "y"
+fnVal.DeclarationLocation.StartLine // 3
+fnVal.DisplayName // "foo"
+fnVal.DeclaringEntity.Value.DisplayName // "Test"
+fnVal.DeclaringEntity.Value.DeclarationLocation.StartLine // 1
+fnVal.GenericParameters.Count // 0
+fnVal.InlineAnnotation // FSharpInlineAnnotation.OptionalInline
+fnVal.IsActivePattern // false
+fnVal.IsCompilerGenerated // false
+fnVal.IsDispatchSlot // false
+fnVal.IsExtensionMember // false
+fnVal.IsPropertyGetterMethod // false
+fnVal.IsImplicitConstructor // false
+fnVal.IsInstanceMember // false
+fnVal.IsMember // false
+fnVal.IsModuleValueOrMember // true
+fnVal.IsMutable // false
+fnVal.IsPropertySetterMethod // false
+fnVal.IsTypeFunction // false
+
+

Now look at the type of the function if used as a first class value. (Aside: the CurriedParameterGroups property contains +more information like the names of the arguments.)

+
fnVal.FullType // int * int -> unit
+fnVal.FullType.IsFunctionType // int * int -> unit
+fnVal.FullType.GenericArguments.[0] // int * int 
+fnVal.FullType.GenericArguments.[0].IsTupleType // int * int 
+let argTy1 = fnVal.FullType.GenericArguments.[0].GenericArguments.[0]
+
+argTy1.TypeDefinition.DisplayName // int
+
+

OK, so we got an object representation of the type int * int -> unit, and we have seen the first 'int'. We can find out more about the +type 'int' as follows, determining that it is a named type, which is an F# type abbreviation, type int = int32:

+
argTy1.HasTypeDefinition
+argTy1.TypeDefinition.IsFSharpAbbreviation // "int"
+
+

We can now look at the right-hand-side of the type abbreviation, which is the type int32:

+
let argTy1b = argTy1.TypeDefinition.AbbreviatedType
+argTy1b.TypeDefinition.Namespace // Some "Microsoft.FSharp.Core" 
+argTy1b.TypeDefinition.CompiledName // "int32" 
+
+

Again we can now look through the type abbreviation type int32 = System.Int32 to get the +full information about the type:

+
let argTy1c = argTy1b.TypeDefinition.AbbreviatedType
+argTy1c.TypeDefinition.Namespace // Some "SystemCore" 
+argTy1c.TypeDefinition.CompiledName // "Int32" 
+
+

The type checking results for a file also contain information extracted from the project (or script) options +used in the compilation, called the ProjectContext:

+
let projectContext = checkFileResults.ProjectContext
+    
+for assembly in projectContext.GetReferencedAssemblies() do
+    match assembly.FileName with 
+    | None -> printfn "compilation referenced an assembly without a file" 
+    | Some s -> printfn "compilation references assembly '%s'" s
+    
+
+

Notes:

+ +

Getting symbolic information about whole projects

+

To check whole projects, create a checker, then call parseAndCheckScript. In this case, we just check +the project for a single script. By specifying a different "projOptions" you can create +a specification of a larger project.

+
let parseAndCheckScript (file, input) = 
+    let projOptions, errors = 
+        checker.GetProjectOptionsFromScript(file, input, assumeDotNetFramework=false)
+        |> Async.RunSynchronously
+
+    checker.ParseAndCheckProject(projOptions) |> Async.RunSynchronously
+
+

Now do it for a particular input:

+
let tmpFile = Path.ChangeExtension(System.IO.Path.GetTempFileName() , "fs")
+File.WriteAllText(tmpFile, input2)
+
+let projectResults = parseAndCheckScript(tmpFile, SourceText.ofString input2)
+
+

Now look at the results:

+
let assemblySig = projectResults.AssemblySignature
+    
+printfn $"#entities = {assemblySig.Entities.Count}" // 1
+printfn $"namespace = {assemblySig.Entities.[0].Namespace}"  // one entity
+printfn $"entity name = {assemblySig.Entities.[0].DisplayName}" // "Tmp28D0"
+printfn $"#members = {assemblySig.Entities.[0].MembersFunctionsAndValues.Count}" // 1 
+printfn $"member name = {assemblySig.Entities.[0].MembersFunctionsAndValues.[0].DisplayName}" // "foo" 
+    
+
+ +
namespace System
+
namespace System.IO
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.Symbols
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

--------------------
type FSharpAttribute = + member Format: context: FSharpDisplayContext -> string + member IsAttribute: unit -> bool + member AttributeType: FSharpEntity + member ConstructorArguments: IList<FSharpType * obj> + member IsUnresolved: bool + member NamedArguments: IList<FSharpType * string * bool * obj> + member Range: range
<summary> + Represents a custom attribute attached to F# source code or a compiler .NET component +</summary>
+
namespace FSharp.Compiler.Text
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val parseAndTypeCheckSingleFile: file: string * input: ISourceText -> FSharpParseFileResults * FSharpCheckFileResults
+
val file: string
+
val input: ISourceText
+
val projOptions: FSharpProjectOptions
+
val errors: FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
member FSharpChecker.GetProjectOptionsFromScript: fileName: string * source: ISourceText * ?previewEnabled: bool * ?loadedTimeStamp: DateTime * ?otherFlags: string array * ?useFsiAuxLib: bool * ?useSdkRefs: bool * ?assumeDotNetFramework: bool * ?sdkDirOverride: string * ?optionsStamp: int64 * ?userOpName: string -> Async<FSharpProjectOptions * FSharp.Compiler.Diagnostics.FSharpDiagnostic list>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: Threading.CancellationToken -> 'T
+
val parseFileResults: FSharpParseFileResults
+
val checkFileResults: FSharpCheckFileAnswer
+
member FSharpChecker.ParseAndCheckFileInProject: fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
+
type FSharpCheckFileAnswer = + | Aborted + | Succeeded of FSharpCheckFileResults
<summary> + The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. +</summary>
+
union case FSharpCheckFileAnswer.Succeeded: FSharpCheckFileResults -> FSharpCheckFileAnswer
<summary> + Success +</summary>
+
val res: FSharpCheckFileResults
+
val res: FSharpCheckFileAnswer
+
val failwithf: format: Printf.StringFormat<'T,'Result> -> 'T
+
val input2: string
+
val checkFileResults: FSharpCheckFileResults
+
module SourceText + +from FSharp.Compiler.Text
<summary> + Functions related to ISourceText objects +</summary>
+
val ofString: string -> ISourceText
<summary> + Creates an ISourceText object from the given string +</summary>
+
val partialAssemblySignature: FSharpAssemblySignature
+
property FSharpCheckFileResults.PartialAssemblySignature: FSharpAssemblySignature with get
<summary> + Get a view of the contents of the assembly up to and including the file just checked +</summary>
+
property FSharpAssemblySignature.Entities: Collections.Generic.IList<FSharpEntity> with get
<summary> + The (non-nested) module and type definitions in this signature +</summary>
+
property Collections.Generic.ICollection.Count: int with get
<summary>Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.</summary>
<returns>The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.</returns>
+
val moduleEntity: FSharpEntity
+
property FSharpEntity.DisplayName: string with get
<summary> + Get the name of the type or module as displayed in F# code +</summary>
+
val classEntity: FSharpEntity
+
property FSharpEntity.NestedEntities: Collections.Generic.IList<FSharpEntity> with get
<summary> + Get the modules and types defined in a module, or the nested types of a type +</summary>
+
val fnVal: FSharpMemberOrFunctionOrValue
+
property FSharpEntity.MembersFunctionsAndValues: Collections.Generic.IList<FSharpMemberOrFunctionOrValue> with get
<summary> + Get the properties, events and methods of a type definitions, or the functions and values of a module +</summary>
+
property FSharpMemberOrFunctionOrValue.Attributes: Collections.Generic.IList<FSharpAttribute> with get
<summary> + Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup + these value references after copying a collection of values. +</summary>
+
property FSharpMemberOrFunctionOrValue.CurriedParameterGroups: Collections.Generic.IList<Collections.Generic.IList<FSharpParameter>> with get
<summary>List of list of parameters, where each nested item represents a defined parameter</summary>
<remarks> + Typically, there is only one nested list. + However, code such as 'f (a, b) (c, d)' contains two groups, each with two parameters. + In that example, there is a list made up of two lists, each with a parameter. + </remarks>
+
property FSharpMemberOrFunctionOrValue.DeclarationLocation: range with get
<summary> + Get the declaration location of the member, function or value +</summary>
+
property Range.StartLine: int with get
<summary> + The start line of the range +</summary>
+
property FSharpMemberOrFunctionOrValue.DisplayName: string with get
<summary> + Get the name as presented in F# error messages and documentation +</summary>
+
property FSharpMemberOrFunctionOrValue.DeclaringEntity: FSharpEntity option with get
<summary> + Get the enclosing entity for the definition +</summary>
+
property Option.Value: FSharpEntity with get
+
property FSharpEntity.DeclarationLocation: range with get
<summary> + Get the declaration location for the type constructor +</summary>
+
property FSharpMemberOrFunctionOrValue.GenericParameters: Collections.Generic.IList<FSharpGenericParameter> with get
<summary> + Get the typars of the member, function or value +</summary>
+
property FSharpMemberOrFunctionOrValue.InlineAnnotation: FSharpInlineAnnotation with get
<summary> + Get a result indicating if this is a must-inline value +</summary>
+
property FSharpMemberOrFunctionOrValue.IsActivePattern: bool with get
<summary> + Indicates if this value or member is an F# active pattern +</summary>
+
property FSharpMemberOrFunctionOrValue.IsCompilerGenerated: bool with get
<summary> + Indicates if this is a compiler generated value +</summary>
+
property FSharpMemberOrFunctionOrValue.IsDispatchSlot: bool with get
<summary> + Indicates if this is an abstract member? +</summary>
+
property FSharpMemberOrFunctionOrValue.IsExtensionMember: bool with get
<summary> + Indicates if this is an extension member? +</summary>
+
property FSharpMemberOrFunctionOrValue.IsPropertyGetterMethod: bool with get
<summary> + Indicates if this is a getter method for a property, or a use of a property in getter mode +</summary>
+
property FSharpMemberOrFunctionOrValue.IsImplicitConstructor: bool with get
<summary> + Indicates if this is an implicit constructor? +</summary>
+
property FSharpMemberOrFunctionOrValue.IsInstanceMember: bool with get
<summary> + Indicates if this is an instance member, when seen from F#? +</summary>
+
property FSharpMemberOrFunctionOrValue.IsMember: bool with get
<summary> + Indicates if this is a member, including extension members? +</summary>
+
property FSharpMemberOrFunctionOrValue.IsModuleValueOrMember: bool with get
<summary> + Indicates if this is a module or member value +</summary>
+
property FSharpMemberOrFunctionOrValue.IsMutable: bool with get
<summary> + Indicates if this is a mutable value +</summary>
+
property FSharpMemberOrFunctionOrValue.IsPropertySetterMethod: bool with get
<summary> + Indicates if this is a setter method for a property, or a use of a property in setter mode +</summary>
+
property FSharpMemberOrFunctionOrValue.IsTypeFunction: bool with get
<summary> + Indicates if this is an F# type function +</summary>
+
property FSharpMemberOrFunctionOrValue.FullType: FSharpType with get
<summary> + Get the full type of the member, function or value when used as a first class value +</summary>
+
property FSharpType.IsFunctionType: bool with get
<summary> + Indicates if the type is a function type. The GenericArguments property returns the domain and range of the function type. +</summary>
+
property FSharpType.GenericArguments: Collections.Generic.IList<FSharpType> with get
<summary> + Get the generic arguments for a tuple type, a function type or a type constructed using a named entity +</summary>
+
val argTy1: FSharpType
+
property FSharpType.TypeDefinition: FSharpEntity with get
<summary> + Get the type definition for a type +</summary>
+
property FSharpType.HasTypeDefinition: bool with get
<summary> + Indicates if the type is constructed using a named entity, including array and byref types +</summary>
+
property FSharpEntity.IsFSharpAbbreviation: bool with get
<summary> + Indicates if the entity is a measure, type or exception abbreviation +</summary>
+
val argTy1b: FSharpType
+
property FSharpEntity.AbbreviatedType: FSharpType with get
<summary> + Get the type abbreviated by an F# type abbreviation +</summary>
+
property FSharpEntity.Namespace: string option with get
<summary> + Get the namespace containing the type or module, if any. Use 'None' for item not in a namespace. +</summary>
+
property FSharpEntity.CompiledName: string with get
<summary> + Get the compiled name of the type or module, possibly with `n mangling. This is identical to LogicalName + unless the CompiledName attribute is used. +</summary>
+
val argTy1c: FSharpType
+
val projectContext: FSharpProjectContext
+
property FSharpCheckFileResults.ProjectContext: FSharpProjectContext with get
<summary> + Get the resolution of the ProjectOptions +</summary>
+
val assembly: FSharpAssembly
+
member FSharpProjectContext.GetReferencedAssemblies: unit -> FSharpAssembly list
+
property FSharpAssembly.FileName: string option with get
<summary> + The file name for the assembly, if any +</summary>
+
union case Option.None: Option<'T>
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
union case Option.Some: Value: 'T -> Option<'T>
+
val s: string
+
val parseAndCheckScript: file: string * input: ISourceText -> FSharpCheckProjectResults
+
member FSharpChecker.ParseAndCheckProject: options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckProjectResults>
+
val tmpFile: 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.ChangeExtension(path: string, extension: string) : string
+
Path.GetTempFileName() : string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit
+
val projectResults: FSharpCheckProjectResults
+
val assemblySig: FSharpAssemblySignature
+
property FSharpCheckProjectResults.AssemblySignature: FSharpAssemblySignature with get
<summary> + Get a view of the overall signature of the assembly. Only valid to use if HasCriticalErrors is false. +</summary>
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/syntax-visitor.html b/fcs/syntax-visitor.html new file mode 100644 index 0000000000..ce96b6074e --- /dev/null +++ b/fcs/syntax-visitor.html @@ -0,0 +1,888 @@ + + + + + + + + + + + + + + + + + + Tutorial: SyntaxVisitorBase | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Using the SyntaxVisitorBase

+

Syntax tree traversal is a common topic when interacting with the FSharp.Compiler.Service.
+As established in Tutorial: Expressions, the ParsedInput can be traversed by a set of recursive functions.
+It can be tedious to always construct these functions from scratch.

+

As an alternative, a SyntaxVisitorBase can be used to traverse the syntax tree. +Consider, the following code sample:

+
let codeSample = """
+module Lib
+
+let myFunction paramOne paramTwo =
+    ()
+"""
+
+

Imagine we wish to grab the myFunction name from the headPat in the SynBinding.
+Let's introduce a helper function to construct the AST:

+
#r "FSharp.Compiler.Service.dll"
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Text
+open FSharp.Compiler.Syntax
+
+let checker = FSharpChecker.Create()
+
+/// Helper to construct an ParsedInput from a code snippet.
+let mkTree codeSample =
+    let parseFileResults =
+        checker.ParseFile(
+            "FileName.fs",
+            SourceText.ofString codeSample,
+            { FSharpParsingOptions.Default with SourceFiles = [| "FileName.fs" |] }
+        )
+        |> Async.RunSynchronously
+
+    parseFileResults.ParseTree
+
+

And create a visitor to traverse the tree:

+
let visitor =
+    { new SyntaxVisitorBase<string>() with
+        override this.VisitPat(path, defaultTraverse, synPat) =
+            // First check if the pattern is what we are looking for.
+            match synPat with
+            | SynPat.LongIdent(longDotId = SynLongIdent(id = [ ident ])) ->
+                // Next we can check if the current path of visited nodes, matches our expectations.
+                // The path will contain all the ancestors of the current node.
+                match path with
+                // The parent node of `synPat` should be a `SynBinding`.
+                | SyntaxNode.SynBinding _ :: _ ->
+                    // We return a `Some` option to indicate we found what we are looking for.
+                    Some ident.idText
+                // If the parent is something else, we can skip it here.
+                | _ -> None
+            | _ -> None }
+
+let result = SyntaxTraversal.Traverse(Position.pos0, mkTree codeSample, visitor) // Some "myFunction"
+
+

Instead of traversing manually from ParsedInput to SynModuleOrNamespace to SynModuleDecl.Let to SynBinding to SynPat, we leverage the default navigation that happens in SyntaxTraversal.Traverse.
+A SyntaxVisitorBase will shortcut all other code paths once a single VisitXYZ override has found anything.

+

Our code sample of course only had one let binding and thus we didn't need to specify any further logic whether to differentiate between multiple bindings. +Let's consider a second example where we know the user's cursor inside an IDE is placed after c and we are interested in the body expression of the let binding.

+
let secondCodeSample = """
+module X
+
+let a = 0
+let b = 1
+let c = 2
+"""
+
+let secondVisitor =
+    { new SyntaxVisitorBase<SynExpr>() with
+        override this.VisitBinding(path, defaultTraverse, binding) =
+            match binding with
+            | SynBinding(expr = e) -> Some e }
+
+let cursorPos = Position.mkPos 6 5
+
+let secondResult =
+    SyntaxTraversal.Traverse(cursorPos, mkTree secondCodeSample, secondVisitor) // Some (Const (Int32 2, (6,8--6,9)))
+
+

Due to our passed cursor position, we did not need to write any code to exclude the expressions of the other let bindings. +SyntaxTraversal.Traverse will check whether the current position is inside any syntax node before drilling deeper.

+

Lastly, some VisitXYZ overrides can contain a defaultTraverse. This helper allows you to continue the default traversal when you currently hit a node that is not of interest. +Consider 1 + 2 + 3 + 4, this will be reflected in a nested infix application expression. +If the cursor is at the end of the entire expression, we can grab the value of 4 using the following visitor:

+
let thirdCodeSample = "let sum = 1 + 2 + 3 + 4"
+
+(*
+AST will look like:
+
+Let
+ (false,
+  [SynBinding
+     (None, Normal, false, false, [],
+      PreXmlDoc ((1,0), Fantomas.FCS.Xml.XmlDocCollector),
+      SynValData
+        (None, SynValInfo ([], SynArgInfo ([], false, None)), None,
+         None),
+      Named (SynIdent (sum, None), false, None, (1,4--1,7)), None,
+      App
+        (NonAtomic, false,
+         App
+           (NonAtomic, true,
+            LongIdent
+              (false,
+               SynLongIdent
+                 ([op_Addition], [], [Some (OriginalNotation "+")]),
+               None, (1,20--1,21)),
+            App
+              (NonAtomic, false,
+               App
+                 (NonAtomic, true,
+                  LongIdent
+                    (false,
+                     SynLongIdent
+                       ([op_Addition], [],
+                        [Some (OriginalNotation "+")]), None,
+                     (1,16--1,17)),
+                  App
+                    (NonAtomic, false,
+                     App
+                       (NonAtomic, true,
+                        LongIdent
+                          (false,
+                           SynLongIdent
+                             ([op_Addition], [],
+                              [Some (OriginalNotation "+")]), None,
+                           (1,12--1,13)),
+                        Const (Int32 1, (1,10--1,11)), (1,10--1,13)),
+                     Const (Int32 2, (1,14--1,15)), (1,10--1,15)),
+                  (1,10--1,17)), Const (Int32 3, (1,18--1,19)),
+               (1,10--1,19)), (1,10--1,21)),
+         Const (Int32 4, (1,22--1,23)), (1,10--1,23)), (1,4--1,7),
+      Yes (1,0--1,23), { LeadingKeyword = Let (1,0--1,3)
+                         InlineKeyword = None
+                         EqualsRange = Some (1,8--1,9) })
+*)
+
+let thirdCursorPos = Position.mkPos 1 22
+
+let thirdVisitor =
+    { new SyntaxVisitorBase<int>() with
+        override this.VisitExpr(path, traverseSynExpr, defaultTraverse, synExpr) =
+            match synExpr with
+            | SynExpr.Const (constant = SynConst.Int32 v) -> Some v
+            // We do want to continue to traverse when nodes like `SynExpr.App` are found.
+            | otherExpr -> defaultTraverse otherExpr }
+
+let thirdResult =
+    SyntaxTraversal.Traverse(cursorPos, mkTree thirdCodeSample, thirdVisitor) // Some 4
+
+

defaultTraverse is especially useful when you do not know upfront what syntax tree you will be walking.
+This is a common case when dealing with IDE tooling. You won't know what actual code the end-user is currently processing.

+

Note: SyntaxVisitorBase is designed to find a single value inside a tree!
+This is not an ideal solution when you are interested in all nodes of certain shape.
+It will always verify if the given cursor position is still matching the range of the node.
+As a fallback the first branch will be explored when you pass Position.pos0.
+By design, it is meant to find a single result.

+ +
val codeSample: string
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.Text
+
namespace FSharp.Compiler.Syntax
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val mkTree: codeSample: string -> ParsedInput
 Helper to construct an ParsedInput from a code snippet.
+
val parseFileResults: FSharpParseFileResults
+
member FSharpChecker.ParseFile: fileName: string * sourceText: ISourceText * options: FSharpParsingOptions * ?cache: bool * ?userOpName: string -> Async<FSharpParseFileResults>
+
module SourceText + +from FSharp.Compiler.Text
<summary> + Functions related to ISourceText objects +</summary>
+
val ofString: string -> ISourceText
<summary> + Creates an ISourceText object from the given string +</summary>
+
type FSharpParsingOptions = + { + SourceFiles: string array + ApplyLineDirectives: bool + ConditionalDefines: string list + DiagnosticOptions: FSharpDiagnosticOptions + LangVersionText: string + IsInteractive: bool + IndentationAwareSyntax: bool option + StrictIndentation: bool option + CompilingFSharpCore: bool + IsExe: bool + } + static member Default: FSharpParsingOptions
<summary> + Options used to determine active --define conditionals and other options relevant to parsing files in a project +</summary>
+
property FSharpParsingOptions.Default: FSharpParsingOptions with get
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
+
property FSharpParseFileResults.ParseTree: ParsedInput with get
<summary> + The syntax tree resulting from the parse +</summary>
+
val visitor: SyntaxVisitorBase<string>
+
Multiple items
type SyntaxVisitorBase<'T> = + new: unit -> SyntaxVisitorBase<'T> + abstract VisitAttributeApplication: path: SyntaxVisitorPath * attributes: SynAttributeList -> 'T option + 1 overload + abstract VisitBinding: path: SyntaxVisitorPath * defaultTraverse: (SynBinding -> 'T option) * synBinding: SynBinding -> 'T option + 1 overload + abstract VisitComponentInfo: path: SyntaxVisitorPath * synComponentInfo: SynComponentInfo -> 'T option + 1 overload + abstract VisitEnumDefn: path: SyntaxVisitorPath * cases: SynEnumCase list * range -> 'T option + 1 overload + abstract VisitExpr: path: SyntaxVisitorPath * traverseSynExpr: (SynExpr -> 'T option) * defaultTraverse: (SynExpr -> 'T option) * synExpr: SynExpr -> 'T option + 1 overload + abstract VisitHashDirective: path: SyntaxVisitorPath * hashDirective: ParsedHashDirective * range: range -> 'T option + 1 overload + abstract VisitImplicitInherit: path: SyntaxVisitorPath * defaultTraverse: (SynExpr -> 'T option) * inheritedType: SynType * synArgs: SynExpr * range: range -> 'T option + 1 overload + abstract VisitInheritSynMemberDefn: path: SyntaxVisitorPath * componentInfo: SynComponentInfo * typeDefnKind: SynTypeDefnKind * synType: SynType * members: SynMemberDefns * range: range -> 'T option + 1 overload + abstract VisitInterfaceSynMemberDefnType: path: SyntaxVisitorPath * synType: SynType -> 'T option + 1 overload + ...

--------------------
new: unit -> SyntaxVisitorBase<'T>
+
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
+
val this: SyntaxVisitorBase<string>
+
override SyntaxVisitorBase.VisitPat: path: SyntaxVisitorPath * defaultTraverse: (SynPat -> 'T option) * synPat: SynPat -> 'T option
+
val path: SyntaxVisitorPath
+
val defaultTraverse: (SynPat -> string option)
+
val synPat: SynPat
+
type SynPat = + | Const of constant: SynConst * range: range + | Wild of range: range + | Named of ident: SynIdent * isThisVal: bool * accessibility: SynAccess option * range: range + | Typed of pat: SynPat * targetType: SynType * range: range + | Attrib of pat: SynPat * attributes: SynAttributes * range: range + | Or of lhsPat: SynPat * rhsPat: SynPat * range: range * trivia: SynPatOrTrivia + | ListCons of lhsPat: SynPat * rhsPat: SynPat * range: range * trivia: SynPatListConsTrivia + | Ands of pats: SynPat list * range: range + | As of lhsPat: SynPat * rhsPat: SynPat * range: range + | LongIdent of longDotId: SynLongIdent * extraId: Ident option * typarDecls: SynValTyparDecls option * argPats: SynArgPats * accessibility: SynAccess option * range: range + ... + member Range: range
<summary> + Represents a syntax tree for an F# pattern +</summary>
+
union case SynPat.LongIdent: longDotId: SynLongIdent * extraId: Ident option * typarDecls: SynValTyparDecls option * argPats: SynArgPats * accessibility: SynAccess option * range: range -> SynPat
<summary> + A long identifier pattern possibly with argument patterns +</summary>
+
Multiple items
union case SynLongIdent.SynLongIdent: id: LongIdent * dotRanges: range list * trivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia option list -> SynLongIdent

--------------------
type SynLongIdent = + | SynLongIdent of id: LongIdent * dotRanges: range list * trivia: IdentTrivia option list + member Dots: range list + member IdentsWithTrivia: SynIdent list + member LongIdent: LongIdent + member Range: range + member RangeWithoutAnyExtraDot: range + member ThereIsAnExtraDotAtTheEnd: bool + member Trivia: IdentTrivia list
<summary> + Represents a long identifier with possible '.' at end. + + Typically dotRanges.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. "Foo.Bar." + The dots mostly matter for parsing, and are typically ignored by the typechecker, but + if dotRanges.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed + more freedom about typechecking these expressions. + LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit) +</summary>
+
val id: x: 'T -> 'T
+
val ident: Ident
+
type SyntaxNode = + | SynPat of SynPat + | SynType of SynType + | SynExpr of SynExpr + | SynModule of SynModuleDecl + | SynModuleOrNamespace of SynModuleOrNamespace + | SynTypeDefn of SynTypeDefn + | SynMemberDefn of SynMemberDefn + | SynMatchClause of SynMatchClause + | SynBinding of SynBinding + | SynModuleOrNamespaceSig of SynModuleOrNamespaceSig + ...
<summary> + Used to track route during traversal of syntax using SyntaxTraversal.Traverse +</summary>
+
union case SyntaxNode.SynBinding: SynBinding -> SyntaxNode
+
union case Option.Some: Value: 'T -> Option<'T>
+
property Ident.idText: string with get
+
union case Option.None: Option<'T>
+
val result: string option
+
module SyntaxTraversal + +from FSharp.Compiler.Syntax
+
val Traverse: pos: pos * parseTree: ParsedInput * visitor: SyntaxVisitorBase<'T> -> 'T option
+
Multiple items
module Position + +from FSharp.Compiler.Text

--------------------
[<Struct>] +type Position = + member Column: int + member Line: int
<summary> + Represents a position in a file +</summary>
+
val pos0: pos
<summary> + The zero position +</summary>
+
val secondCodeSample: string
+
val secondVisitor: SyntaxVisitorBase<SynExpr>
+
type SynExpr = + | Paren of expr: SynExpr * leftParenRange: range * rightParenRange: range option * range: range + | Quote of operator: SynExpr * isRaw: bool * quotedExpr: SynExpr * isFromQueryExpression: bool * range: range + | Const of constant: SynConst * range: range + | Typed of expr: SynExpr * targetType: SynType * range: range + | Tuple of isStruct: bool * exprs: SynExpr list * commaRanges: range list * range: range + | AnonRecd of isStruct: bool * copyInfo: (SynExpr * BlockSeparator) option * recordFields: (SynLongIdent * range option * SynExpr) list * range: range * trivia: SynExprAnonRecdTrivia + | ArrayOrList of isArray: bool * exprs: SynExpr list * range: range + | Record of baseInfo: (SynType * SynExpr * range * BlockSeparator option * range) option * copyInfo: (SynExpr * BlockSeparator) option * recordFields: SynExprRecordField list * range: range + | New of isProtected: bool * targetType: SynType * expr: SynExpr * range: range + | ObjExpr of objType: SynType * argOptions: (SynExpr * Ident option) option * withKeyword: range option * bindings: SynBinding list * members: SynMemberDefns * extraImpls: SynInterfaceImpl list * newExprRange: range * range: range + ... + member IsArbExprAndThusAlreadyReportedError: bool + member Range: range + member RangeOfFirstPortion: range + member RangeWithoutAnyExtraDot: range
<summary> + Represents a syntax tree for F# expressions +</summary>
+
val this: SyntaxVisitorBase<SynExpr>
+
override SyntaxVisitorBase.VisitBinding: path: SyntaxVisitorPath * defaultTraverse: (SynBinding -> 'T option) * synBinding: SynBinding -> 'T option
+
val defaultTraverse: (SynBinding -> SynExpr option)
+
val binding: SynBinding
+
Multiple items
union case SynBinding.SynBinding: accessibility: SynAccess option * kind: SynBindingKind * isInline: bool * isMutable: bool * attributes: SynAttributes * xmlDoc: FSharp.Compiler.Xml.PreXmlDoc * valData: SynValData * headPat: SynPat * returnInfo: SynBindingReturnInfo option * expr: SynExpr * range: range * debugPoint: DebugPointAtBinding * trivia: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia -> SynBinding

--------------------
type SynBinding = + | SynBinding of accessibility: SynAccess option * kind: SynBindingKind * isInline: bool * isMutable: bool * attributes: SynAttributes * xmlDoc: PreXmlDoc * valData: SynValData * headPat: SynPat * returnInfo: SynBindingReturnInfo option * expr: SynExpr * range: range * debugPoint: DebugPointAtBinding * trivia: SynBindingTrivia + member RangeOfBindingWithRhs: range + member RangeOfBindingWithoutRhs: range + member RangeOfHeadPattern: range
<summary> + Represents a binding for a 'let' or 'member' declaration +</summary>
+
val e: SynExpr
+
val cursorPos: pos
+
val mkPos: line: int -> column: int -> pos
<summary> + Create a position for the given line and column +</summary>
+
val secondResult: SynExpr option
+
val thirdCodeSample: string
+
val thirdCursorPos: pos
+
val thirdVisitor: SyntaxVisitorBase<int>
+
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+
val this: SyntaxVisitorBase<int>
+
override SyntaxVisitorBase.VisitExpr: path: SyntaxVisitorPath * traverseSynExpr: (SynExpr -> 'T option) * defaultTraverse: (SynExpr -> 'T option) * synExpr: SynExpr -> 'T option
+
val traverseSynExpr: (SynExpr -> int option)
+
val defaultTraverse: (SynExpr -> int option)
+
val synExpr: SynExpr
+
union case SynExpr.Const: constant: SynConst * range: range -> SynExpr
<summary> + F# syntax: 1, 1.3, () etc. +</summary>
+
type SynConst = + | Unit + | Bool of bool + | SByte of sbyte + | Byte of byte + | Int16 of int16 + | UInt16 of uint16 + | Int32 of int32 + | UInt32 of uint32 + | Int64 of int64 + | UInt64 of uint64 + ... + member Range: dflt: range -> range
<summary> + The unchecked abstract syntax tree of constants in F# types and expressions. +</summary>
+
union case SynConst.Int32: int32 -> SynConst
<summary> + F# syntax: 13, 0x4000, 0o0777 +</summary>
+
val v: int32
+
val otherExpr: SynExpr
+
val thirdResult: int option
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/tokenizer.html b/fcs/tokenizer.html new file mode 100644 index 0000000000..81a3bc462b --- /dev/null +++ b/fcs/tokenizer.html @@ -0,0 +1,701 @@ + + + + + + + + + + + + + + + + + + Tutorial: Tokenizing | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Using the F# tokenizer

+

This tutorial demonstrates how to call the F# language tokenizer. Given F# +source code, the tokenizer generates a list of source code lines that contain +information about tokens on each line. For each token, you can get the type +of the token, exact location as well as color kind of the token (keyword, +identifier, number, operator, etc.).

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published

+
+

Creating the tokenizer

+

To use the tokenizer, reference FSharp.Compiler.Service.dll and open the +FSharp.Compiler.Tokenization namespace:

+
#r "FSharp.Compiler.Service.dll"
+open FSharp.Compiler.Tokenization
+
+

Now you can create an instance of FSharpSourceTokenizer. The class takes two +arguments - the first is the list of defined symbols and the second is the +file name of the source code. The defined symbols are required because the +tokenizer handles #if directives. The file name is required only to specify +locations of the source code (and it does not have to exist):

+
let sourceTok = FSharpSourceTokenizer([], Some "C:\\test.fsx", Some "PREVIEW", None)
+
+

Using the sourceTok object, we can now (repeatedly) tokenize lines of +F# source code.

+

Tokenizing F# code

+

The tokenizer operates on individual lines rather than on the entire source +file. After getting a token, the tokenizer also returns new state (as int64 value). +This can be used to tokenize F# code more efficiently. When source code changes, +you do not need to re-tokenize the entire file - only the parts that have changed.

+

Tokenizing single line

+

To tokenize a single line, we create a FSharpLineTokenizer by calling CreateLineTokenizer +on the FSharpSourceTokenizer object that we created earlier:

+
let tokenizer = sourceTok.CreateLineTokenizer("let answer=42")
+
+

Now, we can write a simple recursive function that calls ScanToken on the tokenizer +until it returns None (indicating the end of line). When the function succeeds, it +returns an FSharpTokenInfo object with all the interesting details:

+
/// Tokenize a single line of F# code
+let rec tokenizeLine (tokenizer:FSharpLineTokenizer) state =
+  match tokenizer.ScanToken(state) with
+  | Some tok, state ->
+      // Print token name
+      printf "%s " tok.TokenName
+      // Tokenize the rest, in the new state
+      tokenizeLine tokenizer state
+  | None, state -> state
+
+

The function returns the new state, which is needed if you need to tokenize multiple lines +and an earlier line ends with a multi-line comment. As an initial state, we can use 0L:

+
tokenizeLine tokenizer FSharpTokenizerLexState.Initial
+
+

The result is a sequence of tokens with names LET, WHITESPACE, IDENT, EQUALS and INT32. +There is a number of interesting properties on FSharpTokenInfo including:

+ +

Note that the tokenizer is stateful - if you want to tokenize single line multiple times, +you need to call CreateLineTokenizer again.

+

Tokenizing sample code

+

To run the tokenizer on a longer sample code or an entire file, you need to read the +sample input as a collection of string values:

+
let lines = """
+  // Hello world
+  let hello() =
+     printfn "Hello world!" """.Split('\r','\n')
+
+

To tokenize multi-line input, we again need a recursive function that keeps the current +state. The following function takes the lines as a list of strings (together with line number +and the current state). We create a new tokenizer for each line and call tokenizeLine +using the state from the end of the previous line:

+
/// Print token names for multiple lines of code
+let rec tokenizeLines state count lines = 
+  match lines with
+  | line::lines ->
+      // Create tokenizer & tokenize single line
+      printfn "\nLine %d" count
+      let tokenizer = sourceTok.CreateLineTokenizer(line)
+      let state = tokenizeLine tokenizer state
+      // Tokenize the rest using new state
+      tokenizeLines state (count+1) lines
+  | [] -> ()
+
+

The function simply calls tokenizeLine (defined earlier) to print the names of all +the tokens on each line. We can call it on the previous input with 0L as the initial +state and 1 as the number of the first line:

+
lines
+|> List.ofSeq
+|> tokenizeLines FSharpTokenizerLexState.Initial 1
+
+

Ignoring some unimportant details (like whitespace at the beginning of each line and +the first line which is just whitespace), the code generates the following output:

+
Line 1
+  LINE_COMMENT LINE_COMMENT (...) LINE_COMMENT 
+Line 2
+  LET WHITESPACE IDENT LPAREN RPAREN WHITESPACE EQUALS 
+Line 3
+  IDENT WHITESPACE STRING_TEXT (...) STRING_TEXT STRING 
+
+

It is worth noting that the tokenizer yields multiple LINE_COMMENT tokens and multiple +STRING_TEXT tokens for each single comment or string (roughly, one for each word), so +if you want to get the entire text of a comment/string, you need to concatenate the +tokens.

+ +
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.Tokenization
+
val sourceTok: FSharpSourceTokenizer
+
Multiple items
type FSharpSourceTokenizer = + new: conditionalDefines: string list * fileName: string option * langVersion: string option * strictIndentation: bool option -> FSharpSourceTokenizer + member CreateBufferTokenizer: bufferFiller: (char array * int * int -> int) -> FSharpLineTokenizer + member CreateLineTokenizer: lineText: string -> FSharpLineTokenizer
<summary> + Tokenizer for a source file. Holds some expensive-to-compute resources at the scope of the file. +</summary>

--------------------
new: conditionalDefines: string list * fileName: string option * langVersion: string option * strictIndentation: bool option -> FSharpSourceTokenizer
+
union case Option.Some: Value: 'T -> Option<'T>
+
union case Option.None: Option<'T>
+
val tokenizer: FSharpLineTokenizer
+
member FSharpSourceTokenizer.CreateLineTokenizer: lineText: string -> FSharpLineTokenizer
+
val tokenizeLine: tokenizer: FSharpLineTokenizer -> state: FSharpTokenizerLexState -> FSharpTokenizerLexState
 Tokenize a single line of F# code
+
type FSharpLineTokenizer = + member ScanToken: lexState: FSharpTokenizerLexState -> FSharpTokenInfo option * FSharpTokenizerLexState + static member ColorStateOfLexState: FSharpTokenizerLexState -> FSharpTokenizerColorState + static member LexStateOfColorState: FSharpTokenizerColorState -> FSharpTokenizerLexState
<summary> + Object to tokenize a line of F# source code, starting with the given lexState. The lexState should be FSharpTokenizerLexState.Initial for + the first line of text. Returns an array of ranges of the text and two enumerations categorizing the + tokens and characters covered by that range, i.e. FSharpTokenColorKind and FSharpTokenCharKind. The enumerations + are somewhat adhoc but useful enough to give good colorization options to the user in an IDE. + + A new lexState is also returned. An IDE-plugin should in general cache the lexState + values for each line of the edited code. +</summary>
+
val state: FSharpTokenizerLexState
+
member FSharpLineTokenizer.ScanToken: lexState: FSharpTokenizerLexState -> FSharpTokenInfo option * FSharpTokenizerLexState
+
val tok: FSharpTokenInfo
+
val printf: format: Printf.TextWriterFormat<'T> -> 'T
+
FSharpTokenInfo.TokenName: string
<summary> + Provides additional information about the token +</summary>
+
[<Struct>] +type FSharpTokenizerLexState = + { + PosBits: int64 + OtherBits: int64 + } + member Equals: FSharpTokenizerLexState -> bool + static member Initial: FSharpTokenizerLexState
<summary> + Represents encoded information for the end-of-line continuation of lexing +</summary>
+
property FSharpTokenizerLexState.Initial: FSharpTokenizerLexState with get
+
val lines: string array
+
val tokenizeLines: state: FSharpTokenizerLexState -> count: int -> lines: string list -> unit
 Print token names for multiple lines of code
+
val count: int
+
val lines: string list
+
val line: string
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
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 ofSeq: source: 'T seq -> 'T list
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/typedtree.html b/fcs/typedtree.html new file mode 100644 index 0000000000..b14e911ee0 --- /dev/null +++ b/fcs/typedtree.html @@ -0,0 +1,1193 @@ + + + + + + + + + + + + + + + + + + Tutorial: Expressions | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Processing typed expression tree

+

This tutorial demonstrates how to get the checked, typed expressions tree (TAST) +for F# code and how to walk over the tree.

+

This can be used for creating tools such as source code analyzers and refactoring tools. +You can also combine the information with the API available +from symbols.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published

+
+

Getting checked expressions

+

To access the type-checked, resolved expressions, you need to create an instance of InteractiveChecker.

+

To use the interactive checker, reference FSharp.Compiler.Service.dll and open the +relevant namespaces:

+
#r "FSharp.Compiler.Service.dll"
+open System
+open System.IO
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.EditorServices
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Text
+
+

Checking code

+

We first parse and check some code as in the symbols tutorial. +One difference is that we set keepAssemblyContents to true.

+
// Create an interactive checker instance 
+let checker = FSharpChecker.Create(keepAssemblyContents=true)
+
+let parseAndCheckSingleFile (input) = 
+    let file = Path.ChangeExtension(System.IO.Path.GetTempFileName(), "fsx")  
+    File.WriteAllText(file, input)
+    // Get context representing a stand-alone (script) file
+    let projOptions, _errors = 
+        checker.GetProjectOptionsFromScript(file, SourceText.ofString input, assumeDotNetFramework=false)
+        |> Async.RunSynchronously
+
+    checker.ParseAndCheckProject(projOptions) 
+    |> Async.RunSynchronously
+
+

Getting the expressions

+

After type checking a file, you can access the declarations and contents of the assembly, including expressions:

+
let input2 = 
+      """
+module MyLibrary 
+
+open System
+
+let foo(x, y) = 
+    let msg = String.Concat("Hello", " ", "world")
+    if msg.Length > 10 then 
+        10 
+    else 
+        20
+
+type MyClass() = 
+    member x.MyMethod() = 1
+      """
+let checkProjectResults = 
+    parseAndCheckSingleFile(input2)
+
+checkProjectResults.Diagnostics // should be empty
+
+

Checked assemblies are made up of a series of checked implementation files. The "file" granularity +matters in F# because initialization actions are triggered at the granularity of files. +In this case there is only one implementation file in the project:

+
let checkedFile = checkProjectResults.AssemblyContents.ImplementationFiles.[0]
+
+

Checked assemblies are made up of a series of checked implementation files. The "file" granularity +matters in F# because initialization actions are triggered at the granularity of files. +In this case there is only one implementation file in the project:

+
let rec printDecl prefix d = 
+    match d with 
+    | FSharpImplementationFileDeclaration.Entity (e, subDecls) -> 
+        printfn "%sEntity %s was declared and contains %d sub-declarations" prefix e.CompiledName subDecls.Length
+        for subDecl in subDecls do 
+            printDecl (prefix+"    ") subDecl
+    | FSharpImplementationFileDeclaration.MemberOrFunctionOrValue(v, vs, e) -> 
+        printfn "%sMember or value %s was declared" prefix  v.CompiledName
+    | FSharpImplementationFileDeclaration.InitAction(e) -> 
+        printfn "%sA top-level expression was declared" prefix 
+
+
+for d in checkedFile.Declarations do 
+   printDecl "" d
+
+// Entity MyLibrary was declared and contains 4 sub-declarations
+//     Member or value foo was declared
+//     Entity MyClass was declared and contains 0 sub-declarations
+//     Member or value .ctor was declared
+//     Member or value MyMethod was declared
+
+

As can be seen, the only declaration in the implementation file is that of the module MyLibrary, which +contains fours sub-declarations.

+
+

As an aside, one peculiarity here is that the member declarations (e.g. the "MyMethod" member) are returned as part of the containing module entity, not as part of their class. +Note that the class constructor is returned as a separate declaration. The class type definition has been "split" into a constructor and the other declarations.

+
+
let myLibraryEntity, myLibraryDecls =    
+   match checkedFile.Declarations.[0] with 
+   | FSharpImplementationFileDeclaration.Entity (e, subDecls) -> (e, subDecls)
+   | _ -> failwith "unexpected"
+
+

What about the expressions, for example the body of function "foo"? Let's find it:

+
let (fooSymbol, fooArgs, fooExpression) = 
+    match myLibraryDecls.[0] with 
+    | FSharpImplementationFileDeclaration.MemberOrFunctionOrValue(v, vs, e) -> (v, vs, e)
+    | _ -> failwith "unexpected"
+
+

Here 'fooSymbol' is a symbol associated with the declaration of 'foo', +'fooArgs' represents the formal arguments to the 'foo' function, and 'fooExpression' +is an expression for the implementation of the 'foo' function.

+

Once you have an expression, you can work with it much like an F# quotation. For example, +you can find its declaration range and its type:

+
fooExpression.Type  // shows that the return type of the body expression is 'int'
+fooExpression.Range  // shows the declaration range of the expression implementing 'foo'
+
+

Walking over expressions

+

Expressions are analyzed using active patterns, much like F# quotations. +Here is a generic expression visitor:

+
let rec visitExpr f (e:FSharpExpr) = 
+    f e
+    match e with 
+    | FSharpExprPatterns.AddressOf(lvalueExpr) -> 
+        visitExpr f lvalueExpr
+    | FSharpExprPatterns.AddressSet(lvalueExpr, rvalueExpr) -> 
+        visitExpr f lvalueExpr; visitExpr f rvalueExpr
+    | FSharpExprPatterns.Application(funcExpr, typeArgs, argExprs) -> 
+        visitExpr f funcExpr; visitExprs f argExprs
+    | FSharpExprPatterns.Call(objExprOpt, memberOrFunc, typeArgs1, typeArgs2, argExprs) -> 
+        visitObjArg f objExprOpt; visitExprs f argExprs
+    | FSharpExprPatterns.Coerce(targetType, inpExpr) -> 
+        visitExpr f inpExpr
+    | FSharpExprPatterns.FastIntegerForLoop(startExpr, limitExpr, consumeExpr, isUp, _, _) -> 
+        visitExpr f startExpr; visitExpr f limitExpr; visitExpr f consumeExpr
+    | FSharpExprPatterns.ILAsm(asmCode, typeArgs, argExprs) -> 
+        visitExprs f argExprs
+    | FSharpExprPatterns.ILFieldGet (objExprOpt, fieldType, fieldName) -> 
+        visitObjArg f objExprOpt
+    | FSharpExprPatterns.ILFieldSet (objExprOpt, fieldType, fieldName, valueExpr) -> 
+        visitObjArg f objExprOpt
+    | FSharpExprPatterns.IfThenElse (guardExpr, thenExpr, elseExpr) -> 
+        visitExpr f guardExpr; visitExpr f thenExpr; visitExpr f elseExpr
+    | FSharpExprPatterns.Lambda(lambdaVar, bodyExpr) -> 
+        visitExpr f bodyExpr
+    | FSharpExprPatterns.Let((bindingVar, bindingExpr, dbg), bodyExpr) -> 
+        visitExpr f bindingExpr; visitExpr f bodyExpr
+    | FSharpExprPatterns.LetRec(recursiveBindings, bodyExpr) ->
+        for _,bindingExpr,_ in recursiveBindings do visitExpr f bindingExpr
+        visitExpr f bodyExpr
+    | FSharpExprPatterns.NewArray(arrayType, argExprs) -> 
+        visitExprs f argExprs
+    | FSharpExprPatterns.NewDelegate(delegateType, delegateBodyExpr) -> 
+        visitExpr f delegateBodyExpr
+    | FSharpExprPatterns.NewObject(objType, typeArgs, argExprs) -> 
+        visitExprs f argExprs
+    | FSharpExprPatterns.NewRecord(recordType, argExprs) ->  
+        visitExprs f argExprs
+    | FSharpExprPatterns.NewAnonRecord(recordType, argExprs) ->  
+        visitExprs f argExprs
+    | FSharpExprPatterns.NewTuple(tupleType, argExprs) -> 
+        visitExprs f argExprs
+    | FSharpExprPatterns.NewUnionCase(unionType, unionCase, argExprs) -> 
+        visitExprs f argExprs
+    | FSharpExprPatterns.Quote(quotedExpr) -> 
+        visitExpr f quotedExpr
+    | FSharpExprPatterns.FSharpFieldGet(objExprOpt, recordOrClassType, fieldInfo) -> 
+        visitObjArg f objExprOpt
+    | FSharpExprPatterns.AnonRecordGet(objExpr, recordOrClassType, fieldInfo) -> 
+        visitExpr f objExpr
+    | FSharpExprPatterns.FSharpFieldSet(objExprOpt, recordOrClassType, fieldInfo, argExpr) -> 
+        visitObjArg f objExprOpt; visitExpr f argExpr
+    | FSharpExprPatterns.Sequential(firstExpr, secondExpr) -> 
+        visitExpr f firstExpr; visitExpr f secondExpr
+    | FSharpExprPatterns.TryFinally(bodyExpr, finalizeExpr, dbgTry, dbgFinally) -> 
+        visitExpr f bodyExpr; visitExpr f finalizeExpr
+    | FSharpExprPatterns.TryWith(bodyExpr, _, _, catchVar, catchExpr, dbgTry, dbgWith) -> 
+        visitExpr f bodyExpr; visitExpr f catchExpr
+    | FSharpExprPatterns.TupleGet(tupleType, tupleElemIndex, tupleExpr) -> 
+        visitExpr f tupleExpr
+    | FSharpExprPatterns.DecisionTree(decisionExpr, decisionTargets) -> 
+        visitExpr f decisionExpr; List.iter (snd >> visitExpr f) decisionTargets
+    | FSharpExprPatterns.DecisionTreeSuccess (decisionTargetIdx, decisionTargetExprs) -> 
+        visitExprs f decisionTargetExprs
+    | FSharpExprPatterns.TypeLambda(genericParam, bodyExpr) -> 
+        visitExpr f bodyExpr
+    | FSharpExprPatterns.TypeTest(ty, inpExpr) -> 
+        visitExpr f inpExpr
+    | FSharpExprPatterns.UnionCaseSet(unionExpr, unionType, unionCase, unionCaseField, valueExpr) -> 
+        visitExpr f unionExpr; visitExpr f valueExpr
+    | FSharpExprPatterns.UnionCaseGet(unionExpr, unionType, unionCase, unionCaseField) -> 
+        visitExpr f unionExpr
+    | FSharpExprPatterns.UnionCaseTest(unionExpr, unionType, unionCase) -> 
+        visitExpr f unionExpr
+    | FSharpExprPatterns.UnionCaseTag(unionExpr, unionType) -> 
+        visitExpr f unionExpr
+    | FSharpExprPatterns.ObjectExpr(objType, baseCallExpr, overrides, interfaceImplementations) -> 
+        visitExpr f baseCallExpr
+        List.iter (visitObjMember f) overrides
+        List.iter (snd >> List.iter (visitObjMember f)) interfaceImplementations
+    | FSharpExprPatterns.TraitCall(sourceTypes, traitName, typeArgs, typeInstantiation, argTypes, argExprs) -> 
+        visitExprs f argExprs
+    | FSharpExprPatterns.ValueSet(valToSet, valueExpr) -> 
+        visitExpr f valueExpr
+    | FSharpExprPatterns.WhileLoop(guardExpr, bodyExpr, dbg) -> 
+        visitExpr f guardExpr; visitExpr f bodyExpr
+    | FSharpExprPatterns.BaseValue baseType -> ()
+    | FSharpExprPatterns.DefaultValue defaultType -> ()
+    | FSharpExprPatterns.ThisValue thisType -> ()
+    | FSharpExprPatterns.Const(constValueObj, constType) -> ()
+    | FSharpExprPatterns.Value(valueToGet) -> ()
+    | _ -> failwith (sprintf "unrecognized %+A" e)
+
+and visitExprs f exprs = 
+    List.iter (visitExpr f) exprs
+
+and visitObjArg f objOpt = 
+    Option.iter (visitExpr f) objOpt
+
+and visitObjMember f memb = 
+    visitExpr f memb.Body
+
+

Let's use this expresssion walker:

+
fooExpression |> visitExpr (fun e -> printfn "Visiting %A" e)
+
+// Prints:
+//
+// Visiting Let...
+// Visiting Call...
+// Visiting Const ("Hello", ...)
+// Visiting Const (" ", ...)
+// Visiting Const ("world", ...)
+// Visiting IfThenElse...
+// Visiting Call...
+// Visiting Call...
+// Visiting Value ...
+// Visiting Const ...
+// Visiting Const ...
+// Visiting Const ...
+
+

Note that

+ +

Summary

+

In this tutorial, we looked at the basics of working with checked declarations and expressions.

+

In practice, it is also useful to combine the information here +with some information you can obtain from the symbols +tutorial.

+ +
namespace System
+
namespace System.IO
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.EditorServices
+
namespace FSharp.Compiler.Symbols
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

--------------------
type FSharpAttribute = + member Format: context: FSharpDisplayContext -> string + member IsAttribute: unit -> bool + member AttributeType: FSharpEntity + member ConstructorArguments: IList<FSharpType * obj> + member IsUnresolved: bool + member NamedArguments: IList<FSharpType * string * bool * obj> + member Range: range
<summary> + Represents a custom attribute attached to F# source code or a compiler .NET component +</summary>
+
namespace FSharp.Compiler.Text
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val parseAndCheckSingleFile: input: string -> FSharpCheckProjectResults
+
val input: string
+
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.ChangeExtension(path: string, extension: string) : string
+
Path.GetTempFileName() : string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit
+
val projOptions: FSharpProjectOptions
+
val _errors: FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
member FSharpChecker.GetProjectOptionsFromScript: fileName: string * source: ISourceText * ?previewEnabled: bool * ?loadedTimeStamp: DateTime * ?otherFlags: string array * ?useFsiAuxLib: bool * ?useSdkRefs: bool * ?assumeDotNetFramework: bool * ?sdkDirOverride: string * ?optionsStamp: int64 * ?userOpName: string -> Async<FSharpProjectOptions * FSharp.Compiler.Diagnostics.FSharpDiagnostic list>
+
module SourceText + +from FSharp.Compiler.Text
<summary> + Functions related to ISourceText objects +</summary>
+
val ofString: string -> ISourceText
<summary> + Creates an ISourceText object from the given string +</summary>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: Threading.CancellationToken -> 'T
+
member FSharpChecker.ParseAndCheckProject: options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckProjectResults>
+
val input2: string
+
val checkProjectResults: FSharpCheckProjectResults
+
property FSharpCheckProjectResults.Diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic array with get
<summary> + The errors returned by processing the project +</summary>
+
val checkedFile: FSharpImplementationFileContents
+
property FSharpCheckProjectResults.AssemblyContents: FSharpAssemblyContents with get
<summary> + Get a view of the overall contents of the assembly. Only valid to use if HasCriticalErrors is false. +</summary>
+
property FSharpAssemblyContents.ImplementationFiles: FSharpImplementationFileContents list with get
<summary> + The contents of the implementation files in the assembly +</summary>
+
val printDecl: prefix: string -> d: FSharpImplementationFileDeclaration -> unit
+
val prefix: string
+
val d: FSharpImplementationFileDeclaration
+
type FSharpImplementationFileDeclaration = + | Entity of entity: FSharpEntity * declarations: FSharpImplementationFileDeclaration list + | MemberOrFunctionOrValue of value: FSharpMemberOrFunctionOrValue * curriedArgs: FSharpMemberOrFunctionOrValue list list * body: FSharpExpr + | InitAction of action: FSharpExpr
<summary> + Represents a declaration in an implementation file, as seen by the F# language +</summary>
+
union case FSharpImplementationFileDeclaration.Entity: entity: FSharpEntity * declarations: FSharpImplementationFileDeclaration list -> FSharpImplementationFileDeclaration
<summary> + Represents the declaration of a type +</summary>
+
val e: FSharpEntity
+
val subDecls: FSharpImplementationFileDeclaration list
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
property FSharpEntity.CompiledName: string with get
<summary> + Get the compiled name of the type or module, possibly with `n mangling. This is identical to LogicalName + unless the CompiledName attribute is used. +</summary>
+
property List.Length: int with get
+
val subDecl: FSharpImplementationFileDeclaration
+
union case FSharpImplementationFileDeclaration.MemberOrFunctionOrValue: value: FSharpMemberOrFunctionOrValue * curriedArgs: FSharpMemberOrFunctionOrValue list list * body: FSharpExpr -> FSharpImplementationFileDeclaration
<summary> + Represents the declaration of a member, function or value, including the parameters and body of the member +</summary>
+
val v: FSharpMemberOrFunctionOrValue
+
val vs: FSharpMemberOrFunctionOrValue list list
+
val e: FSharpExpr
+
property FSharpMemberOrFunctionOrValue.CompiledName: string with get
<summary> + Get the member name in compiled code +</summary>
+
union case FSharpImplementationFileDeclaration.InitAction: action: FSharpExpr -> FSharpImplementationFileDeclaration
<summary> + Represents the declaration of a static initialization action +</summary>
+
property FSharpImplementationFileContents.Declarations: FSharpImplementationFileDeclaration list with get
<summary> + Get the declarations that make up this implementation file +</summary>
+
val myLibraryEntity: FSharpEntity
+
val myLibraryDecls: FSharpImplementationFileDeclaration list
+
val failwith: message: string -> 'T
+
val fooSymbol: FSharpMemberOrFunctionOrValue
+
val fooArgs: FSharpMemberOrFunctionOrValue list list
+
val fooExpression: FSharpExpr
+
property FSharpExpr.Type: FSharpType with get
<summary> + The type of the expression +</summary>
+
property FSharpExpr.Range: range with get
<summary> + The range of the expression +</summary>
+
val visitExpr: f: (FSharpExpr -> unit) -> e: FSharpExpr -> unit
+
val f: (FSharpExpr -> unit)
+
type FSharpExpr = + member ImmediateSubExpressions: FSharpExpr list + member Range: range + member Type: FSharpType
<summary> + Represents a checked and reduced expression, as seen by the F# language. The active patterns + in 'FSharp.Compiler.SourceCodeServices' can be used to analyze information about the expression. + + Pattern matching is reduced to decision trees and conditional tests. Some other + constructs may be represented in reduced form. +</summary>
+
module FSharpExprPatterns + +from FSharp.Compiler.Symbols
<summary> + A collection of active patterns to analyze expressions +</summary>
+
active recognizer AddressOf: FSharpExpr -> FSharpExpr option
<summary> + Matches expressions which take the address of a location +</summary>
+
val lvalueExpr: FSharpExpr
+
active recognizer AddressSet: FSharpExpr -> (FSharpExpr * FSharpExpr) option
<summary> + Matches expressions which set the contents of an address +</summary>
+
val rvalueExpr: FSharpExpr
+
active recognizer Application: FSharpExpr -> (FSharpExpr * FSharpType list * FSharpExpr list) option
<summary> + Matches expressions which are the application of function values +</summary>
+
val funcExpr: FSharpExpr
+
val typeArgs: FSharpType list
+
val argExprs: FSharpExpr list
+
val visitExprs: f: (FSharpExpr -> unit) -> exprs: FSharpExpr list -> unit
+
active recognizer Call: FSharpExpr -> (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list) option
<summary> + Matches expressions which are calls to members or module-defined functions. When calling curried functions and members the + arguments are collapsed to a single collection of arguments, as done in the compiled version of these. +</summary>
+
val objExprOpt: FSharpExpr option
+
val memberOrFunc: FSharpMemberOrFunctionOrValue
+
val typeArgs1: FSharpType list
+
val typeArgs2: FSharpType list
+
val visitObjArg: f: (FSharpExpr -> unit) -> objOpt: FSharpExpr option -> unit
+
active recognizer Coerce: FSharpExpr -> (FSharpType * FSharpExpr) option
<summary> + Matches expressions which coerce the type of a value +</summary>
+
val targetType: FSharpType
+
val inpExpr: FSharpExpr
+
active recognizer FastIntegerForLoop: FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr * bool * FSharp.Compiler.Syntax.DebugPointAtFor * FSharp.Compiler.Syntax.DebugPointAtInOrTo) option
<summary> + Matches fast-integer loops (up or down) +</summary>
+
val startExpr: FSharpExpr
+
val limitExpr: FSharpExpr
+
val consumeExpr: FSharpExpr
+
val isUp: bool
+
active recognizer ILAsm: FSharpExpr -> (string * FSharpType list * FSharpExpr list) option
<summary> + Matches expressions which are IL assembly code +</summary>
+
val asmCode: string
+
active recognizer ILFieldGet: FSharpExpr -> (FSharpExpr option * FSharpType * string) option
<summary> + Matches expressions which fetch a field from a .NET type +</summary>
+
val fieldType: FSharpType
+
val fieldName: string
+
active recognizer ILFieldSet: FSharpExpr -> (FSharpExpr option * FSharpType * string * FSharpExpr) option
<summary> + Matches expressions which set a field in a .NET type +</summary>
+
val valueExpr: FSharpExpr
+
active recognizer IfThenElse: FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr) option
<summary> + Matches expressions which are conditionals +</summary>
+
val guardExpr: FSharpExpr
+
val thenExpr: FSharpExpr
+
val elseExpr: FSharpExpr
+
active recognizer Lambda: FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option
<summary> + Matches expressions which are lambda abstractions +</summary>
+
val lambdaVar: FSharpMemberOrFunctionOrValue
+
val bodyExpr: FSharpExpr
+
active recognizer Let: FSharpExpr -> ((FSharpMemberOrFunctionOrValue * FSharpExpr * FSharp.Compiler.Syntax.DebugPointAtBinding) * FSharpExpr) option
<summary> + Matches expressions which are let definitions +</summary>
+
val bindingVar: FSharpMemberOrFunctionOrValue
+
val bindingExpr: FSharpExpr
+
val dbg: FSharp.Compiler.Syntax.DebugPointAtBinding
+
active recognizer LetRec: FSharpExpr -> ((FSharpMemberOrFunctionOrValue * FSharpExpr * FSharp.Compiler.Syntax.DebugPointAtBinding) list * FSharpExpr) option
<summary> + Matches expressions which are let-rec definitions +</summary>
+
val recursiveBindings: (FSharpMemberOrFunctionOrValue * FSharpExpr * FSharp.Compiler.Syntax.DebugPointAtBinding) list
+
active recognizer NewArray: FSharpExpr -> (FSharpType * FSharpExpr list) option
<summary> + Matches array expressions +</summary>
+
val arrayType: FSharpType
+
active recognizer NewDelegate: FSharpExpr -> (FSharpType * FSharpExpr) option
<summary> + Matches expressions which create an instance of a delegate type +</summary>
+
val delegateType: FSharpType
+
val delegateBodyExpr: FSharpExpr
+
active recognizer NewObject: FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list) option
<summary> + Matches expressions which are calls to object constructors +</summary>
+
val objType: FSharpMemberOrFunctionOrValue
+
active recognizer NewRecord: FSharpExpr -> (FSharpType * FSharpExpr list) option
<summary> + Matches record expressions +</summary>
+
val recordType: FSharpType
+
active recognizer NewAnonRecord: FSharpExpr -> (FSharpType * FSharpExpr list) option
<summary> + Matches anonymous record expressions +</summary>
+
active recognizer NewTuple: FSharpExpr -> (FSharpType * FSharpExpr list) option
<summary> + Matches tuple expressions +</summary>
+
val tupleType: FSharpType
+
active recognizer NewUnionCase: FSharpExpr -> (FSharpType * FSharpUnionCase * FSharpExpr list) option
<summary> + Matches expressions which create an object corresponding to a union case +</summary>
+
val unionType: FSharpType
+
val unionCase: FSharpUnionCase
+
active recognizer Quote: FSharpExpr -> FSharpExpr option
<summary> + Matches expressions which are quotation literals +</summary>
+
val quotedExpr: FSharpExpr
+
active recognizer FSharpFieldGet: FSharpExpr -> (FSharpExpr option * FSharpType * FSharpField) option
<summary> + Matches expressions which get a field from a record or class +</summary>
+
val recordOrClassType: FSharpType
+
val fieldInfo: FSharpField
+
active recognizer AnonRecordGet: FSharpExpr -> (FSharpExpr * FSharpType * int) option
<summary> + Matches expressions getting a field from an anonymous record. The integer represents the + index into the sorted fields of the anonymous record. +</summary>
+
val objExpr: FSharpExpr
+
val fieldInfo: int
+
active recognizer FSharpFieldSet: FSharpExpr -> (FSharpExpr option * FSharpType * FSharpField * FSharpExpr) option
<summary> + Matches expressions which set a field in a record or class +</summary>
+
val argExpr: FSharpExpr
+
active recognizer Sequential: FSharpExpr -> (FSharpExpr * FSharpExpr) option
<summary> + Matches sequential expressions +</summary>
+
val firstExpr: FSharpExpr
+
val secondExpr: FSharpExpr
+
active recognizer TryFinally: FSharpExpr -> (FSharpExpr * FSharpExpr * FSharp.Compiler.Syntax.DebugPointAtTry * FSharp.Compiler.Syntax.DebugPointAtFinally) option
<summary> + Matches try/finally expressions +</summary>
+
val finalizeExpr: FSharpExpr
+
val dbgTry: FSharp.Compiler.Syntax.DebugPointAtTry
+
val dbgFinally: FSharp.Compiler.Syntax.DebugPointAtFinally
+
active recognizer TryWith: FSharpExpr -> (FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * FSharp.Compiler.Syntax.DebugPointAtTry * FSharp.Compiler.Syntax.DebugPointAtWith) option
<summary> + Matches try/with expressions +</summary>
+
val catchVar: FSharpMemberOrFunctionOrValue
+
val catchExpr: FSharpExpr
+
val dbgWith: FSharp.Compiler.Syntax.DebugPointAtWith
+
active recognizer TupleGet: FSharpExpr -> (FSharpType * int * FSharpExpr) option
<summary> + Matches expressions which get a value from a tuple +</summary>
+
val tupleElemIndex: int
+
val tupleExpr: FSharpExpr
+
active recognizer DecisionTree: FSharpExpr -> (FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list) option
<summary> + Matches expressions with a decision expression, each branch of which ends in DecisionTreeSuccess passing control and values to one of the targets. +</summary>
+
val decisionExpr: FSharpExpr
+
val decisionTargets: (FSharpMemberOrFunctionOrValue list * FSharpExpr) 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 iter: action: ('T -> unit) -> list: 'T list -> unit
+
val snd: tuple: ('T1 * 'T2) -> 'T2
+
active recognizer DecisionTreeSuccess: FSharpExpr -> (int * FSharpExpr list) option
<summary> + Special expressions at the end of a conditional decision structure in the decision expression node of a DecisionTree . + The given expressions are passed as values to the decision tree target. +</summary>
+
val decisionTargetIdx: int
+
val decisionTargetExprs: FSharpExpr list
+
active recognizer TypeLambda: FSharpExpr -> (FSharpGenericParameter list * FSharpExpr) option
<summary> + Matches expressions which are type abstractions +</summary>
+
val genericParam: FSharpGenericParameter list
+
active recognizer TypeTest: FSharpExpr -> (FSharpType * FSharpExpr) option
<summary> + Matches expressions which test the runtime type of a value +</summary>
+
val ty: FSharpType
+
active recognizer UnionCaseSet: FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr) option
<summary> + Matches expressions which set a field from a union case (only used in FSharp.Core itself) +</summary>
+
val unionExpr: FSharpExpr
+
val unionCaseField: FSharpField
+
active recognizer UnionCaseGet: FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField) option
<summary> + Matches expressions which get a field from a union case +</summary>
+
active recognizer UnionCaseTest: FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase) option
<summary> + Matches expressions which test if an expression corresponds to a particular union case +</summary>
+
active recognizer UnionCaseTag: FSharpExpr -> (FSharpExpr * FSharpType) option
<summary> + Matches expressions which gets the tag for a union case +</summary>
+
active recognizer ObjectExpr: FSharpExpr -> (FSharpType * FSharpExpr * FSharpObjectExprOverride list * (FSharpType * FSharpObjectExprOverride list) list) option
<summary> + Matches object expressions, returning the base type, the base call, the overrides and the interface implementations +</summary>
+
val objType: FSharpType
+
val baseCallExpr: FSharpExpr
+
val overrides: FSharpObjectExprOverride list
+
val interfaceImplementations: (FSharpType * FSharpObjectExprOverride list) list
+
val visitObjMember: f: (FSharpExpr -> unit) -> memb: FSharpObjectExprOverride -> unit
+
active recognizer TraitCall: FSharpExpr -> (FSharpType list * string * FSharp.Compiler.Syntax.SynMemberFlags * FSharpType list * FSharpType list * FSharpExpr list) option
<summary> + Matches expressions for an unresolved call to a trait +</summary>
+
val sourceTypes: FSharpType list
+
val traitName: string
+
val typeArgs: FSharp.Compiler.Syntax.SynMemberFlags
+
val typeInstantiation: FSharpType list
+
val argTypes: FSharpType list
+
active recognizer ValueSet: FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option
<summary> + Matches expressions which set the contents of a mutable variable +</summary>
+
val valToSet: FSharpMemberOrFunctionOrValue
+
active recognizer WhileLoop: FSharpExpr -> (FSharpExpr * FSharpExpr * FSharp.Compiler.Syntax.DebugPointAtWhile) option
<summary> + Matches while loops +</summary>
+
val dbg: FSharp.Compiler.Syntax.DebugPointAtWhile
+
active recognizer BaseValue: FSharpExpr -> FSharpType option
<summary> + Matches expressions which are uses of the 'base' value +</summary>
+
val baseType: FSharpType
+
active recognizer DefaultValue: FSharpExpr -> FSharpType option
<summary> + Matches default-value expressions, including null expressions +</summary>
+
val defaultType: FSharpType
+
active recognizer ThisValue: FSharpExpr -> FSharpType option
<summary> + Matches expressions which are uses of the 'this' value +</summary>
+
val thisType: FSharpType
+
active recognizer Const: FSharpExpr -> (obj * FSharpType) option
<summary> + Matches constant expressions, including signed and unsigned integers, strings, characters, booleans, arrays + of bytes and arrays of unit16. +</summary>
+
val constValueObj: obj
+
val constType: FSharpType
+
active recognizer Value: FSharpExpr -> FSharpMemberOrFunctionOrValue option
<summary> + Matches expressions which are uses of values +</summary>
+
val valueToGet: FSharpMemberOrFunctionOrValue
+
val sprintf: format: Printf.StringFormat<'T> -> 'T
+
val exprs: FSharpExpr list
+
val objOpt: FSharpExpr option
+
module Option + +from Microsoft.FSharp.Core
+
val iter: action: ('T -> unit) -> option: 'T option -> unit
+
val memb: FSharpObjectExprOverride
+
property FSharpObjectExprOverride.Body: FSharpExpr with get
<summary> + The expression that forms the body of the method +</summary>
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fcs/untypedtree.html b/fcs/untypedtree.html new file mode 100644 index 0000000000..14408d21c5 --- /dev/null +++ b/fcs/untypedtree.html @@ -0,0 +1,982 @@ + + + + + + + + + + + + + + + + + + Tutorial: Expressions | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Services: Processing SyntaxTree

+

This tutorial demonstrates how to get the SyntaxTree (AST) +for F# code and how to walk over the tree. This can be used for creating tools +such as code formatter, basic refactoring or code navigation tools. The untyped +syntax tree contains information about the code structure, but does not contain +types and there are some ambiguities that are resolved only later by the type +checker. You can also combine the SyntaxTree information with the API available +from editor services.

+
+

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published

+
+

Getting the SyntaxTree

+

To access the untyped AST, you need to create an instance of FSharpChecker. +This type represents a context for type checking and parsing and corresponds either +to a stand-alone F# script file (e.g. opened in Visual Studio) or to a loaded project +file with multiple files. Once you have an instance of FSharpChecker, you can +use it to perform "untyped parse" which is the first step of type-checking. The +second phase is "typed parse" and is used by editor services.

+

To use the interactive checker, reference FSharp.Compiler.Service.dll and open the +SourceCodeServices namespace:

+
#r "FSharp.Compiler.Service.dll"
+open System
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Text
+
+

Performing untyped parse

+

The untyped parse operation is very fast (compared to type checking, which can +take notable amount of time) and so we can perform it synchronously. First, we +need to create FSharpChecker - the constructor takes an argument that +can be used to notify the checker about file changes (which we ignore).

+
// Create an interactive checker instance 
+let checker = FSharpChecker.Create()
+
+

To get the AST, we define a function that takes file name and the source code +(the file is only used for location information and does not have to exist). +We first need to get "interactive checker options" which represents the context. +For simple tasks, you can use GetProjectOptionsFromScriptRoot which infers +the context for a script file. Then we use the ParseFile method and +return the ParseTree property:

+
/// Get untyped tree for a specified input
+let getUntypedTree (file, input) = 
+  // Get compiler options for the 'project' implied by a single script file
+  let projOptions, diagnostics = 
+      checker.GetProjectOptionsFromScript(file, input, assumeDotNetFramework=false)
+      |> Async.RunSynchronously
+
+  let parsingOptions, _errors = checker.GetParsingOptionsFromProjectOptions(projOptions)
+
+  // Run the first phase (untyped parsing) of the compiler
+  let parseFileResults = 
+      checker.ParseFile(file, input, parsingOptions) 
+      |> Async.RunSynchronously
+
+  parseFileResults.ParseTree
+  
+
+

Walking over the AST

+

The abstract syntax tree is defined as a number of discriminated unions that represent +different syntactical elements (such as expressions, patterns, declarations etc.). The best +way to understand the AST is to look at the definitions in +SyntaxTree.fsi +in the source code.

+

The relevant parts are in the following namespace:

+
open FSharp.Compiler.Syntax
+
+

When processing the AST, you will typically write a number of mutually recursive functions +that pattern match on the different syntactical elements. There is a number of elements +that need to be supported - the top-level element is module or namespace declaration, +containing declarations inside a module (let bindings, types etc.). A let declaration inside +a module then contains expressions, which can contain patterns.

+

Walking over patterns and expressions

+

We start by looking at functions that walk over expressions and patterns - as we walk, +we print information about the visited elements. For patterns, the input is of type +SynPat and has a number of cases including Wild (for _ pattern), Named (for +<pat> as name) and LongIdent (for a Foo.Bar name). Note that the parsed pattern +is occasionally more complex than what is in the source code (in particular, Named is +used more often):

+
/// Walk over a pattern - this is for example used in 
+/// let <pat> = <expr> or in the 'match' expression
+let rec visitPattern = function
+  | SynPat.Wild _ -> 
+      printfn "  .. underscore pattern"
+  | SynPat.Named(ident = SynIdent(ident = name)) ->
+      printfn "  .. named as '%s'" name.idText
+  | SynPat.LongIdent(longDotId = SynLongIdent(id = ident)) ->
+      let names = String.concat "." [ for i in ident -> i.idText ]
+      printfn "  .. identifier: %s" names
+  | pat -> printfn "  .. other pattern: %A" pat
+
+

The function is recursive (for nested patterns such as (foo, _) as bar), but it does not +call any of the functions defined later (because patterns cannot contain other syntactical +elements).

+

The next function iterates over expressions - this is where most of the work would be and +there are around 20 cases to cover (type SynExpr. and you'll get completion with other +options). In the following, we only show how to handle if .. then .. and let .. = ...:

+
/// Walk over an expression - if expression contains two or three 
+/// sub-expressions (two if the 'else' branch is missing), let expression
+/// contains pattern and two sub-expressions
+let rec visitExpression e = 
+  match e with
+  | SynExpr.IfThenElse(ifExpr=cond; thenExpr=trueBranch; elseExpr=falseBranchOpt) ->
+      // Visit all sub-expressions
+      printfn "Conditional:"
+      visitExpression cond
+      visitExpression trueBranch
+      falseBranchOpt |> Option.iter visitExpression 
+
+  | SynExpr.LetOrUse(_, _, bindings, body, _, _) ->
+      // Visit bindings (there may be multiple 
+      // for 'let .. = .. and .. = .. in ...'
+      printfn "LetOrUse with the following bindings:"
+      for binding in bindings do
+        let (SynBinding(headPat = headPat; expr = init)) = binding
+        visitPattern headPat
+        visitExpression init
+      // Visit the body expression
+      printfn "And the following body:"
+      visitExpression body
+  | expr -> printfn " - not supported expression: %A" expr
+
+

The visitExpression function will be called from a function that visits all top-level +declarations inside a module. In this tutorial, we ignore types and members, but that would +be another source of calls to visitExpression.

+

Walking over declarations

+

As mentioned earlier, the AST of a file contains a number of module or namespace declarations +(top-level node) that contain declarations inside a module (let bindings or types) or inside +a namespace (just types). The following function walks over declarations - we ignore types, +nested modules and all other elements and look only at top-level let bindings (values and +functions):

+
/// Walk over a list of declarations in a module. This is anything
+/// that you can write as a top-level inside module (let bindings,
+/// nested modules, type declarations etc.)
+let visitDeclarations decls = 
+  for declaration in decls do
+    match declaration with
+    | SynModuleDecl.Let(isRec, bindings, range) ->
+        // Let binding as a declaration is similar to let binding
+        // as an expression (in visitExpression), but has no body
+        for binding in bindings do
+          let (SynBinding(headPat = pat; expr = body)) = binding
+          visitPattern pat 
+          visitExpression body         
+    | _ -> printfn " - not supported declaration: %A" declaration
+
+

The visitDeclarations function will be called from a function that walks over a +sequence of module or namespace declarations. This corresponds, for example, to a file +with multiple namespace Foo declarations:

+
/// Walk over all module or namespace declarations 
+/// (basically 'module Foo =' or 'namespace Foo.Bar')
+/// Note that there is one implicitly, even if the file
+/// does not explicitly define it..
+let visitModulesAndNamespaces modulesOrNss =
+  for moduleOrNs in modulesOrNss do
+    let (SynModuleOrNamespace(longId = lid; decls = decls)) = moduleOrNs
+    printfn "Namespace or module: %A" lid
+    visitDeclarations decls
+
+

Now that we have functions that walk over the elements of the AST (starting from declaration, +down to expressions and patterns), we can get AST of a sample input and run the above function.

+

Putting things together

+

As already discussed, the getUntypedTree function uses FSharpChecker to run the first +phase (parsing) on the AST and get back the tree. The function requires F# source code together +with location of the file. The location does not have to exist (it is used only for location +information) and it can be in both Unix and Windows formats:

+
// Sample input for the compiler service
+let input =
+  """
+  let foo() = 
+    let msg = "Hello world"
+    if true then 
+      printfn "%s" msg
+  """
+
+// File name in Unix format
+let file = "/home/user/Test.fsx"
+
+// Get the AST of sample F# code
+let tree = getUntypedTree(file, SourceText.ofString input)
+
+

When you run the code in F# interactive, you can enter tree;; in the interactive console and +see a pretty printed representation of the data structure - the tree contains a lot of information, +so this is not particularly readable, but it gives you a good idea about how the tree looks.

+

The returned tree value is again a discriminated union that can be two different cases - one case +is ParsedInput.SigFile which represents F# signature file (*.fsi) and the other one is +ParsedInput.ImplFile representing regular source code (*.fsx or *.fs). The implementation +file contains a sequence of modules or namespaces that we can pass to the function implemented +in the previous step:

+
// Extract implementation file details
+match tree with
+| ParsedInput.ImplFile(implFile) ->
+    // Extract declarations and walk over them
+    let (ParsedImplFileInput(contents = modules)) = implFile
+    visitModulesAndNamespaces modules
+| _ -> failwith "F# Interface file (*.fsi) not supported."
+
+

Summary

+

In this tutorial, we looked at the basics of working with the untyped abstract syntax tree. This is a +comprehensive topic, so it is not possible to explain everything in a single article. The +Fantomas project is a good example of a tool based on the untyped +AST that can help you understand more. In practice, it is also useful to combine the information here +with some information you can obtain from the editor services discussed in the next +tutorial.

+ +
namespace System
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
namespace FSharp.Compiler
+
namespace FSharp.Compiler.CodeAnalysis
+
namespace FSharp.Compiler.Text
+
val checker: FSharpChecker
+
type FSharpChecker = + member CheckFileInProject: parseResults: FSharpParseFileResults * fileName: string * fileVersion: int * sourceText: ISourceText * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpCheckFileAnswer> + member ClearCache: options: FSharpProjectOptions seq * ?userOpName: string -> unit + member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> unit + member Compile: argv: string array * ?userOpName: string -> Async<FSharpDiagnostic array * int> + member FindBackgroundReferencesInFile: fileName: string * options: FSharpProjectOptions * symbol: FSharpSymbol * ?canInvalidateProject: bool * [<Experimental ("This FCS API is experimental and subject to change.")>] ?fastCheck: bool * ?userOpName: string -> Async<range seq> + member GetBackgroundCheckResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults * FSharpCheckFileResults> + member GetBackgroundParseResultsForFileInProject: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<FSharpParseFileResults> + member GetBackgroundSemanticClassificationForFile: fileName: string * options: FSharpProjectOptions * ?userOpName: string -> Async<SemanticClassificationView option> + member GetParsingOptionsFromCommandLineArgs: sourceFiles: string list * argv: string list * ?isInteractive: bool * ?isEditing: bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload + member GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharpDiagnostic list + ...
<summary> + Used to parse and check F# source code. +</summary>
+
static member FSharpChecker.Create: ?projectCacheSize: int * ?keepAssemblyContents: bool * ?keepAllBackgroundResolutions: bool * ?legacyReferenceResolver: LegacyReferenceResolver * ?tryGetMetadataSnapshot: FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors: bool * ?keepAllBackgroundSymbolUses: bool * ?enableBackgroundItemKeyStoreAndSemanticClassification: bool * ?enablePartialTypeChecking: bool * ?parallelReferenceResolution: bool * ?captureIdentifiersWhenParsing: bool * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?documentSource: DocumentSource * [<Experimental ("This parameter is experimental and likely to be removed in the future.")>] ?useSyntaxTreeCache: bool -> FSharpChecker
+
val getUntypedTree: file: string * input: ISourceText -> FSharp.Compiler.Syntax.ParsedInput
 Get untyped tree for a specified input
+
val file: string
+
val input: ISourceText
+
val projOptions: FSharpProjectOptions
+
val diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
member FSharpChecker.GetProjectOptionsFromScript: fileName: string * source: ISourceText * ?previewEnabled: bool * ?loadedTimeStamp: DateTime * ?otherFlags: string array * ?useFsiAuxLib: bool * ?useSdkRefs: bool * ?assumeDotNetFramework: bool * ?sdkDirOverride: string * ?optionsStamp: int64 * ?userOpName: string -> Async<FSharpProjectOptions * FSharp.Compiler.Diagnostics.FSharpDiagnostic list>
+
Multiple items
type Async = + static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) + static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) + static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> + static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload + static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> + static member CancelDefaultToken: unit -> unit + static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> + static member Choice: computations: Async<'T option> seq -> Async<'T option> + static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads + static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> + ...

--------------------
type Async<'T>
+
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: Threading.CancellationToken -> 'T
+
val parsingOptions: FSharpParsingOptions
+
val _errors: FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
member FSharpChecker.GetParsingOptionsFromProjectOptions: options: FSharpProjectOptions -> FSharpParsingOptions * FSharp.Compiler.Diagnostics.FSharpDiagnostic list
+
val parseFileResults: FSharpParseFileResults
+
member FSharpChecker.ParseFile: fileName: string * sourceText: ISourceText * options: FSharpParsingOptions * ?cache: bool * ?userOpName: string -> Async<FSharpParseFileResults>
+
property FSharpParseFileResults.ParseTree: FSharp.Compiler.Syntax.ParsedInput with get
<summary> + The syntax tree resulting from the parse +</summary>
+
namespace FSharp.Compiler.Syntax
+
val visitPattern: _arg1: SynPat -> unit
 Walk over a pattern - this is for example used in
 let <pat> = <expr> or in the 'match' expression
+
type SynPat = + | Const of constant: SynConst * range: range + | Wild of range: range + | Named of ident: SynIdent * isThisVal: bool * accessibility: SynAccess option * range: range + | Typed of pat: SynPat * targetType: SynType * range: range + | Attrib of pat: SynPat * attributes: SynAttributes * range: range + | Or of lhsPat: SynPat * rhsPat: SynPat * range: range * trivia: SynPatOrTrivia + | ListCons of lhsPat: SynPat * rhsPat: SynPat * range: range * trivia: SynPatListConsTrivia + | Ands of pats: SynPat list * range: range + | As of lhsPat: SynPat * rhsPat: SynPat * range: range + | LongIdent of longDotId: SynLongIdent * extraId: Ident option * typarDecls: SynValTyparDecls option * argPats: SynArgPats * accessibility: SynAccess option * range: range + ... + member Range: range
<summary> + Represents a syntax tree for an F# pattern +</summary>
+
union case SynPat.Wild: range: range -> SynPat
<summary> + A wildcard '_' in a pattern +</summary>
+
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
union case SynPat.Named: ident: SynIdent * isThisVal: bool * accessibility: SynAccess option * range: range -> SynPat
<summary> + A name pattern 'ident' +</summary>
+
Multiple items
union case SynIdent.SynIdent: ident: Ident * trivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia option -> SynIdent

--------------------
type SynIdent = | SynIdent of ident: Ident * trivia: IdentTrivia option
<summary> + Represents an identifier with potentially additional trivia information. +</summary>
+
val name: Ident
+
property Ident.idText: string with get
+
union case SynPat.LongIdent: longDotId: SynLongIdent * extraId: Ident option * typarDecls: SynValTyparDecls option * argPats: SynArgPats * accessibility: SynAccess option * range: range -> SynPat
<summary> + A long identifier pattern possibly with argument patterns +</summary>
+
Multiple items
union case SynLongIdent.SynLongIdent: id: LongIdent * dotRanges: range list * trivia: FSharp.Compiler.SyntaxTrivia.IdentTrivia option list -> SynLongIdent

--------------------
type SynLongIdent = + | SynLongIdent of id: LongIdent * dotRanges: range list * trivia: IdentTrivia option list + member Dots: range list + member IdentsWithTrivia: SynIdent list + member LongIdent: LongIdent + member Range: range + member RangeWithoutAnyExtraDot: range + member ThereIsAnExtraDotAtTheEnd: bool + member Trivia: IdentTrivia list
<summary> + Represents a long identifier with possible '.' at end. + + Typically dotRanges.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. "Foo.Bar." + The dots mostly matter for parsing, and are typically ignored by the typechecker, but + if dotRanges.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed + more freedom about typechecking these expressions. + LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit) +</summary>
+
val id: x: 'T -> 'T
+
val ident: LongIdent
+
val names: string
+
Multiple items
type String = + interface IEnumerable<char> + interface IEnumerable + interface ICloneable + interface IComparable + interface IComparable<string> + interface IConvertible + interface IEquatable<string> + interface IParsable<string> + interface ISpanParsable<string> + new: value: nativeptr<char> -> unit + 8 overloads + ...
<summary>Represents text as a sequence of UTF-16 code units.</summary>

--------------------
String(value: nativeptr<char>) : String
String(value: char array) : String
String(value: ReadOnlySpan<char>) : String
String(value: nativeptr<sbyte>) : String
String(c: char, count: int) : String
String(value: nativeptr<char>, startIndex: int, length: int) : String
String(value: char array, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: Text.Encoding) : String
+
val concat: sep: string -> strings: string seq -> string
+
val i: Ident
+
val pat: SynPat
+
val visitExpression: e: SynExpr -> unit
 Walk over an expression - if expression contains two or three
 sub-expressions (two if the 'else' branch is missing), let expression
 contains pattern and two sub-expressions
+
val e: SynExpr
+
type SynExpr = + | Paren of expr: SynExpr * leftParenRange: range * rightParenRange: range option * range: range + | Quote of operator: SynExpr * isRaw: bool * quotedExpr: SynExpr * isFromQueryExpression: bool * range: range + | Const of constant: SynConst * range: range + | Typed of expr: SynExpr * targetType: SynType * range: range + | Tuple of isStruct: bool * exprs: SynExpr list * commaRanges: range list * range: range + | AnonRecd of isStruct: bool * copyInfo: (SynExpr * BlockSeparator) option * recordFields: (SynLongIdent * range option * SynExpr) list * range: range * trivia: SynExprAnonRecdTrivia + | ArrayOrList of isArray: bool * exprs: SynExpr list * range: range + | Record of baseInfo: (SynType * SynExpr * range * BlockSeparator option * range) option * copyInfo: (SynExpr * BlockSeparator) option * recordFields: SynExprRecordField list * range: range + | New of isProtected: bool * targetType: SynType * expr: SynExpr * range: range + | ObjExpr of objType: SynType * argOptions: (SynExpr * Ident option) option * withKeyword: range option * bindings: SynBinding list * members: SynMemberDefns * extraImpls: SynInterfaceImpl list * newExprRange: range * range: range + ... + member IsArbExprAndThusAlreadyReportedError: bool + member Range: range + member RangeOfFirstPortion: range + member RangeWithoutAnyExtraDot: range
<summary> + Represents a syntax tree for F# expressions +</summary>
+
union case SynExpr.IfThenElse: ifExpr: SynExpr * thenExpr: SynExpr * elseExpr: SynExpr option * spIfToThen: DebugPointAtBinding * isFromErrorRecovery: bool * range: range * trivia: FSharp.Compiler.SyntaxTrivia.SynExprIfThenElseTrivia -> SynExpr
<summary> + F# syntax: if expr then expr + F# syntax: if expr then expr else expr +</summary>
+
val cond: SynExpr
+
val trueBranch: SynExpr
+
val falseBranchOpt: SynExpr option
+
module Option + +from Microsoft.FSharp.Core
+
val iter: action: ('T -> unit) -> option: 'T option -> unit
+
union case SynExpr.LetOrUse: isRecursive: bool * isUse: bool * bindings: SynBinding list * body: SynExpr * range: range * trivia: FSharp.Compiler.SyntaxTrivia.SynExprLetOrUseTrivia -> SynExpr
<summary> + F# syntax: let pat = expr in expr + F# syntax: let f pat1 .. patN = expr in expr + F# syntax: let rec f pat1 .. patN = expr in expr + F# syntax: use pat = expr in expr +</summary>
+
val bindings: SynBinding list
+
val body: SynExpr
+
val binding: SynBinding
+
Multiple items
union case SynBinding.SynBinding: accessibility: SynAccess option * kind: SynBindingKind * isInline: bool * isMutable: bool * attributes: SynAttributes * xmlDoc: FSharp.Compiler.Xml.PreXmlDoc * valData: SynValData * headPat: SynPat * returnInfo: SynBindingReturnInfo option * expr: SynExpr * range: range * debugPoint: DebugPointAtBinding * trivia: FSharp.Compiler.SyntaxTrivia.SynBindingTrivia -> SynBinding

--------------------
type SynBinding = + | SynBinding of accessibility: SynAccess option * kind: SynBindingKind * isInline: bool * isMutable: bool * attributes: SynAttributes * xmlDoc: PreXmlDoc * valData: SynValData * headPat: SynPat * returnInfo: SynBindingReturnInfo option * expr: SynExpr * range: range * debugPoint: DebugPointAtBinding * trivia: SynBindingTrivia + member RangeOfBindingWithRhs: range + member RangeOfBindingWithoutRhs: range + member RangeOfHeadPattern: range
<summary> + Represents a binding for a 'let' or 'member' declaration +</summary>
+
val headPat: SynPat
+
val init: SynExpr
+
val expr: SynExpr
+
val visitDeclarations: decls: SynModuleDecl seq -> unit
 Walk over a list of declarations in a module. This is anything
 that you can write as a top-level inside module (let bindings,
 nested modules, type declarations etc.)
+
val decls: SynModuleDecl seq
+
val declaration: SynModuleDecl
+
type SynModuleDecl = + | ModuleAbbrev of ident: Ident * longId: LongIdent * range: range + | NestedModule of moduleInfo: SynComponentInfo * isRecursive: bool * decls: SynModuleDecl list * isContinuing: bool * range: range * trivia: SynModuleDeclNestedModuleTrivia + | Let of isRecursive: bool * bindings: SynBinding list * range: range + | Expr of expr: SynExpr * range: range + | Types of typeDefns: SynTypeDefn list * range: range + | Exception of exnDefn: SynExceptionDefn * range: range + | Open of target: SynOpenDeclTarget * range: range + | Attributes of attributes: SynAttributes * range: range + | HashDirective of hashDirective: ParsedHashDirective * range: range + | NamespaceFragment of fragment: SynModuleOrNamespace + member Range: range
<summary> + Represents a definition within a module +</summary>
+
union case SynModuleDecl.Let: isRecursive: bool * bindings: SynBinding list * range: range -> SynModuleDecl
<summary> + A 'let' definition within a module +</summary>
+
val isRec: bool
+
Multiple items
val range: range

--------------------
type range = Range
<summary> + Represents a range within a file +</summary>
+
val visitModulesAndNamespaces: modulesOrNss: SynModuleOrNamespace seq -> unit
 Walk over all module or namespace declarations
 (basically 'module Foo =' or 'namespace Foo.Bar')
 Note that there is one implicitly, even if the file
 does not explicitly define it..
+
val modulesOrNss: SynModuleOrNamespace seq
+
val moduleOrNs: SynModuleOrNamespace
+
Multiple items
union case SynModuleOrNamespace.SynModuleOrNamespace: longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * decls: SynModuleDecl list * xmlDoc: FSharp.Compiler.Xml.PreXmlDoc * attribs: SynAttributes * accessibility: SynAccess option * range: range * trivia: FSharp.Compiler.SyntaxTrivia.SynModuleOrNamespaceTrivia -> SynModuleOrNamespace

--------------------
type SynModuleOrNamespace = + | SynModuleOrNamespace of longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * decls: SynModuleDecl list * xmlDoc: PreXmlDoc * attribs: SynAttributes * accessibility: SynAccess option * range: range * trivia: SynModuleOrNamespaceTrivia + member Range: range
<summary> + Represents the definition of a module or namespace +</summary>
+
val lid: LongIdent
+
val decls: SynModuleDecl list
+
val input: string
+
val tree: ParsedInput
+
val getUntypedTree: file: string * input: ISourceText -> ParsedInput
 Get untyped tree for a specified input
+
module SourceText + +from FSharp.Compiler.Text
<summary> + Functions related to ISourceText objects +</summary>
+
val ofString: string -> ISourceText
<summary> + Creates an ISourceText object from the given string +</summary>
+
type ParsedInput = + | ImplFile of ParsedImplFileInput + | SigFile of ParsedSigFileInput + member FileName: string + member Identifiers: Set<string> + member QualifiedName: QualifiedNameOfFile + member Range: range + member ScopedPragmas: ScopedPragma list
<summary> + Represents the syntax tree for a parsed implementation or signature file +</summary>
+
union case ParsedInput.ImplFile: ParsedImplFileInput -> ParsedInput
<summary> + A parsed implementation file +</summary>
+
val implFile: ParsedImplFileInput
+
Multiple items
union case ParsedImplFileInput.ParsedImplFileInput: fileName: string * isScript: bool * qualifiedNameOfFile: QualifiedNameOfFile * scopedPragmas: ScopedPragma list * hashDirectives: ParsedHashDirective list * contents: SynModuleOrNamespace list * flags: bool * bool * trivia: FSharp.Compiler.SyntaxTrivia.ParsedImplFileInputTrivia * identifiers: Set<string> -> ParsedImplFileInput

--------------------
type ParsedImplFileInput = + | ParsedImplFileInput of fileName: string * isScript: bool * qualifiedNameOfFile: QualifiedNameOfFile * scopedPragmas: ScopedPragma list * hashDirectives: ParsedHashDirective list * contents: SynModuleOrNamespace list * flags: bool * bool * trivia: ParsedImplFileInputTrivia * identifiers: Set<string> + member Contents: SynModuleOrNamespace list + member FileName: string + member HashDirectives: ParsedHashDirective list + member IsExe: bool + member IsLastCompiland: bool + member IsScript: bool + member QualifiedName: QualifiedNameOfFile + member ScopedPragmas: ScopedPragma list + member Trivia: ParsedImplFileInputTrivia
<summary> + Represents the full syntax tree, file name and other parsing information for an implementation file +</summary>
+
val modules: SynModuleOrNamespace list
+
val failwith: message: string -> 'T
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fsharp-core-notes.html b/fsharp-core-notes.html new file mode 100644 index 0000000000..ae4cbb994e --- /dev/null +++ b/fsharp-core-notes.html @@ -0,0 +1,682 @@ + + + + + + + + + + + + + + + + + + Guidance | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Notes and Guidance on FSharp.Core

+

This technical guide discusses the FSharp.Core library.

+

Reference documentation for FSharp.Core can be found here: https://fsharp.github.io/fsharp-core-docs/

+

Much of the guidance below applies to any .NET library respecting binary compatibility.

+

FSharp.Core is binary compatible

+

FSharp.Core is binary compatible across versions of the F# language. For example, this means you can create a newer project with a newer FSharp.Core in an older codebase and things should generally "just work".

+

Binary compatibility means that a component built for X can bind to Y at runtime. It doesn't mean that Y behaves 100% the same as X, though. For example, an older compiler that doesn't know how to understand inref<'T> referencing a newer FSharp.Core that has inref<'T> defined may not behave correctly if inref<'T> is used in source.

+

FSharp.Core and F# scripts

+

F# scripts, executed by F# interactive, execute against the FSharp.Core deployed with the .NET SDK you are using. If you're expecting to use a more modern library feature and find that it's missing, it's likely because you have an older .NET SDK and thus an older F# Interactive. Upgrade your .NET SDK.

+

Guidance for package authors

+

If you are authoring a NuGet package for consumption in the F# and .NET ecosystem, you already have to make a decision about functionality vs. reach by deciding what target framework(s) you support.

+

As an F# package author, you also need to make this decision with respect to FSharp.Core:

+ +

This decision is critical, because it can have a network effect. If you choose a higher FSharp.Core version, then that also becomes a dependency for any other package that may depend on your package.

+

Package authors should pin their FSharp.Core reference

+

The default templates for F# projects carry an implicit reference to FSharp.Core. This is ideal for application developers, since applications almost always want to be referencing the highest FSharp.Core available to them. As you upgrade your .NET SDK, the FSharp.Core package referenced implicitly will also be upgraded over time, since FSharp.Core is also distributed with the .NET SDK.

+

However, as a package author this means that unless you reference FSharp.Core explicitly, you will default to the latest possible version and thus eliminate any hope of reaching older projects in older environments.

+

How to explicitly reference FSharp.Core

+

It's a simple gesture in your project file that pins to FSharp.Core 4.7.2:

+
<ItemGroup>
+  <PackageReference Update="FSharp.Core" Version="4.7.2" />
+</ItemGroup>
+
+

Or if you're using Paket:

+
nuget FSharp.Core >= 4.7.2
+
+

And that's it!

+

Compatibility table

+

The following table can help you decide the minimum language/package version you want to support:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Minimum F# language version

Minimum FSharp.Core package version

F# 4.1

4.3.4

F# 4.5

4.5.2

F# 4.6

4.6.2

F# 4.7

4.7.2

F# 5.0

5.0.0

F# 6.0

6.0.0

+ +

If you want to be compatible with much older projects using an F# 4.0 compiler or earlier, you can still do that but it's not recommended. People using those codebases should upgrade instead.

+

Do not bundle FSharp.Core directly with a library

+

Do not include a copy of FSharp.Core with your library or package, such in the lib folder of a package. If you do this, you will create havoc for users of your library.

+

The decision about which FSharp.Core a library binds to is up to the application hosting of the library.

+

Guidance for everyone else

+

If you're not authoring packages for distribution, you have a lot less to worry about.

+

If you are distributing library code across a private organization as if it were a NuGet package, please see the above guidance, as it likely still applies. Otherwise, the below guidance applies.

+

Application authors don't have to explicitly reference FSharp.Core

+

In general, applications can always just use the latest FSharp.Core bundled in the SDK they are built with.

+

C# projects referencing F# projects may need to pin FSharp.Core

+

You can reference an F# project just fine without needing to be explicit about an FSharp.Core reference when using C# projects based on the .NET SDK. References flow transitively for SDK-style projects, so even if you need to use types directly from FSharp.Core (which you probably shouldn't do anyways) it will pick up the right types from the right assembly.

+

If you do have an explicit FSharp.Core reference in your C# project that you need, you should pin your FSharp.Core reference across your entire codebase. Being in a mixed pinned/non-pinned world is difficult to keep straight over a long period of time.

+

Guidance for older projects, compilers, and tools

+

Modern .NET development, including F#, uses SDK-style projects. You can read about that here: https://learn.microsoft.com/dotnet/core/project-sdk/overview

+

If you are not using SDK-style projects F# projects and/or have an older toolset, the following guidance applies.

+

Consider upgrading

+

Yes, really. The old project system that manages legacy projects is not that good, the compiler is older and unoptimized for supporting larger codebases, tooling is not as responsive, etc. You will really have a much better life if you upgrade. Try out the try-convert tool to do that: https://github.com/dotnet/try-convert

+

If you cannot upgrade for some reason, the rest of the guidance applies.

+

Always deploy FSharp.Core as part of a compiled application

+

For applications, FSharp.Core is normally part of the application itself (so-called "xcopy deploy" of FSharp.Core).

+

For older project files, you may need to use <Private>true</Private> in your project file. In Visual Studio this is equivalent to setting the CopyLocal property to true properties for the FSharp.Core reference.

+

FSharp.Core.dll will normally appear in the bin output folder for your application. For example:

+
    Directory of ...
+    
+    18/04/2020  13:20             5,632 ConsoleApplication3.exe
+    14/10/2020  12:12         1,400,472 FSharp.Core.dll
+
+

FSharp.Core and static linking

+

The ILMerge tool and the F# compiler both allow static linking of assemblies including static linking of FSharp.Core. +This can be useful to build a single standalone file for a tool.

+

However, these options must be used with caution.

+ +

Searching on stackoverflow reveals further guidance on this topic.

+

Reference: FSharp.Core version and NuGet package numbers

+

See the F# version information RFC.

+ +
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
+
namespace Microsoft.FSharp.Core
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/fsi-emit.html b/fsi-emit.html new file mode 100644 index 0000000000..33db6e70cd --- /dev/null +++ b/fsi-emit.html @@ -0,0 +1,583 @@ + + + + + + + + + + + + + + + + + + F# Interactive Emit | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

F# Interactive Code Generation

+

F# Interactive (dotnet fsi) accepts incremental code fragments. This capability is also used by hosted execution capability of the FSharp.Compiler.Service API which is used to build the F# kernel for .NET Interactive notebooks.

+

Historically F# Interactive code was emitted into a single dynamic assembly using Reflection.Emit and ilreflect.fs (meaning one assembly that is continually growing). However, .NET Core Reflection.Emit does not support the emit of debug symbols for dynamic assemblies, so in Feb 2022 we switched to emitting multiple non-dynamic assemblies (meaning assemblies dynamically created in-memory using ilwrite.fs, and loaded, but not growing).

+

The assemblies are named:

+

FSI-ASSEMBLY1 +FSI-ASSEMBLY2

+

etc.

+

Compat switch

+

There is a switch fsi --multiemit that turns on the use of multi-assembly generation (when it is off, we use Reflection Emit for single-dynamic-assembly generation). This is on by default for .NET Core, and off by default for .NET Framework for compat reasons.

+

Are multiple assemblies too costly?

+

There is general assumption in this that on modern dev machines (where users execute multiple interactions) then generating 50, 100 or 1,000 or 10,000 dynamic assemblies by repeated manual execution of code is not a problem: the extra overheads of multiple assemblies compared to one dynamic assembly is of no real significance in developer REPL scenarios given the vast amount of memory available on modern 64-bit machines.

+

Quick check: adding 10,000 let x = 1;; interactions to .NET Core dotnet fsi adds about 300MB to the FSI.EXE process, meaning 30K/interaction. A budget of 1GB for interactive fragments (reasonable on a 64-bit machine), and an expected maximum of 10000 fragments before restart (that's a lot!), then each fragment can take up to 100K. This is well below the cost of a new assembly.

+

Additionally, these costs are not substantially reduced if --multiemit is disabled, so they've always been the approximate costs of F# Interactive fragment generation.

+

Internals and accessibility across fragments

+

Generating into multiple assemblies raises issues for some things that are assembly bound such as "internals" accessibility. In a first iteration of this we had a failing case here:

+
> artifacts
+...
+// Fragment 1
+> let internal f() = 1;;
+val internal f: unit -> int
+
+// Fragment 2 - according to existing rules it is allowed to access internal things of the first
+f();; 
+System.MethodAccessException: Attempt by method '<StartupCode$FSI_0003>FSI_0003.main@()' to access method 'FSI_0002.f()' failed.
+   at <StartupCode$FSI_0003>FSI_0003.main@()
+
+

This is because we are now generating into multiple assemblies. Another bug was this:

+
> artifacts
+...
+// Fragment 1 - not `x` becomes an internal field of the class
+> type C() =
+>    let mutable x = 1
+>    member _.M() = x
+> ;;
+...
+// Fragment 2 - inlining 'M()' gave an access to the internal field `x`
+> C().M();;
+...<bang>
+
+

According to the current F# scripting programming model (the one checked in the editor), the "internal" thing should be accessible in subsequent fragments. Should this be changed? No:

+ +

Because of this we emit IVTs for the next 30 FSI-ASSEMBLYnnn assemblies on each assembly fragment, giving a warning when an internal thing is accessed across assembly boundaries within that 30 (reporting it as a deprecated feature), and give an error if internal access happens after that.

+

From a compat perspective this seems reasonable, and the compat flag is available to return the whole system to generate-one-assembly behavior.

+ +
type unit = Unit
+
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+
namespace System
+
Multiple items
type MethodAccessException = + inherit MemberAccessException + new: unit -> unit + 2 overloads
<summary>The exception that is thrown when there is an invalid attempt to access a method, such as accessing a private method from partially trusted code.</summary>

--------------------
System.MethodAccessException() : System.MethodAccessException
System.MethodAccessException(message: string) : System.MethodAccessException
System.MethodAccessException(message: string, inner: exn) : System.MethodAccessException
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/img/favicon.ico b/img/favicon.ico new file mode 100644 index 0000000000..ad06a8a280 Binary files /dev/null and b/img/favicon.ico differ diff --git a/img/logo.png b/img/logo.png new file mode 100644 index 0000000000..9d7b823ec9 Binary files /dev/null and b/img/logo.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000000..1a4616ada0 --- /dev/null +++ b/index.html @@ -0,0 +1,586 @@ + + + + + + + + + + + + + + + + + + F# compiler guide + | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+

F# compiler guide

+

Welcome to the F# compiler and tools repository! This guide discusses the F# compiler source code and implementation from a technical point of view.

+

Documentation Topics

+ +

Edit the source for these docs. The docs are published automatically daily fsharp.github.io/fsharp-compiler-docs/ by this repo.

+

Key Folders

+ +

Resources for learning

+ +

Tools to help work with the compiler

+ +

Attribution

+

This document is based on an original document published in 2015 by the F# Software Foundation. It has since been updated substantially.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/index.json b/index.json new file mode 100644 index 0000000000..c9ce312b6a --- /dev/null +++ b/index.json @@ -0,0 +1 @@ +[{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler.html","title":"FSharp.Compiler","content":"Cancellable \nCompilerEnvironment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil.html","title":"FSharp.Compiler.AbstractIL","content":"IL \nILBinaryReader","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis.html","title":"FSharp.Compiler.CodeAnalysis","content":"DelayedILModuleReader \nDocumentSource \nFSharpCheckFileAnswer \nFSharpCheckFileResults \nFSharpCheckProjectResults \nFSharpChecker \nFSharpParseFileResults \nFSharpParsingOptions \nFSharpProjectContext \nFSharpProjectOptions \nFSharpReferencedProject \nFSharpSymbolUse \nFSharpUnresolvedReferencesSet \nILegacyReferenceResolver \nLegacyReferenceResolver \nLegacyResolutionEnvironment \nLegacyResolutionFailure \nLegacyResolvedFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager.html","title":"FSharp.Compiler.DependencyManager","content":"AssemblyResolutionProbe \nAssemblyResolveHandler \nDependencyProvider \nErrorReportType \nIDependencyManagerProvider \nIResolveDependenciesResult \nNativeDllResolveHandler \nNativeResolutionProbe \nResolvingErrorReport","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics.html","title":"FSharp.Compiler.Diagnostics","content":"ActivityNames \nCompilerDiagnostics \nExtendedData \nFSharpDiagnostic \nFSharpDiagnosticKind \nFSharpDiagnosticOptions \nFSharpDiagnosticSeverity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices.html","title":"FSharp.Compiler.EditorServices","content":"AssemblyContent \nInterfaceStubGenerator \nNavigateTo \nNavigation \nParsedInput \nQuickParse \nSimplifyNames \nStructure \nUnnecessaryParentheses \nUnusedDeclarations \nUnusedOpens \nXmlDocComment \nXmlDocParser \nAssemblyContentType \nAssemblySymbol \nCompletionContext \nCompletionItemKind \nDeclarationListInfo \nDeclarationListItem \nEntityCache \nEntityKind \nFSharpGlyph \nFindDeclExternalParam \nFindDeclExternalSymbol \nFindDeclExternalType \nFindDeclFailureReason \nFindDeclResult \nIAssemblyContentCache \nInheritanceContext \nInsertionContext \nInsertionContextEntity \nInterfaceData \nLookupType \nMaybeUnresolvedIdent \nMethodGroup \nMethodGroupItem \nMethodGroupItemParameter \nModuleKind \nNavigableContainer \nNavigableContainerType \nNavigableItem \nNavigableItemKind \nNavigationEntityKind \nNavigationItem \nNavigationItemKind \nNavigationItems \nNavigationTopLevelDeclaration \nOpenStatementInsertionPoint \nParameterLocations \nPartialLongName \nPatternContext \nRecordContext \nScopeKind \nSemanticClassificationItem \nSemanticClassificationType \nSemanticClassificationView \nShortIdents \nToolTipElement \nToolTipElementData \nToolTipText \nTupledArgumentLocation \nUnresolvedSymbol \nXmlDocable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io.html","title":"FSharp.Compiler.IO","content":"FileSystemAutoOpens \nStreamExtensions \nByteMemory \nDefaultAssemblyLoader \nDefaultFileSystem \nIAssemblyLoader \nIFileSystem","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive.html","title":"FSharp.Compiler.Interactive","content":"CtrlBreakHandlers \nShell","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols.html","title":"FSharp.Compiler.Symbols","content":"FSharpExprPatterns \nFSharpSymbolPatterns \nFSharpAbstractParameter \nFSharpAbstractSignature \nFSharpAccessibility \nFSharpAccessibilityRights \nFSharpActivePatternCase \nFSharpActivePatternGroup \nFSharpAnonRecordTypeDetails \nFSharpAssembly \nFSharpAssemblyContents \nFSharpAssemblySignature \nFSharpAttribute \nFSharpDelegateSignature \nFSharpDisplayContext \nFSharpEntity \nFSharpExpr \nFSharpField \nFSharpGenericParameter \nFSharpGenericParameterConstraint \nFSharpGenericParameterDefaultsToConstraint \nFSharpGenericParameterDelegateConstraint \nFSharpGenericParameterMemberConstraint \nFSharpImplementationFileContents \nFSharpImplementationFileDeclaration \nFSharpInlineAnnotation \nFSharpMemberOrFunctionOrValue \nFSharpObjectExprOverride \nFSharpOpenDeclaration \nFSharpParameter \nFSharpStaticParameter \nFSharpSymbol \nFSharpType \nFSharpUnionCase \nFSharpXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax.html","title":"FSharp.Compiler.Syntax","content":"PrettyNaming \nSynLongIdentHelpers \nSyntaxTraversal \nDebugPointAtBinding \nDebugPointAtFinally \nDebugPointAtFor \nDebugPointAtInOrTo \nDebugPointAtLeafExpr \nDebugPointAtSequential \nDebugPointAtTarget \nDebugPointAtTry \nDebugPointAtWhile \nDebugPointAtWith \nExprAtomicFlag \nIdent \nParsedHashDirective \nParsedHashDirectiveArgument \nParsedImplFile \nParsedImplFileFragment \nParsedImplFileInput \nParsedInput \nParsedScriptInteraction \nParsedSigFile \nParsedSigFileFragment \nParsedSigFileInput \nParserDetail \nQualifiedNameOfFile \nScopedPragma \nSeqExprOnly \nSynAccess \nSynArgInfo \nSynArgPats \nSynAttribute \nSynAttributeList \nSynBinding \nSynBindingKind \nSynBindingReturnInfo \nSynByteStringKind \nSynComponentInfo \nSynConst \nSynEnumCase \nSynExceptionDefn \nSynExceptionDefnRepr \nSynExceptionSig \nSynExpr \nSynExprAndBang \nSynExprRecordField \nSynField \nSynIdent \nSynInterfaceImpl \nSynInterpolatedStringPart \nSynLongIdent \nSynMatchClause \nSynMeasure \nSynMemberDefn \nSynMemberFlags \nSynMemberKind \nSynMemberSig \nSynModuleDecl \nSynModuleOrNamespace \nSynModuleOrNamespaceKind \nSynModuleOrNamespaceSig \nSynModuleSigDecl \nSynOpenDeclTarget \nSynPat \nSynRationalConst \nSynReturnInfo \nSynSimplePat \nSynSimplePatAlternativeIdInfo \nSynSimplePats \nSynStaticOptimizationConstraint \nSynStringKind \nSynTupleTypeSegment \nSynTypar \nSynTyparDecl \nSynTyparDecls \nSynType \nSynTypeConstraint \nSynTypeDefn \nSynTypeDefnKind \nSynTypeDefnRepr \nSynTypeDefnSig \nSynTypeDefnSigRepr \nSynTypeDefnSimpleRepr \nSynUnionCase \nSynUnionCaseKind \nSynValData \nSynValInfo \nSynValSig \nSynValTyparDecls \nSyntaxNode \nSyntaxVisitorBase\u003C\u0027T\u003E \nTyparStaticReq","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia.html","title":"FSharp.Compiler.SyntaxTrivia","content":"CommentTrivia \nConditionalDirectiveTrivia \nGetSetKeywords \nIdentTrivia \nIfDirectiveExpression \nParsedImplFileInputTrivia \nParsedSigFileInputTrivia \nSynArgPatsNamePatPairsTrivia \nSynBindingReturnInfoTrivia \nSynBindingTrivia \nSynEnumCaseTrivia \nSynExprAndBangTrivia \nSynExprAnonRecdTrivia \nSynExprDotLambdaTrivia \nSynExprIfThenElseTrivia \nSynExprLambdaTrivia \nSynExprLetOrUseBangTrivia \nSynExprLetOrUseTrivia \nSynExprMatchBangTrivia \nSynExprMatchTrivia \nSynExprTryFinallyTrivia \nSynExprTryWithTrivia \nSynFieldTrivia \nSynLeadingKeyword \nSynMatchClauseTrivia \nSynMeasureConstantTrivia \nSynMemberDefnAbstractSlotTrivia \nSynMemberDefnAutoPropertyTrivia \nSynMemberDefnImplicitCtorTrivia \nSynMemberGetSetTrivia \nSynMemberSigMemberTrivia \nSynModuleDeclNestedModuleTrivia \nSynModuleOrNamespaceLeadingKeyword \nSynModuleOrNamespaceSigTrivia \nSynModuleOrNamespaceTrivia \nSynModuleSigDeclNestedModuleTrivia \nSynPatListConsTrivia \nSynPatOrTrivia \nSynTyparDeclTrivia \nSynTypeDefnLeadingKeyword \nSynTypeDefnSigTrivia \nSynTypeDefnTrivia \nSynTypeFunTrivia \nSynTypeOrTrivia \nSynUnionCaseTrivia \nSynValSigTrivia","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text.html","title":"FSharp.Compiler.Text","content":"Line \nPosition \nRange \nSourceText \nTaggedText \nISourceText \nLine0 \nNavigableTaggedText \nPosition \nRange \nTaggedText \nTextTag \npos \nrange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization.html","title":"FSharp.Compiler.Tokenization","content":"FSharpKeywords \nFSharpTokenTag \nFSharpLexer \nFSharpLexerFlags \nFSharpLineTokenizer \nFSharpSourceTokenizer \nFSharpToken \nFSharpTokenCharKind \nFSharpTokenColorKind \nFSharpTokenInfo \nFSharpTokenKind \nFSharpTokenTriggerClass \nFSharpTokenizerColorState \nFSharpTokenizerLexState","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml.html","title":"FSharp.Compiler.Xml","content":"PreXmlDoc \nXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library.html","title":"Internal.Utilities.Library","content":"InterruptibleLazy \nDelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E \nInterruptibleLazy\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-cancellable.html","title":"Cancellable","content":"Cancellable \n \nCancellable.CheckAndThrow \nCheckAndThrow \nCancellable.Token \nToken","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-cancellable.html#CheckAndThrow","title":"Cancellable.CheckAndThrow","content":"Cancellable.CheckAndThrow \nCheckAndThrow \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-cancellable.html#Token","title":"Cancellable.Token","content":"Cancellable.Token \nToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html","title":"CompilerEnvironment","content":"CompilerEnvironment \n Information about the compilation environment \nCompilerEnvironment.BinFolderOfDefaultFSharpCompiler \nBinFolderOfDefaultFSharpCompiler \nCompilerEnvironment.DefaultReferencesForOrphanSources \nDefaultReferencesForOrphanSources \nCompilerEnvironment.GetConditionalDefinesForEditing \nGetConditionalDefinesForEditing \nCompilerEnvironment.GetDebuggerLanguageID \nGetDebuggerLanguageID \nCompilerEnvironment.IsCheckerSupportedSubcategory \nIsCheckerSupportedSubcategory \nCompilerEnvironment.IsCompilable \nIsCompilable \nCompilerEnvironment.IsScriptFile \nIsScriptFile \nCompilerEnvironment.MustBeSingleFileProject \nMustBeSingleFileProject","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#BinFolderOfDefaultFSharpCompiler","title":"CompilerEnvironment.BinFolderOfDefaultFSharpCompiler","content":"CompilerEnvironment.BinFolderOfDefaultFSharpCompiler \nBinFolderOfDefaultFSharpCompiler \n The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#DefaultReferencesForOrphanSources","title":"CompilerEnvironment.DefaultReferencesForOrphanSources","content":"CompilerEnvironment.DefaultReferencesForOrphanSources \nDefaultReferencesForOrphanSources \n These are the names of assemblies that should be referenced for .fs or .fsi files that\n are not associated with a project.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#GetConditionalDefinesForEditing","title":"CompilerEnvironment.GetConditionalDefinesForEditing","content":"CompilerEnvironment.GetConditionalDefinesForEditing \nGetConditionalDefinesForEditing \n Return the compilation defines that should be used when editing the given file.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#GetDebuggerLanguageID","title":"CompilerEnvironment.GetDebuggerLanguageID","content":"CompilerEnvironment.GetDebuggerLanguageID \nGetDebuggerLanguageID \n Return the language ID, which is the expression evaluator id that the debugger will use.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#IsCheckerSupportedSubcategory","title":"CompilerEnvironment.IsCheckerSupportedSubcategory","content":"CompilerEnvironment.IsCheckerSupportedSubcategory \nIsCheckerSupportedSubcategory \n Return true if this is a subcategory of error or warning message that the language service can emit","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#IsCompilable","title":"CompilerEnvironment.IsCompilable","content":"CompilerEnvironment.IsCompilable \nIsCompilable \n Whether or not this file is compilable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#IsScriptFile","title":"CompilerEnvironment.IsScriptFile","content":"CompilerEnvironment.IsScriptFile \nIsScriptFile \n A helpers for dealing with F# files.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-compilerenvironment.html#MustBeSingleFileProject","title":"CompilerEnvironment.MustBeSingleFileProject","content":"CompilerEnvironment.MustBeSingleFileProject \nMustBeSingleFileProject \n Whether or not this file should be a single-file project","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html","title":"IL","content":"IL \n The \u0022unlinked\u0022 view of .NET metadata and code. Central to the Abstract IL library \nIL.ILArgConvention \nILArgConvention \nIL.ILArrayShape \nILArrayShape \nIL.ILAssemblyLongevity \nILAssemblyLongevity \nIL.ILAssemblyManifest \nILAssemblyManifest \nIL.ILAssemblyRef \nILAssemblyRef \nIL.ILAttribElem \nILAttribElem \nIL.ILAttribute \nILAttribute \nIL.ILAttributes \nILAttributes \nIL.ILAttributesStored \nILAttributesStored \nIL.ILCallingConv \nILCallingConv \nIL.ILCallingSignature \nILCallingSignature \nIL.ILDebugImport \nILDebugImport \nIL.ILDebugImports \nILDebugImports \nIL.ILDefaultPInvokeEncoding \nILDefaultPInvokeEncoding \nIL.ILEventDef \nILEventDef \nIL.ILEventDefs \nILEventDefs \nIL.ILExportedTypeOrForwarder \nILExportedTypeOrForwarder \nIL.ILExportedTypesAndForwarders \nILExportedTypesAndForwarders \nIL.ILFieldDef \nILFieldDef \nIL.ILFieldDefs \nILFieldDefs \nIL.ILFieldInit \nILFieldInit \nIL.ILFieldRef \nILFieldRef \nIL.ILFieldSpec \nILFieldSpec \nIL.ILGenericParameterDef \nILGenericParameterDef \nIL.ILGenericVariance \nILGenericVariance \nIL.ILGuid \nILGuid \nIL.ILMemberAccess \nILMemberAccess \nIL.ILMethodDef \nILMethodDef \nIL.ILMethodDefs \nILMethodDefs \nIL.ILMethodImplDef \nILMethodImplDef \nIL.ILMethodImplDefs \nILMethodImplDefs \nIL.ILMethodRef \nILMethodRef \nIL.ILMethodSpec \nILMethodSpec \nIL.ILModuleDef \nILModuleDef \nIL.ILModuleRef \nILModuleRef \nIL.ILNativeResource \nILNativeResource \nIL.ILNativeType \nILNativeType \nIL.ILNestedExportedType \nILNestedExportedType \nIL.ILNestedExportedTypes \nILNestedExportedTypes \nIL.ILParameter \nILParameter \nIL.ILPlatform \nILPlatform \nIL.ILPreTypeDef \nILPreTypeDef \nIL.ILPropertyDef \nILPropertyDef \nIL.ILPropertyDefs \nILPropertyDefs \nIL.ILReferences \nILReferences \nIL.ILResources \nILResources \nIL.ILReturn \nILReturn \nIL.ILScopeRef \nILScopeRef \nIL.ILSecurityDeclsStored \nILSecurityDeclsStored \nIL.ILSourceDocument \nILSourceDocument \nIL.ILThisConvention \nILThisConvention \nIL.ILType \nILType \nIL.ILTypeDef \nILTypeDef \nIL.ILTypeDefAccess \nILTypeDefAccess \nIL.ILTypeDefKind \nILTypeDefKind \nIL.ILTypeDefLayout \nILTypeDefLayout \nIL.ILTypeDefs \nILTypeDefs \nIL.ILTypeInit \nILTypeInit \nIL.ILTypeRef \nILTypeRef \nIL.ILTypeSpec \nILTypeSpec \nIL.ILVersionInfo \nILVersionInfo \nIL.MethodBody \nMethodBody \nIL.PublicKey \nPublicKey \nIL.mkILReturn \nmkILReturn \nIL.mkILCustomAttrs \nmkILCustomAttrs \nIL.mkILCustomAttrsFromArray \nmkILCustomAttrsFromArray \nIL.storeILCustomAttrs \nstoreILCustomAttrs \nIL.emptyILCustomAttrs \nemptyILCustomAttrs \nIL.mkILSecurityDecls \nmkILSecurityDecls \nIL.emptyILSecurityDecls \nemptyILSecurityDecls \nIL.storeILSecurityDecls \nstoreILSecurityDecls \nIL.mkILEvents \nmkILEvents \nIL.mkILEventsLazy \nmkILEventsLazy \nIL.emptyILEvents \nemptyILEvents \nIL.mkILProperties \nmkILProperties \nIL.mkILPropertiesLazy \nmkILPropertiesLazy \nIL.emptyILProperties \nemptyILProperties \nIL.mkILMethods \nmkILMethods \nIL.mkILMethodsFromArray \nmkILMethodsFromArray \nIL.mkILMethodsComputed \nmkILMethodsComputed \nIL.emptyILMethods \nemptyILMethods \nIL.mkILFields \nmkILFields \nIL.mkILFieldsLazy \nmkILFieldsLazy \nIL.emptyILFields \nemptyILFields \nIL.mkILMethodImpls \nmkILMethodImpls \nIL.mkILMethodImplsLazy \nmkILMethodImplsLazy \nIL.emptyILMethodImpls \nemptyILMethodImpls \nIL.mkILTypeDefs \nmkILTypeDefs \nIL.mkILTypeDefsFromArray \nmkILTypeDefsFromArray \nIL.emptyILTypeDefs \nemptyILTypeDefs \nIL.mkILTypeDefsComputed \nmkILTypeDefsComputed \nIL.mkILNestedExportedTypes \nmkILNestedExportedTypes \nIL.mkILExportedTypes \nmkILExportedTypes \nIL.emptyILResources \nemptyILResources \nIL.mkILSimpleModule \nmkILSimpleModule \nIL.NoMetadataIdx \nNoMetadataIdx","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILReturn","title":"IL.mkILReturn","content":"IL.mkILReturn \nmkILReturn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILCustomAttrs","title":"IL.mkILCustomAttrs","content":"IL.mkILCustomAttrs \nmkILCustomAttrs \n Making tables of custom attributes, etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILCustomAttrsFromArray","title":"IL.mkILCustomAttrsFromArray","content":"IL.mkILCustomAttrsFromArray \nmkILCustomAttrsFromArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#storeILCustomAttrs","title":"IL.storeILCustomAttrs","content":"IL.storeILCustomAttrs \nstoreILCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILCustomAttrs","title":"IL.emptyILCustomAttrs","content":"IL.emptyILCustomAttrs \nemptyILCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILSecurityDecls","title":"IL.mkILSecurityDecls","content":"IL.mkILSecurityDecls \nmkILSecurityDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILSecurityDecls","title":"IL.emptyILSecurityDecls","content":"IL.emptyILSecurityDecls \nemptyILSecurityDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#storeILSecurityDecls","title":"IL.storeILSecurityDecls","content":"IL.storeILSecurityDecls \nstoreILSecurityDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILEvents","title":"IL.mkILEvents","content":"IL.mkILEvents \nmkILEvents \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILEventsLazy","title":"IL.mkILEventsLazy","content":"IL.mkILEventsLazy \nmkILEventsLazy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILEvents","title":"IL.emptyILEvents","content":"IL.emptyILEvents \nemptyILEvents \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILProperties","title":"IL.mkILProperties","content":"IL.mkILProperties \nmkILProperties \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILPropertiesLazy","title":"IL.mkILPropertiesLazy","content":"IL.mkILPropertiesLazy \nmkILPropertiesLazy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILProperties","title":"IL.emptyILProperties","content":"IL.emptyILProperties \nemptyILProperties \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILMethods","title":"IL.mkILMethods","content":"IL.mkILMethods \nmkILMethods \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILMethodsFromArray","title":"IL.mkILMethodsFromArray","content":"IL.mkILMethodsFromArray \nmkILMethodsFromArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILMethodsComputed","title":"IL.mkILMethodsComputed","content":"IL.mkILMethodsComputed \nmkILMethodsComputed \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILMethods","title":"IL.emptyILMethods","content":"IL.emptyILMethods \nemptyILMethods \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILFields","title":"IL.mkILFields","content":"IL.mkILFields \nmkILFields \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILFieldsLazy","title":"IL.mkILFieldsLazy","content":"IL.mkILFieldsLazy \nmkILFieldsLazy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILFields","title":"IL.emptyILFields","content":"IL.emptyILFields \nemptyILFields \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILMethodImpls","title":"IL.mkILMethodImpls","content":"IL.mkILMethodImpls \nmkILMethodImpls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILMethodImplsLazy","title":"IL.mkILMethodImplsLazy","content":"IL.mkILMethodImplsLazy \nmkILMethodImplsLazy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILMethodImpls","title":"IL.emptyILMethodImpls","content":"IL.emptyILMethodImpls \nemptyILMethodImpls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILTypeDefs","title":"IL.mkILTypeDefs","content":"IL.mkILTypeDefs \nmkILTypeDefs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILTypeDefsFromArray","title":"IL.mkILTypeDefsFromArray","content":"IL.mkILTypeDefsFromArray \nmkILTypeDefsFromArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILTypeDefs","title":"IL.emptyILTypeDefs","content":"IL.emptyILTypeDefs \nemptyILTypeDefs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILTypeDefsComputed","title":"IL.mkILTypeDefsComputed","content":"IL.mkILTypeDefsComputed \nmkILTypeDefsComputed \n Create table of types which is loaded/computed on-demand, and whose individual\n elements are also loaded/computed on-demand. Any call to tdefs.AsList will\n result in the laziness being forced. Operations can examine the\n custom attributes and name of each type in order to decide whether\n to proceed with examining the other details of the type.\n\n Note that individual type definitions may contain further delays\n in their method, field and other tables.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILNestedExportedTypes","title":"IL.mkILNestedExportedTypes","content":"IL.mkILNestedExportedTypes \nmkILNestedExportedTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILExportedTypes","title":"IL.mkILExportedTypes","content":"IL.mkILExportedTypes \nmkILExportedTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#emptyILResources","title":"IL.emptyILResources","content":"IL.emptyILResources \nemptyILResources \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#mkILSimpleModule","title":"IL.mkILSimpleModule","content":"IL.mkILSimpleModule \nmkILSimpleModule \n Making modules.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il.html#NoMetadataIdx","title":"IL.NoMetadataIdx","content":"IL.NoMetadataIdx \nNoMetadataIdx \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html","title":"ILArgConvention","content":"ILArgConvention \n \nILArgConvention.Default \nDefault \nILArgConvention.CDecl \nCDecl \nILArgConvention.StdCall \nStdCall \nILArgConvention.ThisCall \nThisCall \nILArgConvention.FastCall \nFastCall \nILArgConvention.VarArg \nVarArg","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html#Default","title":"ILArgConvention.Default","content":"ILArgConvention.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html#CDecl","title":"ILArgConvention.CDecl","content":"ILArgConvention.CDecl \nCDecl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html#StdCall","title":"ILArgConvention.StdCall","content":"ILArgConvention.StdCall \nStdCall \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html#ThisCall","title":"ILArgConvention.ThisCall","content":"ILArgConvention.ThisCall \nThisCall \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html#FastCall","title":"ILArgConvention.FastCall","content":"ILArgConvention.FastCall \nFastCall \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilargconvention.html#VarArg","title":"ILArgConvention.VarArg","content":"ILArgConvention.VarArg \nVarArg \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilarrayshape.html","title":"ILArrayShape","content":"ILArrayShape \n \nILArrayShape.Rank \nRank \nILArrayShape.FromRank \nFromRank \nILArrayShape.SingleDimensional \nSingleDimensional","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilarrayshape.html#Rank","title":"ILArrayShape.Rank","content":"ILArrayShape.Rank \nRank \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilarrayshape.html#FromRank","title":"ILArrayShape.FromRank","content":"ILArrayShape.FromRank \nFromRank \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilarrayshape.html#SingleDimensional","title":"ILArrayShape.SingleDimensional","content":"ILArrayShape.SingleDimensional \nSingleDimensional \n Bounds for a single dimensional, zero based array","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblylongevity.html","title":"ILAssemblyLongevity","content":"ILAssemblyLongevity \n \nILAssemblyLongevity.Default \nDefault","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblylongevity.html#Default","title":"ILAssemblyLongevity.Default","content":"ILAssemblyLongevity.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html","title":"ILAssemblyManifest","content":"ILAssemblyManifest \n The main module of an assembly is a module plus some manifest information. \nILAssemblyManifest.CustomAttrs \nCustomAttrs \nILAssemblyManifest.SecurityDecls \nSecurityDecls \nILAssemblyManifest.Name \nName \nILAssemblyManifest.AuxModuleHashAlgorithm \nAuxModuleHashAlgorithm \nILAssemblyManifest.SecurityDeclsStored \nSecurityDeclsStored \nILAssemblyManifest.PublicKey \nPublicKey \nILAssemblyManifest.Version \nVersion \nILAssemblyManifest.Locale \nLocale \nILAssemblyManifest.CustomAttrsStored \nCustomAttrsStored \nILAssemblyManifest.AssemblyLongevity \nAssemblyLongevity \nILAssemblyManifest.DisableJitOptimizations \nDisableJitOptimizations \nILAssemblyManifest.JitTracking \nJitTracking \nILAssemblyManifest.IgnoreSymbolStoreSequencePoints \nIgnoreSymbolStoreSequencePoints \nILAssemblyManifest.Retargetable \nRetargetable \nILAssemblyManifest.ExportedTypes \nExportedTypes \nILAssemblyManifest.EntrypointElsewhere \nEntrypointElsewhere \nILAssemblyManifest.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#CustomAttrs","title":"ILAssemblyManifest.CustomAttrs","content":"ILAssemblyManifest.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#SecurityDecls","title":"ILAssemblyManifest.SecurityDecls","content":"ILAssemblyManifest.SecurityDecls \nSecurityDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#Name","title":"ILAssemblyManifest.Name","content":"ILAssemblyManifest.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#AuxModuleHashAlgorithm","title":"ILAssemblyManifest.AuxModuleHashAlgorithm","content":"ILAssemblyManifest.AuxModuleHashAlgorithm \nAuxModuleHashAlgorithm \n This is the ID of the algorithm used for the hashes of auxiliary\n files in the assembly. These hashes are stored in the\n \u003Cc\u003EILModuleRef.Hash\u003C/c\u003E fields of this assembly. These are not\n cryptographic hashes: they are simple file hashes. The algorithm\n is normally \u003Cc\u003E0x00008004\u003C/c\u003E indicating the SHA1 hash algorithm.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#SecurityDeclsStored","title":"ILAssemblyManifest.SecurityDeclsStored","content":"ILAssemblyManifest.SecurityDeclsStored \nSecurityDeclsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#PublicKey","title":"ILAssemblyManifest.PublicKey","content":"ILAssemblyManifest.PublicKey \nPublicKey \n This is the public key used to sign this\n assembly (the signature itself is stored elsewhere: see the\n binary format, and may not have been written if delay signing\n is used). (member Name, member PublicKey) forms the full\n public name of the assembly.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#Version","title":"ILAssemblyManifest.Version","content":"ILAssemblyManifest.Version \nVersion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#Locale","title":"ILAssemblyManifest.Locale","content":"ILAssemblyManifest.Locale \nLocale \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#CustomAttrsStored","title":"ILAssemblyManifest.CustomAttrsStored","content":"ILAssemblyManifest.CustomAttrsStored \nCustomAttrsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#AssemblyLongevity","title":"ILAssemblyManifest.AssemblyLongevity","content":"ILAssemblyManifest.AssemblyLongevity \nAssemblyLongevity \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#DisableJitOptimizations","title":"ILAssemblyManifest.DisableJitOptimizations","content":"ILAssemblyManifest.DisableJitOptimizations \nDisableJitOptimizations \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#JitTracking","title":"ILAssemblyManifest.JitTracking","content":"ILAssemblyManifest.JitTracking \nJitTracking \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#IgnoreSymbolStoreSequencePoints","title":"ILAssemblyManifest.IgnoreSymbolStoreSequencePoints","content":"ILAssemblyManifest.IgnoreSymbolStoreSequencePoints \nIgnoreSymbolStoreSequencePoints \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#Retargetable","title":"ILAssemblyManifest.Retargetable","content":"ILAssemblyManifest.Retargetable \nRetargetable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#ExportedTypes","title":"ILAssemblyManifest.ExportedTypes","content":"ILAssemblyManifest.ExportedTypes \nExportedTypes \n Records the types implemented by this assembly in auxiliary\n modules.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#EntrypointElsewhere","title":"ILAssemblyManifest.EntrypointElsewhere","content":"ILAssemblyManifest.EntrypointElsewhere \nEntrypointElsewhere \n Records whether the entrypoint resides in another module.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html#MetadataIndex","title":"ILAssemblyManifest.MetadataIndex","content":"ILAssemblyManifest.MetadataIndex \nMetadataIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html","title":"ILAssemblyRef","content":"ILAssemblyRef \n \nILAssemblyRef.EqualsIgnoringVersion \nEqualsIgnoringVersion \nILAssemblyRef.Locale \nLocale \nILAssemblyRef.Version \nVersion \nILAssemblyRef.Hash \nHash \nILAssemblyRef.QualifiedName \nQualifiedName \nILAssemblyRef.Name \nName \nILAssemblyRef.Retargetable \nRetargetable \nILAssemblyRef.PublicKey \nPublicKey \nILAssemblyRef.Create \nCreate \nILAssemblyRef.FromAssemblyName \nFromAssemblyName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#EqualsIgnoringVersion","title":"ILAssemblyRef.EqualsIgnoringVersion","content":"ILAssemblyRef.EqualsIgnoringVersion \nEqualsIgnoringVersion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#Locale","title":"ILAssemblyRef.Locale","content":"ILAssemblyRef.Locale \nLocale \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#Version","title":"ILAssemblyRef.Version","content":"ILAssemblyRef.Version \nVersion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#Hash","title":"ILAssemblyRef.Hash","content":"ILAssemblyRef.Hash \nHash \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#QualifiedName","title":"ILAssemblyRef.QualifiedName","content":"ILAssemblyRef.QualifiedName \nQualifiedName \n The fully qualified name of the assembly reference, e.g. mscorlib, Version=1.0.3705 etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#Name","title":"ILAssemblyRef.Name","content":"ILAssemblyRef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#Retargetable","title":"ILAssemblyRef.Retargetable","content":"ILAssemblyRef.Retargetable \nRetargetable \n CLI says this indicates if the assembly can be retargeted (at runtime) to be from a different publisher.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#PublicKey","title":"ILAssemblyRef.PublicKey","content":"ILAssemblyRef.PublicKey \nPublicKey \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#Create","title":"ILAssemblyRef.Create","content":"ILAssemblyRef.Create \nCreate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilassemblyref.html#FromAssemblyName","title":"ILAssemblyRef.FromAssemblyName","content":"ILAssemblyRef.FromAssemblyName \nFromAssemblyName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html","title":"ILAttribElem","content":"ILAttribElem \n \nILAttribElem.String \nString \nILAttribElem.Bool \nBool \nILAttribElem.Char \nChar \nILAttribElem.SByte \nSByte \nILAttribElem.Int16 \nInt16 \nILAttribElem.Int32 \nInt32 \nILAttribElem.Int64 \nInt64 \nILAttribElem.Byte \nByte \nILAttribElem.UInt16 \nUInt16 \nILAttribElem.UInt32 \nUInt32 \nILAttribElem.UInt64 \nUInt64 \nILAttribElem.Single \nSingle \nILAttribElem.Double \nDouble \nILAttribElem.Null \nNull \nILAttribElem.Type \nType \nILAttribElem.TypeRef \nTypeRef \nILAttribElem.Array \nArray","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#String","title":"ILAttribElem.String","content":"ILAttribElem.String \nString \n Represents a custom attribute parameter of type \u0027string\u0027. These may be null, in which case they are encoded in a special\n way as indicated by Ecma-335 Partition II.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Bool","title":"ILAttribElem.Bool","content":"ILAttribElem.Bool \nBool \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Char","title":"ILAttribElem.Char","content":"ILAttribElem.Char \nChar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#SByte","title":"ILAttribElem.SByte","content":"ILAttribElem.SByte \nSByte \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Int16","title":"ILAttribElem.Int16","content":"ILAttribElem.Int16 \nInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Int32","title":"ILAttribElem.Int32","content":"ILAttribElem.Int32 \nInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Int64","title":"ILAttribElem.Int64","content":"ILAttribElem.Int64 \nInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Byte","title":"ILAttribElem.Byte","content":"ILAttribElem.Byte \nByte \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#UInt16","title":"ILAttribElem.UInt16","content":"ILAttribElem.UInt16 \nUInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#UInt32","title":"ILAttribElem.UInt32","content":"ILAttribElem.UInt32 \nUInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#UInt64","title":"ILAttribElem.UInt64","content":"ILAttribElem.UInt64 \nUInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Single","title":"ILAttribElem.Single","content":"ILAttribElem.Single \nSingle \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Double","title":"ILAttribElem.Double","content":"ILAttribElem.Double \nDouble \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Null","title":"ILAttribElem.Null","content":"ILAttribElem.Null \nNull \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Type","title":"ILAttribElem.Type","content":"ILAttribElem.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#TypeRef","title":"ILAttribElem.TypeRef","content":"ILAttribElem.TypeRef \nTypeRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribelem.html#Array","title":"ILAttribElem.Array","content":"ILAttribElem.Array \nArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribute.html","title":"ILAttribute","content":"ILAttribute \n Custom attribute. \nILAttribute.Encoded \nEncoded \nILAttribute.Decoded \nDecoded","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribute.html#Encoded","title":"ILAttribute.Encoded","content":"ILAttribute.Encoded \nEncoded \n Attribute with args encoded to a binary blob according to ECMA-335 II.21 and II.23.3.\n \u0027decodeILAttribData\u0027 is used to parse the byte[] blob to ILAttribElem\u0027s as best as possible.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattribute.html#Decoded","title":"ILAttribute.Decoded","content":"ILAttribute.Decoded \nDecoded \n Attribute with args in decoded form.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattributes.html","title":"ILAttributes","content":"ILAttributes \n \nILAttributes.AsArray \nAsArray \nILAttributes.AsList \nAsList","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattributes.html#AsArray","title":"ILAttributes.AsArray","content":"ILAttributes.AsArray \nAsArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattributes.html#AsList","title":"ILAttributes.AsList","content":"ILAttributes.AsList \nAsList \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilattributesstored.html","title":"ILAttributesStored","content":"ILAttributesStored \n Represents the efficiency-oriented storage of ILAttributes in another item.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingconv.html","title":"ILCallingConv","content":"ILCallingConv \n \nILCallingConv.Instance \nInstance \nILCallingConv.Static \nStatic \nILCallingConv.Callconv \nCallconv","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingconv.html#Instance","title":"ILCallingConv.Instance","content":"ILCallingConv.Instance \nInstance \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingconv.html#Static","title":"ILCallingConv.Static","content":"ILCallingConv.Static \nStatic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingconv.html#Callconv","title":"ILCallingConv.Callconv","content":"ILCallingConv.Callconv \nCallconv \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html","title":"ILCallingSignature","content":"ILCallingSignature \n \nILCallingSignature.CallingConv \nCallingConv \nILCallingSignature.ArgTypes \nArgTypes \nILCallingSignature.ReturnType \nReturnType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html#CallingConv","title":"ILCallingSignature.CallingConv","content":"ILCallingSignature.CallingConv \nCallingConv \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html#ArgTypes","title":"ILCallingSignature.ArgTypes","content":"ILCallingSignature.ArgTypes \nArgTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html#ReturnType","title":"ILCallingSignature.ReturnType","content":"ILCallingSignature.ReturnType \nReturnType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildebugimport.html","title":"ILDebugImport","content":"ILDebugImport \n Defines an opened namespace, type relevant to a code location.\n\n Emitted to the PortablePDB format. Note the format supports additional variations on\n imported things that are not yet emitted in F#. \nILDebugImport.ImportType \nImportType \nILDebugImport.ImportNamespace \nImportNamespace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildebugimport.html#ImportType","title":"ILDebugImport.ImportType","content":"ILDebugImport.ImportType \nImportType \n Represents an \u0027open type XYZ\u0027 opening a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildebugimport.html#ImportNamespace","title":"ILDebugImport.ImportNamespace","content":"ILDebugImport.ImportNamespace \nImportNamespace \n Represents an \u0027open XYZ\u0027 opening a namespace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildebugimports.html","title":"ILDebugImports","content":"ILDebugImports \n Defines a set of opened namespace, type relevant to a code location.\n\n Emitted to the PortablePDB format. \nILDebugImports.Parent \nParent \nILDebugImports.Imports \nImports","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildebugimports.html#Parent","title":"ILDebugImports.Parent","content":"ILDebugImports.Parent \nParent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildebugimports.html#Imports","title":"ILDebugImports.Imports","content":"ILDebugImports.Imports \nImports \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html","title":"ILDefaultPInvokeEncoding","content":"ILDefaultPInvokeEncoding \n Default Unicode encoding for P/Invoke within a type. \nILDefaultPInvokeEncoding.Ansi \nAnsi \nILDefaultPInvokeEncoding.Auto \nAuto \nILDefaultPInvokeEncoding.Unicode \nUnicode","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html#Ansi","title":"ILDefaultPInvokeEncoding.Ansi","content":"ILDefaultPInvokeEncoding.Ansi \nAnsi \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html#Auto","title":"ILDefaultPInvokeEncoding.Auto","content":"ILDefaultPInvokeEncoding.Auto \nAuto \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html#Unicode","title":"ILDefaultPInvokeEncoding.Unicode","content":"ILDefaultPInvokeEncoding.Unicode \nUnicode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html","title":"ILEventDef","content":"ILEventDef \n Event definitions. \nILEventDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nILEventDef.CustomAttrs \nCustomAttrs \nILEventDef.OtherMethods \nOtherMethods \nILEventDef.AddMethod \nAddMethod \nILEventDef.Attributes \nAttributes \nILEventDef.IsSpecialName \nIsSpecialName \nILEventDef.RemoveMethod \nRemoveMethod \nILEventDef.IsRTSpecialName \nIsRTSpecialName \nILEventDef.Name \nName \nILEventDef.FireMethod \nFireMethod \nILEventDef.EventType \nEventType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#\u0060\u0060.ctor\u0060\u0060","title":"ILEventDef.\u0060\u0060.ctor\u0060\u0060","content":"ILEventDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Functional creation of a value, immediate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#CustomAttrs","title":"ILEventDef.CustomAttrs","content":"ILEventDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#OtherMethods","title":"ILEventDef.OtherMethods","content":"ILEventDef.OtherMethods \nOtherMethods \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#AddMethod","title":"ILEventDef.AddMethod","content":"ILEventDef.AddMethod \nAddMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#Attributes","title":"ILEventDef.Attributes","content":"ILEventDef.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#IsSpecialName","title":"ILEventDef.IsSpecialName","content":"ILEventDef.IsSpecialName \nIsSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#RemoveMethod","title":"ILEventDef.RemoveMethod","content":"ILEventDef.RemoveMethod \nRemoveMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#IsRTSpecialName","title":"ILEventDef.IsRTSpecialName","content":"ILEventDef.IsRTSpecialName \nIsRTSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#Name","title":"ILEventDef.Name","content":"ILEventDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#FireMethod","title":"ILEventDef.FireMethod","content":"ILEventDef.FireMethod \nFireMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdef.html#EventType","title":"ILEventDef.EventType","content":"ILEventDef.EventType \nEventType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ileventdefs.html","title":"ILEventDefs","content":"ILEventDefs \n Table of those events in a type definition.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html","title":"ILExportedTypeOrForwarder","content":"ILExportedTypeOrForwarder \n these are only found in the ILExportedTypesAndForwarders table in the manifest \nILExportedTypeOrForwarder.CustomAttrs \nCustomAttrs \nILExportedTypeOrForwarder.IsForwarder \nIsForwarder \nILExportedTypeOrForwarder.Access \nAccess \nILExportedTypeOrForwarder.ScopeRef \nScopeRef \nILExportedTypeOrForwarder.Name \nName \nILExportedTypeOrForwarder.Attributes \nAttributes \nILExportedTypeOrForwarder.Nested \nNested \nILExportedTypeOrForwarder.CustomAttrsStored \nCustomAttrsStored \nILExportedTypeOrForwarder.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#CustomAttrs","title":"ILExportedTypeOrForwarder.CustomAttrs","content":"ILExportedTypeOrForwarder.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#IsForwarder","title":"ILExportedTypeOrForwarder.IsForwarder","content":"ILExportedTypeOrForwarder.IsForwarder \nIsForwarder \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#Access","title":"ILExportedTypeOrForwarder.Access","content":"ILExportedTypeOrForwarder.Access \nAccess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#ScopeRef","title":"ILExportedTypeOrForwarder.ScopeRef","content":"ILExportedTypeOrForwarder.ScopeRef \nScopeRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#Name","title":"ILExportedTypeOrForwarder.Name","content":"ILExportedTypeOrForwarder.Name \nName \n [Namespace.]Name","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#Attributes","title":"ILExportedTypeOrForwarder.Attributes","content":"ILExportedTypeOrForwarder.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#Nested","title":"ILExportedTypeOrForwarder.Nested","content":"ILExportedTypeOrForwarder.Nested \nNested \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#CustomAttrsStored","title":"ILExportedTypeOrForwarder.CustomAttrsStored","content":"ILExportedTypeOrForwarder.CustomAttrsStored \nCustomAttrsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html#MetadataIndex","title":"ILExportedTypeOrForwarder.MetadataIndex","content":"ILExportedTypeOrForwarder.MetadataIndex \nMetadataIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilexportedtypesandforwarders.html","title":"ILExportedTypesAndForwarders","content":"ILExportedTypesAndForwarders \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html","title":"ILFieldDef","content":"ILFieldDef \n Field definitions. \nILFieldDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nILFieldDef.CustomAttrs \nCustomAttrs \nILFieldDef.NotSerialized \nNotSerialized \nILFieldDef.LiteralValue \nLiteralValue \nILFieldDef.Attributes \nAttributes \nILFieldDef.Offset \nOffset \nILFieldDef.Data \nData \nILFieldDef.IsSpecialName \nIsSpecialName \nILFieldDef.Marshal \nMarshal \nILFieldDef.Access \nAccess \nILFieldDef.IsStatic \nIsStatic \nILFieldDef.IsLiteral \nIsLiteral \nILFieldDef.Name \nName \nILFieldDef.IsInitOnly \nIsInitOnly \nILFieldDef.FieldType \nFieldType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#\u0060\u0060.ctor\u0060\u0060","title":"ILFieldDef.\u0060\u0060.ctor\u0060\u0060","content":"ILFieldDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Functional creation of a value, immediate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#CustomAttrs","title":"ILFieldDef.CustomAttrs","content":"ILFieldDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#NotSerialized","title":"ILFieldDef.NotSerialized","content":"ILFieldDef.NotSerialized \nNotSerialized \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#LiteralValue","title":"ILFieldDef.LiteralValue","content":"ILFieldDef.LiteralValue \nLiteralValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#Attributes","title":"ILFieldDef.Attributes","content":"ILFieldDef.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#Offset","title":"ILFieldDef.Offset","content":"ILFieldDef.Offset \nOffset \n The explicit offset in bytes when explicit layout is used.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#Data","title":"ILFieldDef.Data","content":"ILFieldDef.Data \nData \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#IsSpecialName","title":"ILFieldDef.IsSpecialName","content":"ILFieldDef.IsSpecialName \nIsSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#Marshal","title":"ILFieldDef.Marshal","content":"ILFieldDef.Marshal \nMarshal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#Access","title":"ILFieldDef.Access","content":"ILFieldDef.Access \nAccess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#IsStatic","title":"ILFieldDef.IsStatic","content":"ILFieldDef.IsStatic \nIsStatic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#IsLiteral","title":"ILFieldDef.IsLiteral","content":"ILFieldDef.IsLiteral \nIsLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#Name","title":"ILFieldDef.Name","content":"ILFieldDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#IsInitOnly","title":"ILFieldDef.IsInitOnly","content":"ILFieldDef.IsInitOnly \nIsInitOnly \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddef.html#FieldType","title":"ILFieldDef.FieldType","content":"ILFieldDef.FieldType \nFieldType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfielddefs.html","title":"ILFieldDefs","content":"ILFieldDefs \n Tables of fields. Logically equivalent to a list of fields but the table is kept in\n a form to allow efficient looking up fields by name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html","title":"ILFieldInit","content":"ILFieldInit \n Field Init \nILFieldInit.AsObject \nAsObject \nILFieldInit.String \nString \nILFieldInit.Bool \nBool \nILFieldInit.Char \nChar \nILFieldInit.Int8 \nInt8 \nILFieldInit.Int16 \nInt16 \nILFieldInit.Int32 \nInt32 \nILFieldInit.Int64 \nInt64 \nILFieldInit.UInt8 \nUInt8 \nILFieldInit.UInt16 \nUInt16 \nILFieldInit.UInt32 \nUInt32 \nILFieldInit.UInt64 \nUInt64 \nILFieldInit.Single \nSingle \nILFieldInit.Double \nDouble \nILFieldInit.Null \nNull","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#AsObject","title":"ILFieldInit.AsObject","content":"ILFieldInit.AsObject \nAsObject \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#String","title":"ILFieldInit.String","content":"ILFieldInit.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Bool","title":"ILFieldInit.Bool","content":"ILFieldInit.Bool \nBool \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Char","title":"ILFieldInit.Char","content":"ILFieldInit.Char \nChar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Int8","title":"ILFieldInit.Int8","content":"ILFieldInit.Int8 \nInt8 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Int16","title":"ILFieldInit.Int16","content":"ILFieldInit.Int16 \nInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Int32","title":"ILFieldInit.Int32","content":"ILFieldInit.Int32 \nInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Int64","title":"ILFieldInit.Int64","content":"ILFieldInit.Int64 \nInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#UInt8","title":"ILFieldInit.UInt8","content":"ILFieldInit.UInt8 \nUInt8 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#UInt16","title":"ILFieldInit.UInt16","content":"ILFieldInit.UInt16 \nUInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#UInt32","title":"ILFieldInit.UInt32","content":"ILFieldInit.UInt32 \nUInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#UInt64","title":"ILFieldInit.UInt64","content":"ILFieldInit.UInt64 \nUInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Single","title":"ILFieldInit.Single","content":"ILFieldInit.Single \nSingle \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Double","title":"ILFieldInit.Double","content":"ILFieldInit.Double \nDouble \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldinit.html#Null","title":"ILFieldInit.Null","content":"ILFieldInit.Null \nNull \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldref.html","title":"ILFieldRef","content":"ILFieldRef \n Formal identities of fields. \nILFieldRef.DeclaringTypeRef \nDeclaringTypeRef \nILFieldRef.Name \nName \nILFieldRef.Type \nType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldref.html#DeclaringTypeRef","title":"ILFieldRef.DeclaringTypeRef","content":"ILFieldRef.DeclaringTypeRef \nDeclaringTypeRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldref.html#Name","title":"ILFieldRef.Name","content":"ILFieldRef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldref.html#Type","title":"ILFieldRef.Type","content":"ILFieldRef.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html","title":"ILFieldSpec","content":"ILFieldSpec \n Field specs. The data given for a ldfld, stfld etc. instruction. \nILFieldSpec.DeclaringTypeRef \nDeclaringTypeRef \nILFieldSpec.ActualType \nActualType \nILFieldSpec.FormalType \nFormalType \nILFieldSpec.Name \nName \nILFieldSpec.FieldRef \nFieldRef \nILFieldSpec.DeclaringType \nDeclaringType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html#DeclaringTypeRef","title":"ILFieldSpec.DeclaringTypeRef","content":"ILFieldSpec.DeclaringTypeRef \nDeclaringTypeRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html#ActualType","title":"ILFieldSpec.ActualType","content":"ILFieldSpec.ActualType \nActualType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html#FormalType","title":"ILFieldSpec.FormalType","content":"ILFieldSpec.FormalType \nFormalType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html#Name","title":"ILFieldSpec.Name","content":"ILFieldSpec.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html#FieldRef","title":"ILFieldSpec.FieldRef","content":"ILFieldSpec.FieldRef \nFieldRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilfieldspec.html#DeclaringType","title":"ILFieldSpec.DeclaringType","content":"ILFieldSpec.DeclaringType \nDeclaringType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html","title":"ILGenericParameterDef","content":"ILGenericParameterDef \n Generic parameters. Formal generic parameter declarations may include the bounds, if any, on the generic parameter. \nILGenericParameterDef.CustomAttrs \nCustomAttrs \nILGenericParameterDef.Name \nName \nILGenericParameterDef.Constraints \nConstraints \nILGenericParameterDef.Variance \nVariance \nILGenericParameterDef.HasReferenceTypeConstraint \nHasReferenceTypeConstraint \nILGenericParameterDef.HasNotNullableValueTypeConstraint \nHasNotNullableValueTypeConstraint \nILGenericParameterDef.HasDefaultConstructorConstraint \nHasDefaultConstructorConstraint \nILGenericParameterDef.CustomAttrsStored \nCustomAttrsStored \nILGenericParameterDef.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#CustomAttrs","title":"ILGenericParameterDef.CustomAttrs","content":"ILGenericParameterDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#Name","title":"ILGenericParameterDef.Name","content":"ILGenericParameterDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#Constraints","title":"ILGenericParameterDef.Constraints","content":"ILGenericParameterDef.Constraints \nConstraints \n At most one is the parent type, the others are interface types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#Variance","title":"ILGenericParameterDef.Variance","content":"ILGenericParameterDef.Variance \nVariance \n Variance of type parameters, only applicable to generic parameters for generic interfaces and delegates.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#HasReferenceTypeConstraint","title":"ILGenericParameterDef.HasReferenceTypeConstraint","content":"ILGenericParameterDef.HasReferenceTypeConstraint \nHasReferenceTypeConstraint \n Indicates the type argument must be a reference type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#HasNotNullableValueTypeConstraint","title":"ILGenericParameterDef.HasNotNullableValueTypeConstraint","content":"ILGenericParameterDef.HasNotNullableValueTypeConstraint \nHasNotNullableValueTypeConstraint \n Indicates the type argument must be a value type, but not Nullable.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#HasDefaultConstructorConstraint","title":"ILGenericParameterDef.HasDefaultConstructorConstraint","content":"ILGenericParameterDef.HasDefaultConstructorConstraint \nHasDefaultConstructorConstraint \n Indicates the type argument must have a public nullary constructor.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#CustomAttrsStored","title":"ILGenericParameterDef.CustomAttrsStored","content":"ILGenericParameterDef.CustomAttrsStored \nCustomAttrsStored \n Do not use this","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html#MetadataIndex","title":"ILGenericParameterDef.MetadataIndex","content":"ILGenericParameterDef.MetadataIndex \nMetadataIndex \n Do not use this","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html","title":"ILGenericVariance","content":"ILGenericVariance \n \nILGenericVariance.NonVariant \nNonVariant \nILGenericVariance.CoVariant \nCoVariant \nILGenericVariance.ContraVariant \nContraVariant","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html#NonVariant","title":"ILGenericVariance.NonVariant","content":"ILGenericVariance.NonVariant \nNonVariant \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html#CoVariant","title":"ILGenericVariance.CoVariant","content":"ILGenericVariance.CoVariant \nCoVariant \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html#ContraVariant","title":"ILGenericVariance.ContraVariant","content":"ILGenericVariance.ContraVariant \nContraVariant \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilguid.html","title":"ILGuid","content":"ILGuid \n Represents guids","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html","title":"ILMemberAccess","content":"ILMemberAccess \n Member Access \nILMemberAccess.Assembly \nAssembly \nILMemberAccess.CompilerControlled \nCompilerControlled \nILMemberAccess.FamilyAndAssembly \nFamilyAndAssembly \nILMemberAccess.FamilyOrAssembly \nFamilyOrAssembly \nILMemberAccess.Family \nFamily \nILMemberAccess.Private \nPrivate \nILMemberAccess.Public \nPublic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#Assembly","title":"ILMemberAccess.Assembly","content":"ILMemberAccess.Assembly \nAssembly \n Assembly - Indicates that the method is accessible to any class of this assembly. (internal)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#CompilerControlled","title":"ILMemberAccess.CompilerControlled","content":"ILMemberAccess.CompilerControlled \nCompilerControlled \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#FamilyAndAssembly","title":"ILMemberAccess.FamilyAndAssembly","content":"ILMemberAccess.FamilyAndAssembly \nFamilyAndAssembly \n FamilyAndAssembly - Indicates that the method is accessible to members of this type and its derived types that are in _this assembly only_. (private protected)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#FamilyOrAssembly","title":"ILMemberAccess.FamilyOrAssembly","content":"ILMemberAccess.FamilyOrAssembly \nFamilyOrAssembly \n FamilyOrAssembly - Indicates that the method is accessible to derived classes anywhere, as well as to any class _in the assembly_. (protected internal)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#Family","title":"ILMemberAccess.Family","content":"ILMemberAccess.Family \nFamily \n Family - Indicates that the method is accessible only to members of this class and its derived classes. (protected)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#Private","title":"ILMemberAccess.Private","content":"ILMemberAccess.Private \nPrivate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html#Public","title":"ILMemberAccess.Public","content":"ILMemberAccess.Public \nPublic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html","title":"ILMethodDef","content":"ILMethodDef \n IL Method definitions. \nILMethodDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nILMethodDef.GetCallingSignature \nGetCallingSignature \nILMethodDef.IsManaged \nIsManaged \nILMethodDef.IsSpecialName \nIsSpecialName \nILMethodDef.SecurityDecls \nSecurityDecls \nILMethodDef.IsConstructor \nIsConstructor \nILMethodDef.IsSynchronized \nIsSynchronized \nILMethodDef.IsReqSecObj \nIsReqSecObj \nILMethodDef.IsClassInitializer \nIsClassInitializer \nILMethodDef.IsStatic \nIsStatic \nILMethodDef.Code \nCode \nILMethodDef.IsAggressiveInline \nIsAggressiveInline \nILMethodDef.Return \nReturn \nILMethodDef.HasSecurity \nHasSecurity \nILMethodDef.Body \nBody \nILMethodDef.Name \nName \nILMethodDef.IsNoInline \nIsNoInline \nILMethodDef.IsZeroInit \nIsZeroInit \nILMethodDef.IsPreserveSig \nIsPreserveSig \nILMethodDef.IsEntryPoint \nIsEntryPoint \nILMethodDef.IsNonVirtualInstance \nIsNonVirtualInstance \nILMethodDef.CallingConv \nCallingConv \nILMethodDef.MaxStack \nMaxStack \nILMethodDef.Access \nAccess \nILMethodDef.ParameterTypes \nParameterTypes \nILMethodDef.Locals \nLocals \nILMethodDef.IsFinal \nIsFinal \nILMethodDef.ImplAttributes \nImplAttributes \nILMethodDef.Parameters \nParameters \nILMethodDef.IsAbstract \nIsAbstract \nILMethodDef.IsMustRun \nIsMustRun \nILMethodDef.IsCheckAccessOnOverride \nIsCheckAccessOnOverride \nILMethodDef.IsIL \nIsIL \nILMethodDef.IsHideBySig \nIsHideBySig \nILMethodDef.GenericParams \nGenericParams \nILMethodDef.CustomAttrs \nCustomAttrs \nILMethodDef.IsUnmanagedExport \nIsUnmanagedExport \nILMethodDef.IsVirtual \nIsVirtual \nILMethodDef.MethodBody \nMethodBody \nILMethodDef.IsForwardRef \nIsForwardRef \nILMethodDef.IsNewSlot \nIsNewSlot \nILMethodDef.Attributes \nAttributes \nILMethodDef.IsInternalCall \nIsInternalCall","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#\u0060\u0060.ctor\u0060\u0060","title":"ILMethodDef.\u0060\u0060.ctor\u0060\u0060","content":"ILMethodDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Functional creation of a value, immediate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#GetCallingSignature","title":"ILMethodDef.GetCallingSignature","content":"ILMethodDef.GetCallingSignature \nGetCallingSignature \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsManaged","title":"ILMethodDef.IsManaged","content":"ILMethodDef.IsManaged \nIsManaged \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsSpecialName","title":"ILMethodDef.IsSpecialName","content":"ILMethodDef.IsSpecialName \nIsSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#SecurityDecls","title":"ILMethodDef.SecurityDecls","content":"ILMethodDef.SecurityDecls \nSecurityDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsConstructor","title":"ILMethodDef.IsConstructor","content":"ILMethodDef.IsConstructor \nIsConstructor \n Indicates a .ctor method.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsSynchronized","title":"ILMethodDef.IsSynchronized","content":"ILMethodDef.IsSynchronized \nIsSynchronized \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsReqSecObj","title":"ILMethodDef.IsReqSecObj","content":"ILMethodDef.IsReqSecObj \nIsReqSecObj \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsClassInitializer","title":"ILMethodDef.IsClassInitializer","content":"ILMethodDef.IsClassInitializer \nIsClassInitializer \n Indicates a .cctor method.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsStatic","title":"ILMethodDef.IsStatic","content":"ILMethodDef.IsStatic \nIsStatic \n Indicates a static method.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Code","title":"ILMethodDef.Code","content":"ILMethodDef.Code \nCode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsAggressiveInline","title":"ILMethodDef.IsAggressiveInline","content":"ILMethodDef.IsAggressiveInline \nIsAggressiveInline \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Return","title":"ILMethodDef.Return","content":"ILMethodDef.Return \nReturn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#HasSecurity","title":"ILMethodDef.HasSecurity","content":"ILMethodDef.HasSecurity \nHasSecurity \n Some methods are marked \u0022HasSecurity\u0022 even if there are no permissions attached, e.g. if they use SuppressUnmanagedCodeSecurityAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Body","title":"ILMethodDef.Body","content":"ILMethodDef.Body \nBody \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Name","title":"ILMethodDef.Name","content":"ILMethodDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsNoInline","title":"ILMethodDef.IsNoInline","content":"ILMethodDef.IsNoInline \nIsNoInline \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsZeroInit","title":"ILMethodDef.IsZeroInit","content":"ILMethodDef.IsZeroInit \nIsZeroInit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsPreserveSig","title":"ILMethodDef.IsPreserveSig","content":"ILMethodDef.IsPreserveSig \nIsPreserveSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsEntryPoint","title":"ILMethodDef.IsEntryPoint","content":"ILMethodDef.IsEntryPoint \nIsEntryPoint \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsNonVirtualInstance","title":"ILMethodDef.IsNonVirtualInstance","content":"ILMethodDef.IsNonVirtualInstance \nIsNonVirtualInstance \n Indicates this is an instance methods that is not virtual.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#CallingConv","title":"ILMethodDef.CallingConv","content":"ILMethodDef.CallingConv \nCallingConv \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#MaxStack","title":"ILMethodDef.MaxStack","content":"ILMethodDef.MaxStack \nMaxStack \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Access","title":"ILMethodDef.Access","content":"ILMethodDef.Access \nAccess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#ParameterTypes","title":"ILMethodDef.ParameterTypes","content":"ILMethodDef.ParameterTypes \nParameterTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Locals","title":"ILMethodDef.Locals","content":"ILMethodDef.Locals \nLocals \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsFinal","title":"ILMethodDef.IsFinal","content":"ILMethodDef.IsFinal \nIsFinal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#ImplAttributes","title":"ILMethodDef.ImplAttributes","content":"ILMethodDef.ImplAttributes \nImplAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Parameters","title":"ILMethodDef.Parameters","content":"ILMethodDef.Parameters \nParameters \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsAbstract","title":"ILMethodDef.IsAbstract","content":"ILMethodDef.IsAbstract \nIsAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsMustRun","title":"ILMethodDef.IsMustRun","content":"ILMethodDef.IsMustRun \nIsMustRun \n SafeHandle finalizer must be run.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsCheckAccessOnOverride","title":"ILMethodDef.IsCheckAccessOnOverride","content":"ILMethodDef.IsCheckAccessOnOverride \nIsCheckAccessOnOverride \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsIL","title":"ILMethodDef.IsIL","content":"ILMethodDef.IsIL \nIsIL \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsHideBySig","title":"ILMethodDef.IsHideBySig","content":"ILMethodDef.IsHideBySig \nIsHideBySig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#GenericParams","title":"ILMethodDef.GenericParams","content":"ILMethodDef.GenericParams \nGenericParams \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#CustomAttrs","title":"ILMethodDef.CustomAttrs","content":"ILMethodDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsUnmanagedExport","title":"ILMethodDef.IsUnmanagedExport","content":"ILMethodDef.IsUnmanagedExport \nIsUnmanagedExport \n The method is exported to unmanaged code using COM interop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsVirtual","title":"ILMethodDef.IsVirtual","content":"ILMethodDef.IsVirtual \nIsVirtual \n Indicates an instance methods that is virtual or abstract or implements an interface slot.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#MethodBody","title":"ILMethodDef.MethodBody","content":"ILMethodDef.MethodBody \nMethodBody \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsForwardRef","title":"ILMethodDef.IsForwardRef","content":"ILMethodDef.IsForwardRef \nIsForwardRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsNewSlot","title":"ILMethodDef.IsNewSlot","content":"ILMethodDef.IsNewSlot \nIsNewSlot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#Attributes","title":"ILMethodDef.Attributes","content":"ILMethodDef.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddef.html#IsInternalCall","title":"ILMethodDef.IsInternalCall","content":"ILMethodDef.IsInternalCall \nIsInternalCall \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html","title":"ILMethodDefs","content":"ILMethodDefs \n Tables of methods. Logically equivalent to a list of methods but\n the table is kept in a form optimized for looking up methods by\n name and arity. \nILMethodDefs.AsArray \nAsArray \nILMethodDefs.AsList \nAsList \nILMethodDefs.FindByName \nFindByName \nILMethodDefs.TryFindInstanceByNameAndCallingSignature \nTryFindInstanceByNameAndCallingSignature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html#AsArray","title":"ILMethodDefs.AsArray","content":"ILMethodDefs.AsArray \nAsArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html#AsList","title":"ILMethodDefs.AsList","content":"ILMethodDefs.AsList \nAsList \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html#FindByName","title":"ILMethodDefs.FindByName","content":"ILMethodDefs.FindByName \nFindByName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html#TryFindInstanceByNameAndCallingSignature","title":"ILMethodDefs.TryFindInstanceByNameAndCallingSignature","content":"ILMethodDefs.TryFindInstanceByNameAndCallingSignature \nTryFindInstanceByNameAndCallingSignature \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodimpldef.html","title":"ILMethodImplDef","content":"ILMethodImplDef \n Method Impls \nILMethodImplDef.Overrides \nOverrides \nILMethodImplDef.OverrideBy \nOverrideBy","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodimpldef.html#Overrides","title":"ILMethodImplDef.Overrides","content":"ILMethodImplDef.Overrides \nOverrides \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodimpldef.html#OverrideBy","title":"ILMethodImplDef.OverrideBy","content":"ILMethodImplDef.OverrideBy \nOverrideBy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodimpldefs.html","title":"ILMethodImplDefs","content":"ILMethodImplDefs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html","title":"ILMethodRef","content":"ILMethodRef \n Formal identities of methods. \nILMethodRef.GetCallingSignature \nGetCallingSignature \nILMethodRef.DeclaringTypeRef \nDeclaringTypeRef \nILMethodRef.ReturnType \nReturnType \nILMethodRef.ArgCount \nArgCount \nILMethodRef.Name \nName \nILMethodRef.ArgTypes \nArgTypes \nILMethodRef.CallingConv \nCallingConv \nILMethodRef.GenericArity \nGenericArity \nILMethodRef.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#GetCallingSignature","title":"ILMethodRef.GetCallingSignature","content":"ILMethodRef.GetCallingSignature \nGetCallingSignature \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#DeclaringTypeRef","title":"ILMethodRef.DeclaringTypeRef","content":"ILMethodRef.DeclaringTypeRef \nDeclaringTypeRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#ReturnType","title":"ILMethodRef.ReturnType","content":"ILMethodRef.ReturnType \nReturnType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#ArgCount","title":"ILMethodRef.ArgCount","content":"ILMethodRef.ArgCount \nArgCount \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#Name","title":"ILMethodRef.Name","content":"ILMethodRef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#ArgTypes","title":"ILMethodRef.ArgTypes","content":"ILMethodRef.ArgTypes \nArgTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#CallingConv","title":"ILMethodRef.CallingConv","content":"ILMethodRef.CallingConv \nCallingConv \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#GenericArity","title":"ILMethodRef.GenericArity","content":"ILMethodRef.GenericArity \nGenericArity \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodref.html#Create","title":"ILMethodRef.Create","content":"ILMethodRef.Create \nCreate \n Functional creation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html","title":"ILMethodSpec","content":"ILMethodSpec \n The information at the callsite of a method \nILMethodSpec.DeclaringType \nDeclaringType \nILMethodSpec.FormalReturnType \nFormalReturnType \nILMethodSpec.MethodRef \nMethodRef \nILMethodSpec.Name \nName \nILMethodSpec.FormalArgTypes \nFormalArgTypes \nILMethodSpec.GenericArgs \nGenericArgs \nILMethodSpec.CallingConv \nCallingConv \nILMethodSpec.GenericArity \nGenericArity \nILMethodSpec.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#DeclaringType","title":"ILMethodSpec.DeclaringType","content":"ILMethodSpec.DeclaringType \nDeclaringType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#FormalReturnType","title":"ILMethodSpec.FormalReturnType","content":"ILMethodSpec.FormalReturnType \nFormalReturnType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#MethodRef","title":"ILMethodSpec.MethodRef","content":"ILMethodSpec.MethodRef \nMethodRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#Name","title":"ILMethodSpec.Name","content":"ILMethodSpec.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#FormalArgTypes","title":"ILMethodSpec.FormalArgTypes","content":"ILMethodSpec.FormalArgTypes \nFormalArgTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#GenericArgs","title":"ILMethodSpec.GenericArgs","content":"ILMethodSpec.GenericArgs \nGenericArgs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#CallingConv","title":"ILMethodSpec.CallingConv","content":"ILMethodSpec.CallingConv \nCallingConv \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#GenericArity","title":"ILMethodSpec.GenericArity","content":"ILMethodSpec.GenericArity \nGenericArity \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmethodspec.html#Create","title":"ILMethodSpec.Create","content":"ILMethodSpec.Create \nCreate \n Functional creation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html","title":"ILModuleDef","content":"ILModuleDef \n One module in the \u0022current\u0022 assembly, either a main-module or\n an auxiliary module. The main module will have a manifest.\n\n An assembly is built by joining together a \u0022main\u0022 module plus\n several auxiliary modules. \nILModuleDef.CustomAttrs \nCustomAttrs \nILModuleDef.ManifestOfAssembly \nManifestOfAssembly \nILModuleDef.HasManifest \nHasManifest \nILModuleDef.Manifest \nManifest \nILModuleDef.Name \nName \nILModuleDef.TypeDefs \nTypeDefs \nILModuleDef.SubsystemVersion \nSubsystemVersion \nILModuleDef.UseHighEntropyVA \nUseHighEntropyVA \nILModuleDef.SubSystemFlags \nSubSystemFlags \nILModuleDef.IsDLL \nIsDLL \nILModuleDef.IsILOnly \nIsILOnly \nILModuleDef.Platform \nPlatform \nILModuleDef.StackReserveSize \nStackReserveSize \nILModuleDef.Is32Bit \nIs32Bit \nILModuleDef.Is32BitPreferred \nIs32BitPreferred \nILModuleDef.Is64Bit \nIs64Bit \nILModuleDef.VirtualAlignment \nVirtualAlignment \nILModuleDef.PhysicalAlignment \nPhysicalAlignment \nILModuleDef.ImageBase \nImageBase \nILModuleDef.MetadataVersion \nMetadataVersion \nILModuleDef.Resources \nResources \nILModuleDef.NativeResources \nNativeResources \nILModuleDef.CustomAttrsStored \nCustomAttrsStored \nILModuleDef.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#CustomAttrs","title":"ILModuleDef.CustomAttrs","content":"ILModuleDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#ManifestOfAssembly","title":"ILModuleDef.ManifestOfAssembly","content":"ILModuleDef.ManifestOfAssembly \nManifestOfAssembly \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#HasManifest","title":"ILModuleDef.HasManifest","content":"ILModuleDef.HasManifest \nHasManifest \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Manifest","title":"ILModuleDef.Manifest","content":"ILModuleDef.Manifest \nManifest \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Name","title":"ILModuleDef.Name","content":"ILModuleDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#TypeDefs","title":"ILModuleDef.TypeDefs","content":"ILModuleDef.TypeDefs \nTypeDefs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#SubsystemVersion","title":"ILModuleDef.SubsystemVersion","content":"ILModuleDef.SubsystemVersion \nSubsystemVersion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#UseHighEntropyVA","title":"ILModuleDef.UseHighEntropyVA","content":"ILModuleDef.UseHighEntropyVA \nUseHighEntropyVA \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#SubSystemFlags","title":"ILModuleDef.SubSystemFlags","content":"ILModuleDef.SubSystemFlags \nSubSystemFlags \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#IsDLL","title":"ILModuleDef.IsDLL","content":"ILModuleDef.IsDLL \nIsDLL \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#IsILOnly","title":"ILModuleDef.IsILOnly","content":"ILModuleDef.IsILOnly \nIsILOnly \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Platform","title":"ILModuleDef.Platform","content":"ILModuleDef.Platform \nPlatform \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#StackReserveSize","title":"ILModuleDef.StackReserveSize","content":"ILModuleDef.StackReserveSize \nStackReserveSize \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Is32Bit","title":"ILModuleDef.Is32Bit","content":"ILModuleDef.Is32Bit \nIs32Bit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Is32BitPreferred","title":"ILModuleDef.Is32BitPreferred","content":"ILModuleDef.Is32BitPreferred \nIs32BitPreferred \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Is64Bit","title":"ILModuleDef.Is64Bit","content":"ILModuleDef.Is64Bit \nIs64Bit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#VirtualAlignment","title":"ILModuleDef.VirtualAlignment","content":"ILModuleDef.VirtualAlignment \nVirtualAlignment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#PhysicalAlignment","title":"ILModuleDef.PhysicalAlignment","content":"ILModuleDef.PhysicalAlignment \nPhysicalAlignment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#ImageBase","title":"ILModuleDef.ImageBase","content":"ILModuleDef.ImageBase \nImageBase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#MetadataVersion","title":"ILModuleDef.MetadataVersion","content":"ILModuleDef.MetadataVersion \nMetadataVersion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#Resources","title":"ILModuleDef.Resources","content":"ILModuleDef.Resources \nResources \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#NativeResources","title":"ILModuleDef.NativeResources","content":"ILModuleDef.NativeResources \nNativeResources \n e.g. win86 resources, as the exact contents of a .res or .obj file. Must be unlinked manually.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#CustomAttrsStored","title":"ILModuleDef.CustomAttrsStored","content":"ILModuleDef.CustomAttrsStored \nCustomAttrsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduledef.html#MetadataIndex","title":"ILModuleDef.MetadataIndex","content":"ILModuleDef.MetadataIndex \nMetadataIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduleref.html","title":"ILModuleRef","content":"ILModuleRef \n \nILModuleRef.HasMetadata \nHasMetadata \nILModuleRef.Hash \nHash \nILModuleRef.Name \nName \nILModuleRef.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduleref.html#HasMetadata","title":"ILModuleRef.HasMetadata","content":"ILModuleRef.HasMetadata \nHasMetadata \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduleref.html#Hash","title":"ILModuleRef.Hash","content":"ILModuleRef.Hash \nHash \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduleref.html#Name","title":"ILModuleRef.Name","content":"ILModuleRef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilmoduleref.html#Create","title":"ILModuleRef.Create","content":"ILModuleRef.Create \nCreate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativeresource.html","title":"ILNativeResource","content":"ILNativeResource \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html","title":"ILNativeType","content":"ILNativeType \n Native Types, for marshalling to the native C interface.\n These are taken directly from the ILASM syntax.\n Most of these are listed in the CLI ECMA-335 Spec (Partition II, 7.4). \nILNativeType.Empty \nEmpty \nILNativeType.Custom \nCustom \nILNativeType.FixedSysString \nFixedSysString \nILNativeType.FixedArray \nFixedArray \nILNativeType.Currency \nCurrency \nILNativeType.LPSTR \nLPSTR \nILNativeType.LPWSTR \nLPWSTR \nILNativeType.LPTSTR \nLPTSTR \nILNativeType.LPUTF8STR \nLPUTF8STR \nILNativeType.ByValStr \nByValStr \nILNativeType.TBSTR \nTBSTR \nILNativeType.LPSTRUCT \nLPSTRUCT \nILNativeType.Struct \nStruct \nILNativeType.Void \nVoid \nILNativeType.Bool \nBool \nILNativeType.Int8 \nInt8 \nILNativeType.Int16 \nInt16 \nILNativeType.Int32 \nInt32 \nILNativeType.Int64 \nInt64 \nILNativeType.Single \nSingle \nILNativeType.Double \nDouble \nILNativeType.Byte \nByte \nILNativeType.UInt16 \nUInt16 \nILNativeType.UInt32 \nUInt32 \nILNativeType.UInt64 \nUInt64 \nILNativeType.Array \nArray \nILNativeType.Int \nInt \nILNativeType.UInt \nUInt \nILNativeType.Method \nMethod \nILNativeType.AsAny \nAsAny \nILNativeType.BSTR \nBSTR \nILNativeType.IUnknown \nIUnknown \nILNativeType.IDispatch \nIDispatch \nILNativeType.Interface \nInterface \nILNativeType.Error \nError \nILNativeType.SafeArray \nSafeArray \nILNativeType.ANSIBSTR \nANSIBSTR \nILNativeType.VariantBool \nVariantBool","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Empty","title":"ILNativeType.Empty","content":"ILNativeType.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Custom","title":"ILNativeType.Custom","content":"ILNativeType.Custom \nCustom \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#FixedSysString","title":"ILNativeType.FixedSysString","content":"ILNativeType.FixedSysString \nFixedSysString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#FixedArray","title":"ILNativeType.FixedArray","content":"ILNativeType.FixedArray \nFixedArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Currency","title":"ILNativeType.Currency","content":"ILNativeType.Currency \nCurrency \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#LPSTR","title":"ILNativeType.LPSTR","content":"ILNativeType.LPSTR \nLPSTR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#LPWSTR","title":"ILNativeType.LPWSTR","content":"ILNativeType.LPWSTR \nLPWSTR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#LPTSTR","title":"ILNativeType.LPTSTR","content":"ILNativeType.LPTSTR \nLPTSTR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#LPUTF8STR","title":"ILNativeType.LPUTF8STR","content":"ILNativeType.LPUTF8STR \nLPUTF8STR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#ByValStr","title":"ILNativeType.ByValStr","content":"ILNativeType.ByValStr \nByValStr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#TBSTR","title":"ILNativeType.TBSTR","content":"ILNativeType.TBSTR \nTBSTR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#LPSTRUCT","title":"ILNativeType.LPSTRUCT","content":"ILNativeType.LPSTRUCT \nLPSTRUCT \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Struct","title":"ILNativeType.Struct","content":"ILNativeType.Struct \nStruct \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Void","title":"ILNativeType.Void","content":"ILNativeType.Void \nVoid \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Bool","title":"ILNativeType.Bool","content":"ILNativeType.Bool \nBool \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Int8","title":"ILNativeType.Int8","content":"ILNativeType.Int8 \nInt8 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Int16","title":"ILNativeType.Int16","content":"ILNativeType.Int16 \nInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Int32","title":"ILNativeType.Int32","content":"ILNativeType.Int32 \nInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Int64","title":"ILNativeType.Int64","content":"ILNativeType.Int64 \nInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Single","title":"ILNativeType.Single","content":"ILNativeType.Single \nSingle \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Double","title":"ILNativeType.Double","content":"ILNativeType.Double \nDouble \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Byte","title":"ILNativeType.Byte","content":"ILNativeType.Byte \nByte \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#UInt16","title":"ILNativeType.UInt16","content":"ILNativeType.UInt16 \nUInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#UInt32","title":"ILNativeType.UInt32","content":"ILNativeType.UInt32 \nUInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#UInt64","title":"ILNativeType.UInt64","content":"ILNativeType.UInt64 \nUInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Array","title":"ILNativeType.Array","content":"ILNativeType.Array \nArray \n optional idx of parameter giving size plus optional additive i.e. num elems","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Int","title":"ILNativeType.Int","content":"ILNativeType.Int \nInt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#UInt","title":"ILNativeType.UInt","content":"ILNativeType.UInt \nUInt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Method","title":"ILNativeType.Method","content":"ILNativeType.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#AsAny","title":"ILNativeType.AsAny","content":"ILNativeType.AsAny \nAsAny \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#BSTR","title":"ILNativeType.BSTR","content":"ILNativeType.BSTR \nBSTR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#IUnknown","title":"ILNativeType.IUnknown","content":"ILNativeType.IUnknown \nIUnknown \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#IDispatch","title":"ILNativeType.IDispatch","content":"ILNativeType.IDispatch \nIDispatch \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Interface","title":"ILNativeType.Interface","content":"ILNativeType.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#Error","title":"ILNativeType.Error","content":"ILNativeType.Error \nError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#SafeArray","title":"ILNativeType.SafeArray","content":"ILNativeType.SafeArray \nSafeArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#ANSIBSTR","title":"ILNativeType.ANSIBSTR","content":"ILNativeType.ANSIBSTR \nANSIBSTR \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnativetype.html#VariantBool","title":"ILNativeType.VariantBool","content":"ILNativeType.VariantBool \nVariantBool \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html","title":"ILNestedExportedType","content":"ILNestedExportedType \n \u0022Classes Elsewhere\u0022 - classes in auxiliary modules.\n\n Manifests include declarations for all the classes in an\n assembly, regardless of which module they are in.\n\n The \u0022.class extern\u0022 construct describes so-called exported types --\n these are public classes defined in the auxiliary modules of this assembly,\n i.e. modules other than the manifest-carrying module.\n\n For example, if you have a two-module\n assembly (A.DLL and B.DLL), and the manifest resides in the A.DLL,\n then in the manifest all the public classes declared in B.DLL should\n be defined as exported types, i.e., as \u0022.class extern\u0022. The public classes\n defined in A.DLL should not be defined as \u0022.class extern\u0022 -- they are\n already available in the manifest-carrying module. The union of all\n public classes defined in the manifest-carrying module and all\n exported types defined there is the set of all classes exposed by\n this assembly. Thus, by analysing the metadata of the manifest-carrying\n module of an assembly, you can identify all the classes exposed by\n this assembly, and where to find them.\n\n Nested classes found in external modules should also be located in\n this table, suitably nested inside another \u0022ILExportedTypeOrForwarder\u0022\n definition.\n these are only found in the \u0022Nested\u0022 field of ILExportedTypeOrForwarder objects \nILNestedExportedType.CustomAttrs \nCustomAttrs \nILNestedExportedType.Name \nName \nILNestedExportedType.Access \nAccess \nILNestedExportedType.Nested \nNested \nILNestedExportedType.CustomAttrsStored \nCustomAttrsStored \nILNestedExportedType.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html#CustomAttrs","title":"ILNestedExportedType.CustomAttrs","content":"ILNestedExportedType.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html#Name","title":"ILNestedExportedType.Name","content":"ILNestedExportedType.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html#Access","title":"ILNestedExportedType.Access","content":"ILNestedExportedType.Access \nAccess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html#Nested","title":"ILNestedExportedType.Nested","content":"ILNestedExportedType.Nested \nNested \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html#CustomAttrsStored","title":"ILNestedExportedType.CustomAttrsStored","content":"ILNestedExportedType.CustomAttrsStored \nCustomAttrsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html#MetadataIndex","title":"ILNestedExportedType.MetadataIndex","content":"ILNestedExportedType.MetadataIndex \nMetadataIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilnestedexportedtypes.html","title":"ILNestedExportedTypes","content":"ILNestedExportedTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html","title":"ILParameter","content":"ILParameter \n Method parameters and return values. \nILParameter.CustomAttrs \nCustomAttrs \nILParameter.Name \nName \nILParameter.Type \nType \nILParameter.Default \nDefault \nILParameter.Marshal \nMarshal \nILParameter.IsIn \nIsIn \nILParameter.IsOut \nIsOut \nILParameter.IsOptional \nIsOptional \nILParameter.CustomAttrsStored \nCustomAttrsStored \nILParameter.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#CustomAttrs","title":"ILParameter.CustomAttrs","content":"ILParameter.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#Name","title":"ILParameter.Name","content":"ILParameter.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#Type","title":"ILParameter.Type","content":"ILParameter.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#Default","title":"ILParameter.Default","content":"ILParameter.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#Marshal","title":"ILParameter.Marshal","content":"ILParameter.Marshal \nMarshal \n Marshalling map for parameters. COM Interop only.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#IsIn","title":"ILParameter.IsIn","content":"ILParameter.IsIn \nIsIn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#IsOut","title":"ILParameter.IsOut","content":"ILParameter.IsOut \nIsOut \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#IsOptional","title":"ILParameter.IsOptional","content":"ILParameter.IsOptional \nIsOptional \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#CustomAttrsStored","title":"ILParameter.CustomAttrsStored","content":"ILParameter.CustomAttrsStored \nCustomAttrsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilparameter.html#MetadataIndex","title":"ILParameter.MetadataIndex","content":"ILParameter.MetadataIndex \nMetadataIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilplatform.html","title":"ILPlatform","content":"ILPlatform \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpretypedef.html","title":"ILPreTypeDef","content":"ILPreTypeDef \n Represents a prefix of information for ILTypeDef.\n\n The information is enough to perform name resolution for the F# compiler, probe attributes\n for ExtensionAttribute etc. This is key to the on-demand exploration of .NET metadata.\n This information has to be \u0022Goldilocks\u0022 - not too much, not too little, just right. \nILPreTypeDef.GetTypeDef \nGetTypeDef \nILPreTypeDef.Namespace \nNamespace \nILPreTypeDef.Name \nName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpretypedef.html#GetTypeDef","title":"ILPreTypeDef.GetTypeDef","content":"ILPreTypeDef.GetTypeDef \nGetTypeDef \n Realise the actual full typedef","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpretypedef.html#Namespace","title":"ILPreTypeDef.Namespace","content":"ILPreTypeDef.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpretypedef.html#Name","title":"ILPreTypeDef.Name","content":"ILPreTypeDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html","title":"ILPropertyDef","content":"ILPropertyDef \n Property definitions \nILPropertyDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nILPropertyDef.CustomAttrs \nCustomAttrs \nILPropertyDef.Attributes \nAttributes \nILPropertyDef.GetMethod \nGetMethod \nILPropertyDef.Init \nInit \nILPropertyDef.IsSpecialName \nIsSpecialName \nILPropertyDef.IsRTSpecialName \nIsRTSpecialName \nILPropertyDef.PropertyType \nPropertyType \nILPropertyDef.Name \nName \nILPropertyDef.CallingConv \nCallingConv \nILPropertyDef.SetMethod \nSetMethod \nILPropertyDef.Args \nArgs","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#\u0060\u0060.ctor\u0060\u0060","title":"ILPropertyDef.\u0060\u0060.ctor\u0060\u0060","content":"ILPropertyDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Functional creation of a value, immediate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#CustomAttrs","title":"ILPropertyDef.CustomAttrs","content":"ILPropertyDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#Attributes","title":"ILPropertyDef.Attributes","content":"ILPropertyDef.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#GetMethod","title":"ILPropertyDef.GetMethod","content":"ILPropertyDef.GetMethod \nGetMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#Init","title":"ILPropertyDef.Init","content":"ILPropertyDef.Init \nInit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#IsSpecialName","title":"ILPropertyDef.IsSpecialName","content":"ILPropertyDef.IsSpecialName \nIsSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#IsRTSpecialName","title":"ILPropertyDef.IsRTSpecialName","content":"ILPropertyDef.IsRTSpecialName \nIsRTSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#PropertyType","title":"ILPropertyDef.PropertyType","content":"ILPropertyDef.PropertyType \nPropertyType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#Name","title":"ILPropertyDef.Name","content":"ILPropertyDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#CallingConv","title":"ILPropertyDef.CallingConv","content":"ILPropertyDef.CallingConv \nCallingConv \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#SetMethod","title":"ILPropertyDef.SetMethod","content":"ILPropertyDef.SetMethod \nSetMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydef.html#Args","title":"ILPropertyDef.Args","content":"ILPropertyDef.Args \nArgs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilpropertydefs.html","title":"ILPropertyDefs","content":"ILPropertyDefs \n Table of properties in an IL type definition.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreferences.html","title":"ILReferences","content":"ILReferences \n \nILReferences.AssemblyReferences \nAssemblyReferences \nILReferences.ModuleReferences \nModuleReferences \nILReferences.TypeReferences \nTypeReferences \nILReferences.MethodReferences \nMethodReferences \nILReferences.FieldReferences \nFieldReferences","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreferences.html#AssemblyReferences","title":"ILReferences.AssemblyReferences","content":"ILReferences.AssemblyReferences \nAssemblyReferences \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreferences.html#ModuleReferences","title":"ILReferences.ModuleReferences","content":"ILReferences.ModuleReferences \nModuleReferences \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreferences.html#TypeReferences","title":"ILReferences.TypeReferences","content":"ILReferences.TypeReferences \nTypeReferences \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreferences.html#MethodReferences","title":"ILReferences.MethodReferences","content":"ILReferences.MethodReferences \nMethodReferences \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreferences.html#FieldReferences","title":"ILReferences.FieldReferences","content":"ILReferences.FieldReferences \nFieldReferences \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilresources.html","title":"ILResources","content":"ILResources \n Table of resources in a module.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html","title":"ILReturn","content":"ILReturn \n Method return values. \nILReturn.WithCustomAttrs \nWithCustomAttrs \nILReturn.CustomAttrs \nCustomAttrs \nILReturn.Marshal \nMarshal \nILReturn.Type \nType \nILReturn.CustomAttrsStored \nCustomAttrsStored \nILReturn.MetadataIndex \nMetadataIndex","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html#WithCustomAttrs","title":"ILReturn.WithCustomAttrs","content":"ILReturn.WithCustomAttrs \nWithCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html#CustomAttrs","title":"ILReturn.CustomAttrs","content":"ILReturn.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html#Marshal","title":"ILReturn.Marshal","content":"ILReturn.Marshal \nMarshal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html#Type","title":"ILReturn.Type","content":"ILReturn.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html#CustomAttrsStored","title":"ILReturn.CustomAttrsStored","content":"ILReturn.CustomAttrsStored \nCustomAttrsStored \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilreturn.html#MetadataIndex","title":"ILReturn.MetadataIndex","content":"ILReturn.MetadataIndex \nMetadataIndex \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html","title":"ILScopeRef","content":"ILScopeRef \n \nILScopeRef.QualifiedName \nQualifiedName \nILScopeRef.IsLocalRef \nIsLocalRef \nILScopeRef.Local \nLocal \nILScopeRef.Module \nModule \nILScopeRef.Assembly \nAssembly \nILScopeRef.PrimaryAssembly \nPrimaryAssembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html#QualifiedName","title":"ILScopeRef.QualifiedName","content":"ILScopeRef.QualifiedName \nQualifiedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html#IsLocalRef","title":"ILScopeRef.IsLocalRef","content":"ILScopeRef.IsLocalRef \nIsLocalRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html#Local","title":"ILScopeRef.Local","content":"ILScopeRef.Local \nLocal \n A reference to the type in the current module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html#Module","title":"ILScopeRef.Module","content":"ILScopeRef.Module \nModule \n A reference to a type in a module in the same assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html#Assembly","title":"ILScopeRef.Assembly","content":"ILScopeRef.Assembly \nAssembly \n A reference to a type in another assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilscoperef.html#PrimaryAssembly","title":"ILScopeRef.PrimaryAssembly","content":"ILScopeRef.PrimaryAssembly \nPrimaryAssembly \n A reference to a type in the primary assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsecuritydeclsstored.html","title":"ILSecurityDeclsStored","content":"ILSecurityDeclsStored \n Represents the efficiency-oriented storage of ILSecurityDecls in another item.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html","title":"ILSourceDocument","content":"ILSourceDocument \n Debug info. Values of type \u0022source\u0022 can be attached at sequence\n points and some other locations. \nILSourceDocument.Vendor \nVendor \nILSourceDocument.File \nFile \nILSourceDocument.DocumentType \nDocumentType \nILSourceDocument.Language \nLanguage \nILSourceDocument.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html#Vendor","title":"ILSourceDocument.Vendor","content":"ILSourceDocument.Vendor \nVendor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html#File","title":"ILSourceDocument.File","content":"ILSourceDocument.File \nFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html#DocumentType","title":"ILSourceDocument.DocumentType","content":"ILSourceDocument.DocumentType \nDocumentType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html#Language","title":"ILSourceDocument.Language","content":"ILSourceDocument.Language \nLanguage \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html#Create","title":"ILSourceDocument.Create","content":"ILSourceDocument.Create \nCreate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilthisconvention.html","title":"ILThisConvention","content":"ILThisConvention \n \nILThisConvention.Instance \nInstance \nILThisConvention.InstanceExplicit \nInstanceExplicit \nILThisConvention.Static \nStatic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilthisconvention.html#Instance","title":"ILThisConvention.Instance","content":"ILThisConvention.Instance \nInstance \n accepts an implicit \u0027this\u0027 pointer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilthisconvention.html#InstanceExplicit","title":"ILThisConvention.InstanceExplicit","content":"ILThisConvention.InstanceExplicit \nInstanceExplicit \n accepts an explicit \u0027this\u0027 pointer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilthisconvention.html#Static","title":"ILThisConvention.Static","content":"ILThisConvention.Static \nStatic \n no \u0027this\u0027 pointer is passed","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html","title":"ILType","content":"ILType \n \nILType.BasicQualifiedName \nBasicQualifiedName \nILType.QualifiedName \nQualifiedName \nILType.TypeSpec \nTypeSpec \nILType.IsTyvar \nIsTyvar \nILType.TypeRef \nTypeRef \nILType.GenericArgs \nGenericArgs \nILType.IsNominal \nIsNominal \nILType.Void \nVoid \nILType.Array \nArray \nILType.Value \nValue \nILType.Boxed \nBoxed \nILType.Ptr \nPtr \nILType.Byref \nByref \nILType.FunctionPointer \nFunctionPointer \nILType.TypeVar \nTypeVar \nILType.Modified \nModified","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#BasicQualifiedName","title":"ILType.BasicQualifiedName","content":"ILType.BasicQualifiedName \nBasicQualifiedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#QualifiedName","title":"ILType.QualifiedName","content":"ILType.QualifiedName \nQualifiedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#TypeSpec","title":"ILType.TypeSpec","content":"ILType.TypeSpec \nTypeSpec \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#IsTyvar","title":"ILType.IsTyvar","content":"ILType.IsTyvar \nIsTyvar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#TypeRef","title":"ILType.TypeRef","content":"ILType.TypeRef \nTypeRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#GenericArgs","title":"ILType.GenericArgs","content":"ILType.GenericArgs \nGenericArgs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#IsNominal","title":"ILType.IsNominal","content":"ILType.IsNominal \nIsNominal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Void","title":"ILType.Void","content":"ILType.Void \nVoid \n Used only in return and pointer types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Array","title":"ILType.Array","content":"ILType.Array \nArray \n Array types","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Value","title":"ILType.Value","content":"ILType.Value \nValue \n Unboxed types, including builtin types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Boxed","title":"ILType.Boxed","content":"ILType.Boxed \nBoxed \n Reference types. Also may be used for parents of members even if for members in value types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Ptr","title":"ILType.Ptr","content":"ILType.Ptr \nPtr \n Unmanaged pointers. Nb. the type is used by tools and for binding only, not by the verifier.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Byref","title":"ILType.Byref","content":"ILType.Byref \nByref \n Managed pointers.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#FunctionPointer","title":"ILType.FunctionPointer","content":"ILType.FunctionPointer \nFunctionPointer \n ILCode pointers.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#TypeVar","title":"ILType.TypeVar","content":"ILType.TypeVar \nTypeVar \n Reference a generic arg.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltype.html#Modified","title":"ILType.Modified","content":"ILType.Modified \nModified \n Custom modifiers.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html","title":"ILTypeDef","content":"ILTypeDef \n Represents IL Type Definitions. \nILTypeDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nILTypeDef.With \nWith \nILTypeDef.IsClass \nIsClass \nILTypeDef.CustomAttrs \nCustomAttrs \nILTypeDef.Implements \nImplements \nILTypeDef.SecurityDecls \nSecurityDecls \nILTypeDef.IsStruct \nIsStruct \nILTypeDef.Attributes \nAttributes \nILTypeDef.NestedTypes \nNestedTypes \nILTypeDef.Methods \nMethods \nILTypeDef.Extends \nExtends \nILTypeDef.Fields \nFields \nILTypeDef.Layout \nLayout \nILTypeDef.IsSpecialName \nIsSpecialName \nILTypeDef.IsSerializable \nIsSerializable \nILTypeDef.Access \nAccess \nILTypeDef.Events \nEvents \nILTypeDef.Encoding \nEncoding \nILTypeDef.Properties \nProperties \nILTypeDef.IsStructOrEnum \nIsStructOrEnum \nILTypeDef.IsAbstract \nIsAbstract \nILTypeDef.IsEnum \nIsEnum \nILTypeDef.Name \nName \nILTypeDef.HasSecurity \nHasSecurity \nILTypeDef.IsInterface \nIsInterface \nILTypeDef.IsKnownToBeAttribute \nIsKnownToBeAttribute \nILTypeDef.IsSealed \nIsSealed \nILTypeDef.IsDelegate \nIsDelegate \nILTypeDef.GenericParams \nGenericParams \nILTypeDef.IsComInterop \nIsComInterop \nILTypeDef.MethodImpls \nMethodImpls","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#\u0060\u0060.ctor\u0060\u0060","title":"ILTypeDef.\u0060\u0060.ctor\u0060\u0060","content":"ILTypeDef.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Functional creation of a value, immediate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#With","title":"ILTypeDef.With","content":"ILTypeDef.With \nWith \n Functional update","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsClass","title":"ILTypeDef.IsClass","content":"ILTypeDef.IsClass \nIsClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#CustomAttrs","title":"ILTypeDef.CustomAttrs","content":"ILTypeDef.CustomAttrs \nCustomAttrs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Implements","title":"ILTypeDef.Implements","content":"ILTypeDef.Implements \nImplements \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#SecurityDecls","title":"ILTypeDef.SecurityDecls","content":"ILTypeDef.SecurityDecls \nSecurityDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsStruct","title":"ILTypeDef.IsStruct","content":"ILTypeDef.IsStruct \nIsStruct \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Attributes","title":"ILTypeDef.Attributes","content":"ILTypeDef.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#NestedTypes","title":"ILTypeDef.NestedTypes","content":"ILTypeDef.NestedTypes \nNestedTypes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Methods","title":"ILTypeDef.Methods","content":"ILTypeDef.Methods \nMethods \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Extends","title":"ILTypeDef.Extends","content":"ILTypeDef.Extends \nExtends \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Fields","title":"ILTypeDef.Fields","content":"ILTypeDef.Fields \nFields \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Layout","title":"ILTypeDef.Layout","content":"ILTypeDef.Layout \nLayout \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsSpecialName","title":"ILTypeDef.IsSpecialName","content":"ILTypeDef.IsSpecialName \nIsSpecialName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsSerializable","title":"ILTypeDef.IsSerializable","content":"ILTypeDef.IsSerializable \nIsSerializable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Access","title":"ILTypeDef.Access","content":"ILTypeDef.Access \nAccess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Events","title":"ILTypeDef.Events","content":"ILTypeDef.Events \nEvents \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Encoding","title":"ILTypeDef.Encoding","content":"ILTypeDef.Encoding \nEncoding \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Properties","title":"ILTypeDef.Properties","content":"ILTypeDef.Properties \nProperties \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsStructOrEnum","title":"ILTypeDef.IsStructOrEnum","content":"ILTypeDef.IsStructOrEnum \nIsStructOrEnum \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsAbstract","title":"ILTypeDef.IsAbstract","content":"ILTypeDef.IsAbstract \nIsAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsEnum","title":"ILTypeDef.IsEnum","content":"ILTypeDef.IsEnum \nIsEnum \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#Name","title":"ILTypeDef.Name","content":"ILTypeDef.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#HasSecurity","title":"ILTypeDef.HasSecurity","content":"ILTypeDef.HasSecurity \nHasSecurity \n Some classes are marked \u0022HasSecurity\u0022 even if there are no permissions attached,\n e.g. if they use SuppressUnmanagedCodeSecurityAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsInterface","title":"ILTypeDef.IsInterface","content":"ILTypeDef.IsInterface \nIsInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsKnownToBeAttribute","title":"ILTypeDef.IsKnownToBeAttribute","content":"ILTypeDef.IsKnownToBeAttribute \nIsKnownToBeAttribute \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsSealed","title":"ILTypeDef.IsSealed","content":"ILTypeDef.IsSealed \nIsSealed \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsDelegate","title":"ILTypeDef.IsDelegate","content":"ILTypeDef.IsDelegate \nIsDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#GenericParams","title":"ILTypeDef.GenericParams","content":"ILTypeDef.GenericParams \nGenericParams \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#IsComInterop","title":"ILTypeDef.IsComInterop","content":"ILTypeDef.IsComInterop \nIsComInterop \n Class or interface generated for COM interop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedef.html#MethodImpls","title":"ILTypeDef.MethodImpls","content":"ILTypeDef.MethodImpls \nMethodImpls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html","title":"ILTypeDefAccess","content":"ILTypeDefAccess \n Type Access. \nILTypeDefAccess.Public \nPublic \nILTypeDefAccess.Private \nPrivate \nILTypeDefAccess.Nested \nNested","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html#Public","title":"ILTypeDefAccess.Public","content":"ILTypeDefAccess.Public \nPublic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html#Private","title":"ILTypeDefAccess.Private","content":"ILTypeDefAccess.Private \nPrivate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html#Nested","title":"ILTypeDefAccess.Nested","content":"ILTypeDefAccess.Nested \nNested \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefkind.html","title":"ILTypeDefKind","content":"ILTypeDefKind \n A categorization of type definitions into \u0022kinds\u0022 \nILTypeDefKind.Class \nClass \nILTypeDefKind.ValueType \nValueType \nILTypeDefKind.Interface \nInterface \nILTypeDefKind.Enum \nEnum \nILTypeDefKind.Delegate \nDelegate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefkind.html#Class","title":"ILTypeDefKind.Class","content":"ILTypeDefKind.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefkind.html#ValueType","title":"ILTypeDefKind.ValueType","content":"ILTypeDefKind.ValueType \nValueType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefkind.html#Interface","title":"ILTypeDefKind.Interface","content":"ILTypeDefKind.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefkind.html#Enum","title":"ILTypeDefKind.Enum","content":"ILTypeDefKind.Enum \nEnum \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefkind.html#Delegate","title":"ILTypeDefKind.Delegate","content":"ILTypeDefKind.Delegate \nDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html","title":"ILTypeDefLayout","content":"ILTypeDefLayout \n Type Layout information. \nILTypeDefLayout.Auto \nAuto \nILTypeDefLayout.Sequential \nSequential \nILTypeDefLayout.Explicit \nExplicit","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html#Auto","title":"ILTypeDefLayout.Auto","content":"ILTypeDefLayout.Auto \nAuto \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html#Sequential","title":"ILTypeDefLayout.Sequential","content":"ILTypeDefLayout.Sequential \nSequential \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html#Explicit","title":"ILTypeDefLayout.Explicit","content":"ILTypeDefLayout.Explicit \nExplicit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypedefs.html","title":"ILTypeDefs","content":"ILTypeDefs \n Tables of named type definitions.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypeinit.html","title":"ILTypeInit","content":"ILTypeInit \n Indicate the initialization semantics of a type. \nILTypeInit.BeforeField \nBeforeField \nILTypeInit.OnAny \nOnAny","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypeinit.html#BeforeField","title":"ILTypeInit.BeforeField","content":"ILTypeInit.BeforeField \nBeforeField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypeinit.html#OnAny","title":"ILTypeInit.OnAny","content":"ILTypeInit.OnAny \nOnAny \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html","title":"ILTypeRef","content":"ILTypeRef \n Type refs, i.e. references to types in some .NET assembly \nILTypeRef.BasicQualifiedName \nBasicQualifiedName \nILTypeRef.QualifiedName \nQualifiedName \nILTypeRef.FullName \nFullName \nILTypeRef.Name \nName \nILTypeRef.Scope \nScope \nILTypeRef.Enclosing \nEnclosing \nILTypeRef.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#BasicQualifiedName","title":"ILTypeRef.BasicQualifiedName","content":"ILTypeRef.BasicQualifiedName \nBasicQualifiedName \n The name of the type in the assembly using the \u0027\u002B\u0027 notation for nested types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#QualifiedName","title":"ILTypeRef.QualifiedName","content":"ILTypeRef.QualifiedName \nQualifiedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#FullName","title":"ILTypeRef.FullName","content":"ILTypeRef.FullName \nFullName \n The name of the type in the assembly using the \u0027.\u0027 notation for nested types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#Name","title":"ILTypeRef.Name","content":"ILTypeRef.Name \nName \n The name of the type. This also contains the namespace if Enclosing is empty.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#Scope","title":"ILTypeRef.Scope","content":"ILTypeRef.Scope \nScope \n Where is the type, i.e. is it in this module, in another module in this assembly or in another assembly?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#Enclosing","title":"ILTypeRef.Enclosing","content":"ILTypeRef.Enclosing \nEnclosing \n The list of enclosing type names for a nested type. If non-nil then the first of these also contains the namespace.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltyperef.html#Create","title":"ILTypeRef.Create","content":"ILTypeRef.Create \nCreate \n Create a ILTypeRef.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html","title":"ILTypeSpec","content":"ILTypeSpec \n Type specs and types. \nILTypeSpec.FullName \nFullName \nILTypeSpec.TypeRef \nTypeRef \nILTypeSpec.Name \nName \nILTypeSpec.GenericArgs \nGenericArgs \nILTypeSpec.Scope \nScope \nILTypeSpec.Enclosing \nEnclosing \nILTypeSpec.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#FullName","title":"ILTypeSpec.FullName","content":"ILTypeSpec.FullName \nFullName \n The name of the type in the assembly using the \u0027.\u0027 notation for nested types.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#TypeRef","title":"ILTypeSpec.TypeRef","content":"ILTypeSpec.TypeRef \nTypeRef \n Which type is being referred to?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#Name","title":"ILTypeSpec.Name","content":"ILTypeSpec.Name \nName \n The name of the type. This also contains the namespace if Enclosing is empty.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#GenericArgs","title":"ILTypeSpec.GenericArgs","content":"ILTypeSpec.GenericArgs \nGenericArgs \n The type instantiation if the type is generic, otherwise empty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#Scope","title":"ILTypeSpec.Scope","content":"ILTypeSpec.Scope \nScope \n Where is the type, i.e. is it in this module, in another module in this assembly or in another assembly?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#Enclosing","title":"ILTypeSpec.Enclosing","content":"ILTypeSpec.Enclosing \nEnclosing \n The list of enclosing type names for a nested type. If non-nil then the first of these also contains the namespace.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-iltypespec.html#Create","title":"ILTypeSpec.Create","content":"ILTypeSpec.Create \nCreate \n Create an ILTypeSpec.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilversioninfo.html","title":"ILVersionInfo","content":"ILVersionInfo \n \nILVersionInfo.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nILVersionInfo.Major \nMajor \nILVersionInfo.Minor \nMinor \nILVersionInfo.Build \nBuild \nILVersionInfo.Revision \nRevision","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilversioninfo.html#\u0060\u0060.ctor\u0060\u0060","title":"ILVersionInfo.\u0060\u0060.ctor\u0060\u0060","content":"ILVersionInfo.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilversioninfo.html#Major","title":"ILVersionInfo.Major","content":"ILVersionInfo.Major \nMajor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilversioninfo.html#Minor","title":"ILVersionInfo.Minor","content":"ILVersionInfo.Minor \nMinor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilversioninfo.html#Build","title":"ILVersionInfo.Build","content":"ILVersionInfo.Build \nBuild \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-ilversioninfo.html#Revision","title":"ILVersionInfo.Revision","content":"ILVersionInfo.Revision \nRevision \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-methodbody.html","title":"MethodBody","content":"MethodBody \n \nMethodBody.IL \nIL \nMethodBody.PInvoke \nPInvoke \nMethodBody.Abstract \nAbstract \nMethodBody.Native \nNative \nMethodBody.NotAvailable \nNotAvailable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-methodbody.html#IL","title":"MethodBody.IL","content":"MethodBody.IL \nIL \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-methodbody.html#PInvoke","title":"MethodBody.PInvoke","content":"MethodBody.PInvoke \nPInvoke \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-methodbody.html#Abstract","title":"MethodBody.Abstract","content":"MethodBody.Abstract \nAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-methodbody.html#Native","title":"MethodBody.Native","content":"MethodBody.Native \nNative \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-methodbody.html#NotAvailable","title":"MethodBody.NotAvailable","content":"MethodBody.NotAvailable \nNotAvailable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html","title":"PublicKey","content":"PublicKey \n \nPublicKey.Key \nKey \nPublicKey.IsKey \nIsKey \nPublicKey.IsKeyToken \nIsKeyToken \nPublicKey.KeyToken \nKeyToken \nPublicKey.KeyAsToken \nKeyAsToken \nPublicKey.PublicKey \nPublicKey \nPublicKey.PublicKeyToken \nPublicKeyToken","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#Key","title":"PublicKey.Key","content":"PublicKey.Key \nKey \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#IsKey","title":"PublicKey.IsKey","content":"PublicKey.IsKey \nIsKey \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#IsKeyToken","title":"PublicKey.IsKeyToken","content":"PublicKey.IsKeyToken \nIsKeyToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#KeyToken","title":"PublicKey.KeyToken","content":"PublicKey.KeyToken \nKeyToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#KeyAsToken","title":"PublicKey.KeyAsToken","content":"PublicKey.KeyAsToken \nKeyAsToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#PublicKey","title":"PublicKey.PublicKey","content":"PublicKey.PublicKey \nPublicKey \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-il-publickey.html#PublicKeyToken","title":"PublicKey.PublicKeyToken","content":"PublicKey.PublicKeyToken \nPublicKeyToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader.html","title":"ILBinaryReader","content":"ILBinaryReader \n\u003Cpre\u003E Binary reader. Read a .NET binary and concert it to Abstract IL data\n structures.\n \n NOTE:\n - The metadata in the loaded modules will be relative to \n those modules, e.g. ILScopeRef.Local will mean \u0022local to \n that module\u0022. You must use [rescopeILType] etc. if you want to include \n (i.e. copy) the metadata into your own module. \n\n - PDB (debug info) reading/folding:\n The PDB reader is invoked if you give a PDB path \n This indicates if you want to search for PDB files and have the \n reader fold them in. You cannot currently name the pdb file \n directly - you can only name the path. Giving \u0022None\u0022 says \n \u0022do not read the PDB file even if one exists\u0022. \n \n The debug info appears primarily as I_seqpoint annotations in \n the instruction streams. Unfortunately the PDB information does\n not, for example, tell you how to map back from a class definition\n to a source code line number - you will need to explicitly search\n for a sequence point in the code for one of the methods of the \n class. That is not particularly satisfactory, and it may be\n a good idea to build a small library which extracts the information\n you need.\u003C/pre\u003E \nILBinaryReader.Shim \nShim \nILBinaryReader.ILModuleReader \nILModuleReader \nILBinaryReader.ILReaderOptions \nILReaderOptions \nILBinaryReader.ILReaderTryGetMetadataSnapshot \nILReaderTryGetMetadataSnapshot \nILBinaryReader.MetadataOnlyFlag \nMetadataOnlyFlag \nILBinaryReader.ReduceMemoryFlag \nReduceMemoryFlag","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-shim.html","title":"Shim","content":"Shim \n The public API hook for changing the IL assembly reader, used by Resharper \nShim.IAssemblyReader \nIAssemblyReader \nShim.AssemblyReader \nAssemblyReader","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-shim.html#AssemblyReader","title":"Shim.AssemblyReader","content":"Shim.AssemblyReader \nAssemblyReader \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-shim-iassemblyreader.html","title":"IAssemblyReader","content":"IAssemblyReader \n \nIAssemblyReader.GetILModuleReader \nGetILModuleReader","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-shim-iassemblyreader.html#GetILModuleReader","title":"IAssemblyReader.GetILModuleReader","content":"IAssemblyReader.GetILModuleReader \nGetILModuleReader \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilmodulereader.html","title":"ILModuleReader","content":"ILModuleReader \n Represents a reader of the metadata of a .NET binary. May also give some values (e.g. IL code) from the PE file\n if it was provided. \nILModuleReader.ILModuleDef \nILModuleDef \nILModuleReader.ILAssemblyRefs \nILAssemblyRefs","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilmodulereader.html#ILModuleDef","title":"ILModuleReader.ILModuleDef","content":"ILModuleReader.ILModuleDef \nILModuleDef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilmodulereader.html#ILAssemblyRefs","title":"ILModuleReader.ILAssemblyRefs","content":"ILModuleReader.ILAssemblyRefs \nILAssemblyRefs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html","title":"ILReaderOptions","content":"ILReaderOptions \n \nILReaderOptions.pdbDirPath \npdbDirPath \nILReaderOptions.reduceMemoryUsage \nreduceMemoryUsage \nILReaderOptions.metadataOnly \nmetadataOnly \nILReaderOptions.tryGetMetadataSnapshot \ntryGetMetadataSnapshot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html#pdbDirPath","title":"ILReaderOptions.pdbDirPath","content":"ILReaderOptions.pdbDirPath \npdbDirPath \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html#reduceMemoryUsage","title":"ILReaderOptions.reduceMemoryUsage","content":"ILReaderOptions.reduceMemoryUsage \nreduceMemoryUsage \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html#metadataOnly","title":"ILReaderOptions.metadataOnly","content":"ILReaderOptions.metadataOnly \nmetadataOnly \n Only open a metadata reader for the metadata portion of the .NET binary without keeping alive any data associated with the PE reader\n - IL code will not be available (mdBody in ILMethodDef will return NotAvailable)\n - Managed resources will be reported back as ILResourceLocation.LocalIn (as always)\n - Native resources will not be available (none will be returned)\n - Static data associated with fields will not be available","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html#tryGetMetadataSnapshot","title":"ILReaderOptions.tryGetMetadataSnapshot","content":"ILReaderOptions.tryGetMetadataSnapshot \ntryGetMetadataSnapshot \n A function to call to try to get an object that acts as a snapshot of the metadata section of a .NET binary,\n and from which we can read the metadata. Only used when metadataOnly=true.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreadertrygetmetadatasnapshot.html","title":"ILReaderTryGetMetadataSnapshot","content":"ILReaderTryGetMetadataSnapshot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-metadataonlyflag.html","title":"MetadataOnlyFlag","content":"MetadataOnlyFlag \n \nMetadataOnlyFlag.Yes \nYes \nMetadataOnlyFlag.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-metadataonlyflag.html#Yes","title":"MetadataOnlyFlag.Yes","content":"MetadataOnlyFlag.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-metadataonlyflag.html#No","title":"MetadataOnlyFlag.No","content":"MetadataOnlyFlag.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-reducememoryflag.html","title":"ReduceMemoryFlag","content":"ReduceMemoryFlag \n \nReduceMemoryFlag.Yes \nYes \nReduceMemoryFlag.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-reducememoryflag.html#Yes","title":"ReduceMemoryFlag.Yes","content":"ReduceMemoryFlag.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-abstractil-ilbinaryreader-reducememoryflag.html#No","title":"ReduceMemoryFlag.No","content":"ReduceMemoryFlag.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-delayedilmodulereader.html","title":"DelayedILModuleReader","content":"DelayedILModuleReader \n Delays the creation of an ILModuleReader \nDelayedILModuleReader.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDelayedILModuleReader.OutputFile \nOutputFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-delayedilmodulereader.html#\u0060\u0060.ctor\u0060\u0060","title":"DelayedILModuleReader.\u0060\u0060.ctor\u0060\u0060","content":"DelayedILModuleReader.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-delayedilmodulereader.html#OutputFile","title":"DelayedILModuleReader.OutputFile","content":"DelayedILModuleReader.OutputFile \nOutputFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-documentsource.html","title":"DocumentSource","content":"DocumentSource \n \nDocumentSource.FileSystem \nFileSystem \nDocumentSource.Custom \nCustom","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-documentsource.html#FileSystem","title":"DocumentSource.FileSystem","content":"DocumentSource.FileSystem \nFileSystem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-documentsource.html#Custom","title":"DocumentSource.Custom","content":"DocumentSource.Custom \nCustom \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileanswer.html","title":"FSharpCheckFileAnswer","content":"FSharpCheckFileAnswer \n The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. \nFSharpCheckFileAnswer.Aborted \nAborted \nFSharpCheckFileAnswer.Succeeded \nSucceeded","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileanswer.html#Aborted","title":"FSharpCheckFileAnswer.Aborted","content":"FSharpCheckFileAnswer.Aborted \nAborted \n Aborted because cancellation caused an abandonment of the operation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileanswer.html#Succeeded","title":"FSharpCheckFileAnswer.Succeeded","content":"FSharpCheckFileAnswer.Succeeded \nSucceeded \n Success","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html","title":"FSharpCheckFileResults","content":"FSharpCheckFileResults \n A handle to the results of CheckFileInProject. \nFSharpCheckFileResults.GenerateSignature \nGenerateSignature \nFSharpCheckFileResults.GetAllUsesOfAllSymbolsInFile \nGetAllUsesOfAllSymbolsInFile \nFSharpCheckFileResults.GetDeclarationListInfo \nGetDeclarationListInfo \nFSharpCheckFileResults.GetDeclarationListSymbols \nGetDeclarationListSymbols \nFSharpCheckFileResults.GetDeclarationLocation \nGetDeclarationLocation \nFSharpCheckFileResults.GetDescription \nGetDescription \nFSharpCheckFileResults.GetDisplayContextForPos \nGetDisplayContextForPos \nFSharpCheckFileResults.GetF1Keyword \nGetF1Keyword \nFSharpCheckFileResults.GetFormatSpecifierLocations \nGetFormatSpecifierLocations \nFSharpCheckFileResults.GetFormatSpecifierLocationsAndArity \nGetFormatSpecifierLocationsAndArity \nFSharpCheckFileResults.GetKeywordTooltip \nGetKeywordTooltip \nFSharpCheckFileResults.GetMethods \nGetMethods \nFSharpCheckFileResults.GetMethodsAsSymbols \nGetMethodsAsSymbols \nFSharpCheckFileResults.GetSemanticClassification \nGetSemanticClassification \nFSharpCheckFileResults.GetSymbolUseAtLocation \nGetSymbolUseAtLocation \nFSharpCheckFileResults.GetSymbolUsesAtLocation \nGetSymbolUsesAtLocation \nFSharpCheckFileResults.GetToolTip \nGetToolTip \nFSharpCheckFileResults.GetUsesOfSymbolInFile \nGetUsesOfSymbolInFile \nFSharpCheckFileResults.IsRelativeNameResolvableFromSymbol \nIsRelativeNameResolvableFromSymbol \nFSharpCheckFileResults.OpenDeclarations \nOpenDeclarations \nFSharpCheckFileResults.Diagnostics \nDiagnostics \nFSharpCheckFileResults.DependencyFiles \nDependencyFiles \nFSharpCheckFileResults.HasFullTypeCheckInfo \nHasFullTypeCheckInfo \nFSharpCheckFileResults.ProjectContext \nProjectContext \nFSharpCheckFileResults.ImplementationFile \nImplementationFile \nFSharpCheckFileResults.PartialAssemblySignature \nPartialAssemblySignature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GenerateSignature","title":"FSharpCheckFileResults.GenerateSignature","content":"FSharpCheckFileResults.GenerateSignature \nGenerateSignature \n Lays out and returns the formatted signature for the typechecked file as source text.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetAllUsesOfAllSymbolsInFile","title":"FSharpCheckFileResults.GetAllUsesOfAllSymbolsInFile","content":"FSharpCheckFileResults.GetAllUsesOfAllSymbolsInFile \nGetAllUsesOfAllSymbolsInFile \n Get all textual usages of all symbols throughout the file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetDeclarationListInfo","title":"FSharpCheckFileResults.GetDeclarationListInfo","content":"FSharpCheckFileResults.GetDeclarationListInfo \nGetDeclarationListInfo \nGet the items for a declaration list","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetDeclarationListSymbols","title":"FSharpCheckFileResults.GetDeclarationListSymbols","content":"FSharpCheckFileResults.GetDeclarationListSymbols \nGetDeclarationListSymbols \nGet the items for a declaration list in FSharpSymbol format","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetDeclarationLocation","title":"FSharpCheckFileResults.GetDeclarationLocation","content":"FSharpCheckFileResults.GetDeclarationLocation \nGetDeclarationLocation \nResolve the names at the given location to the declaration location of the corresponding construct.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetDescription","title":"FSharpCheckFileResults.GetDescription","content":"FSharpCheckFileResults.GetDescription \nGetDescription \nCompute a formatted tooltip for the given symbol at position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetDisplayContextForPos","title":"FSharpCheckFileResults.GetDisplayContextForPos","content":"FSharpCheckFileResults.GetDisplayContextForPos \nGetDisplayContextForPos \n Find the most precise display environment for the given line and column.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetF1Keyword","title":"FSharpCheckFileResults.GetF1Keyword","content":"FSharpCheckFileResults.GetF1Keyword \nGetF1Keyword \nCompute the Visual Studio F1-help key identifier for the given location, based on name resolution results","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetFormatSpecifierLocations","title":"FSharpCheckFileResults.GetFormatSpecifierLocations","content":"FSharpCheckFileResults.GetFormatSpecifierLocations \nGetFormatSpecifierLocations \nGet the locations of format specifiers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetFormatSpecifierLocationsAndArity","title":"FSharpCheckFileResults.GetFormatSpecifierLocationsAndArity","content":"FSharpCheckFileResults.GetFormatSpecifierLocationsAndArity \nGetFormatSpecifierLocationsAndArity \nGet the locations of and number of arguments associated with format specifiers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetKeywordTooltip","title":"FSharpCheckFileResults.GetKeywordTooltip","content":"FSharpCheckFileResults.GetKeywordTooltip \nGetKeywordTooltip \nCompute a formatted tooltip for the given keywords","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetMethods","title":"FSharpCheckFileResults.GetMethods","content":"FSharpCheckFileResults.GetMethods \nGetMethods \nCompute a set of method overloads to show in a dialog relevant to the given code location.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetMethodsAsSymbols","title":"FSharpCheckFileResults.GetMethodsAsSymbols","content":"FSharpCheckFileResults.GetMethodsAsSymbols \nGetMethodsAsSymbols \nCompute a set of method overloads to show in a dialog relevant to the given code location. The resulting method overloads are returned as symbols.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetSemanticClassification","title":"FSharpCheckFileResults.GetSemanticClassification","content":"FSharpCheckFileResults.GetSemanticClassification \nGetSemanticClassification \nGet any extra colorization info that is available after the typecheck","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetSymbolUseAtLocation","title":"FSharpCheckFileResults.GetSymbolUseAtLocation","content":"FSharpCheckFileResults.GetSymbolUseAtLocation \nGetSymbolUseAtLocation \nResolve the names at the given location to a use of symbol.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetSymbolUsesAtLocation","title":"FSharpCheckFileResults.GetSymbolUsesAtLocation","content":"FSharpCheckFileResults.GetSymbolUsesAtLocation \nGetSymbolUsesAtLocation \nSimilar to GetSymbolUseAtLocation, but returns all found symbols if there are multiple.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetToolTip","title":"FSharpCheckFileResults.GetToolTip","content":"FSharpCheckFileResults.GetToolTip \nGetToolTip \nCompute a formatted tooltip for the given location","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#GetUsesOfSymbolInFile","title":"FSharpCheckFileResults.GetUsesOfSymbolInFile","content":"FSharpCheckFileResults.GetUsesOfSymbolInFile \nGetUsesOfSymbolInFile \n Get the textual usages that resolved to the given symbol throughout the file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#IsRelativeNameResolvableFromSymbol","title":"FSharpCheckFileResults.IsRelativeNameResolvableFromSymbol","content":"FSharpCheckFileResults.IsRelativeNameResolvableFromSymbol \nIsRelativeNameResolvableFromSymbol \n Determines if a long ident is resolvable at a specific point.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#OpenDeclarations","title":"FSharpCheckFileResults.OpenDeclarations","content":"FSharpCheckFileResults.OpenDeclarations \nOpenDeclarations \n Open declarations in the file, including auto open modules.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#Diagnostics","title":"FSharpCheckFileResults.Diagnostics","content":"FSharpCheckFileResults.Diagnostics \nDiagnostics \n The errors returned by parsing a source file.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#DependencyFiles","title":"FSharpCheckFileResults.DependencyFiles","content":"FSharpCheckFileResults.DependencyFiles \nDependencyFiles \n Indicates the set of files which must be watched to accurately track changes that affect these results,\n Clients interested in reacting to updates to these files should watch these files and take actions as described\n in the documentation for compiler service.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#HasFullTypeCheckInfo","title":"FSharpCheckFileResults.HasFullTypeCheckInfo","content":"FSharpCheckFileResults.HasFullTypeCheckInfo \nHasFullTypeCheckInfo \n Indicates whether type checking successfully occurred with some results returned. If false, indicates that\n an unrecoverable error in earlier checking/parsing/resolution steps.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#ProjectContext","title":"FSharpCheckFileResults.ProjectContext","content":"FSharpCheckFileResults.ProjectContext \nProjectContext \n Get the resolution of the ProjectOptions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#ImplementationFile","title":"FSharpCheckFileResults.ImplementationFile","content":"FSharpCheckFileResults.ImplementationFile \nImplementationFile \n Represents complete typechecked implementation file, including its typechecked signatures if any.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html#PartialAssemblySignature","title":"FSharpCheckFileResults.PartialAssemblySignature","content":"FSharpCheckFileResults.PartialAssemblySignature \nPartialAssemblySignature \n Get a view of the contents of the assembly up to and including the file just checked","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html","title":"FSharpCheckProjectResults","content":"FSharpCheckProjectResults \n A handle to the results of CheckFileInProject. \nFSharpCheckProjectResults.GetAllUsesOfAllSymbols \nGetAllUsesOfAllSymbols \nFSharpCheckProjectResults.GetOptimizedAssemblyContents \nGetOptimizedAssemblyContents \nFSharpCheckProjectResults.GetUsesOfSymbol \nGetUsesOfSymbol \nFSharpCheckProjectResults.AssemblyContents \nAssemblyContents \nFSharpCheckProjectResults.Diagnostics \nDiagnostics \nFSharpCheckProjectResults.DependencyFiles \nDependencyFiles \nFSharpCheckProjectResults.AssemblySignature \nAssemblySignature \nFSharpCheckProjectResults.ProjectContext \nProjectContext \nFSharpCheckProjectResults.HasCriticalErrors \nHasCriticalErrors","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#GetAllUsesOfAllSymbols","title":"FSharpCheckProjectResults.GetAllUsesOfAllSymbols","content":"FSharpCheckProjectResults.GetAllUsesOfAllSymbols \nGetAllUsesOfAllSymbols \n Get all textual usages of all symbols throughout the project","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#GetOptimizedAssemblyContents","title":"FSharpCheckProjectResults.GetOptimizedAssemblyContents","content":"FSharpCheckProjectResults.GetOptimizedAssemblyContents \nGetOptimizedAssemblyContents \n Get an optimized view of the overall contents of the assembly. Only valid to use if HasCriticalErrors is false.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#GetUsesOfSymbol","title":"FSharpCheckProjectResults.GetUsesOfSymbol","content":"FSharpCheckProjectResults.GetUsesOfSymbol \nGetUsesOfSymbol \n Get the textual usages that resolved to the given symbol throughout the project","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#AssemblyContents","title":"FSharpCheckProjectResults.AssemblyContents","content":"FSharpCheckProjectResults.AssemblyContents \nAssemblyContents \n Get a view of the overall contents of the assembly. Only valid to use if HasCriticalErrors is false.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#Diagnostics","title":"FSharpCheckProjectResults.Diagnostics","content":"FSharpCheckProjectResults.Diagnostics \nDiagnostics \n The errors returned by processing the project","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#DependencyFiles","title":"FSharpCheckProjectResults.DependencyFiles","content":"FSharpCheckProjectResults.DependencyFiles \nDependencyFiles \n Indicates the set of files which must be watched to accurately track changes that affect these results,\n Clients interested in reacting to updates to these files should watch these files and take actions as described\n in the documentation for compiler service.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#AssemblySignature","title":"FSharpCheckProjectResults.AssemblySignature","content":"FSharpCheckProjectResults.AssemblySignature \nAssemblySignature \n Get a view of the overall signature of the assembly. Only valid to use if HasCriticalErrors is false.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#ProjectContext","title":"FSharpCheckProjectResults.ProjectContext","content":"FSharpCheckProjectResults.ProjectContext \nProjectContext \n Get the resolution of the ProjectOptions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html#HasCriticalErrors","title":"FSharpCheckProjectResults.HasCriticalErrors","content":"FSharpCheckProjectResults.HasCriticalErrors \nHasCriticalErrors \n Indicates if critical errors existed in the project options","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html","title":"FSharpChecker","content":"FSharpChecker \n Used to parse and check F# source code. \nFSharpChecker.CheckFileInProject \nCheckFileInProject \nFSharpChecker.CheckFileInProjectAllowingStaleCachedResults \nCheckFileInProjectAllowingStaleCachedResults \nFSharpChecker.ClearCache \nClearCache \nFSharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients \nClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients \nFSharpChecker.Compile \nCompile \nFSharpChecker.FindBackgroundReferencesInFile \nFindBackgroundReferencesInFile \nFSharpChecker.GetBackgroundCheckResultsForFileInProject \nGetBackgroundCheckResultsForFileInProject \nFSharpChecker.GetBackgroundParseResultsForFileInProject \nGetBackgroundParseResultsForFileInProject \nFSharpChecker.GetBackgroundSemanticClassificationForFile \nGetBackgroundSemanticClassificationForFile \nFSharpChecker.GetParsingOptionsFromCommandLineArgs \nGetParsingOptionsFromCommandLineArgs \nFSharpChecker.GetParsingOptionsFromCommandLineArgs \nGetParsingOptionsFromCommandLineArgs \nFSharpChecker.GetParsingOptionsFromProjectOptions \nGetParsingOptionsFromProjectOptions \nFSharpChecker.GetProjectOptionsFromCommandLineArgs \nGetProjectOptionsFromCommandLineArgs \nFSharpChecker.GetProjectOptionsFromScript \nGetProjectOptionsFromScript \nFSharpChecker.InvalidateAll \nInvalidateAll \nFSharpChecker.InvalidateConfiguration \nInvalidateConfiguration \nFSharpChecker.MatchBraces \nMatchBraces \nFSharpChecker.MatchBraces \nMatchBraces \nFSharpChecker.NotifyFileChanged \nNotifyFileChanged \nFSharpChecker.NotifyProjectCleaned \nNotifyProjectCleaned \nFSharpChecker.ParseAndCheckFileInProject \nParseAndCheckFileInProject \nFSharpChecker.ParseAndCheckProject \nParseAndCheckProject \nFSharpChecker.ParseFile \nParseFile \nFSharpChecker.ParseFileInProject \nParseFileInProject \nFSharpChecker.TokenizeFile \nTokenizeFile \nFSharpChecker.TokenizeLine \nTokenizeLine \nFSharpChecker.TryGetRecentCheckResultsForFile \nTryGetRecentCheckResultsForFile \nFSharpChecker.FileChecked \nFileChecked \nFSharpChecker.ProjectChecked \nProjectChecked \nFSharpChecker.BeforeBackgroundFileCheck \nBeforeBackgroundFileCheck \nFSharpChecker.FileParsed \nFileParsed \nFSharpChecker.Create \nCreate \nFSharpChecker.ActualCheckFileCount \nActualCheckFileCount \nFSharpChecker.ActualParseFileCount \nActualParseFileCount \nFSharpChecker.Instance \nInstance","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#CheckFileInProject","title":"FSharpChecker.CheckFileInProject","content":"FSharpChecker.CheckFileInProject \nCheckFileInProject \n\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Check a source code file, returning a handle to the results\n \u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Note: all files except the one being checked are read from the FileSystem API\n \u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Return FSharpCheckFileAnswer.Aborted if a parse tree was not available.\n \u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#CheckFileInProjectAllowingStaleCachedResults","title":"FSharpChecker.CheckFileInProjectAllowingStaleCachedResults","content":"FSharpChecker.CheckFileInProjectAllowingStaleCachedResults \nCheckFileInProjectAllowingStaleCachedResults \n\u003Cp class=\u0027fsdocs-para\u0027\u003ECheck a source code file, returning a handle to the results of the parse including\n the reconstructed types in the file.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files except the one being checked are read from the FileSystem API\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003ENote: returns NoAntecedent if the background builder is not yet done preparing the type check context for the\n file (e.g. loading references and parsing/checking files in the project that this file depends upon).\n In this case, the caller can either retry, or wait for FileTypeCheckStateIsDirty to be raised for this file.\n \u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ClearCache","title":"FSharpChecker.ClearCache","content":"FSharpChecker.ClearCache \nClearCache \nClear the internal cache of the given projects.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients","title":"FSharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients","content":"FSharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients \nClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients \n Flush all caches and garbage collect","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#Compile","title":"FSharpChecker.Compile","content":"FSharpChecker.Compile \nCompile \n\n Compile using the given flags. Source files names are resolved via the FileSystem API.\n The output file must be given by a -o flag.\n The first argument is ignored and can just be \u0022fsc.exe\u0022.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#FindBackgroundReferencesInFile","title":"FSharpChecker.FindBackgroundReferencesInFile","content":"FSharpChecker.FindBackgroundReferencesInFile \nFindBackgroundReferencesInFile \n\u003Cp class=\u0027fsdocs-para\u0027\u003EOptimized find references for a given symbol in a file of project.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files are read from the FileSystem API, including the file being checked.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003ECan cause a second type-check when \u0060enablePartialTypeChecking\u0060 is true on the FSharpChecker.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetBackgroundCheckResultsForFileInProject","title":"FSharpChecker.GetBackgroundCheckResultsForFileInProject","content":"FSharpChecker.GetBackgroundCheckResultsForFileInProject \nGetBackgroundCheckResultsForFileInProject \n\u003Cp class=\u0027fsdocs-para\u0027\u003ELike CheckFileInProject, but uses the existing results from the background builder.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files are read from the FileSystem API, including the file being checked.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003ECan cause a second type-check when \u0060enablePartialTypeChecking\u0060 is true on the FSharpChecker.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetBackgroundParseResultsForFileInProject","title":"FSharpChecker.GetBackgroundParseResultsForFileInProject","content":"FSharpChecker.GetBackgroundParseResultsForFileInProject \nGetBackgroundParseResultsForFileInProject \n\u003Cp class=\u0027fsdocs-para\u0027\u003ELike ParseFile, but uses results from the background builder.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files are read from the FileSystem API, including the file being checked.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetBackgroundSemanticClassificationForFile","title":"FSharpChecker.GetBackgroundSemanticClassificationForFile","content":"FSharpChecker.GetBackgroundSemanticClassificationForFile \nGetBackgroundSemanticClassificationForFile \n\u003Cp class=\u0027fsdocs-para\u0027\u003EGet semantic classification for a file.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files are read from the FileSystem API, including the file being checked.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003ECan cause a second type-check when \u0060enablePartialTypeChecking\u0060 is true on the FSharpChecker.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetParsingOptionsFromCommandLineArgs","title":"FSharpChecker.GetParsingOptionsFromCommandLineArgs","content":"FSharpChecker.GetParsingOptionsFromCommandLineArgs \nGetParsingOptionsFromCommandLineArgs \n\u003Cp class=\u0027fsdocs-para\u0027\u003EGet the FSharpParsingOptions implied by a set of command line arguments.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetParsingOptionsFromCommandLineArgs","title":"FSharpChecker.GetParsingOptionsFromCommandLineArgs","content":"FSharpChecker.GetParsingOptionsFromCommandLineArgs \nGetParsingOptionsFromCommandLineArgs \n\u003Cp class=\u0027fsdocs-para\u0027\u003EGet the FSharpParsingOptions implied by a set of command line arguments and list of source files.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetParsingOptionsFromProjectOptions","title":"FSharpChecker.GetParsingOptionsFromProjectOptions","content":"FSharpChecker.GetParsingOptionsFromProjectOptions \nGetParsingOptionsFromProjectOptions \n\u003Cp class=\u0027fsdocs-para\u0027\u003EGet the FSharpParsingOptions implied by a FSharpProjectOptions.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetProjectOptionsFromCommandLineArgs","title":"FSharpChecker.GetProjectOptionsFromCommandLineArgs","content":"FSharpChecker.GetProjectOptionsFromCommandLineArgs \nGetProjectOptionsFromCommandLineArgs \nGet the FSharpProjectOptions implied by a set of command line arguments.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#GetProjectOptionsFromScript","title":"FSharpChecker.GetProjectOptionsFromScript","content":"FSharpChecker.GetProjectOptionsFromScript \nGetProjectOptionsFromScript \n\u003Cp class=\u0027fsdocs-para\u0027\u003EFor a given script file, get the FSharpProjectOptions implied by the #load closure.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files are read from the FileSystem API, except the file being checked.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#InvalidateAll","title":"FSharpChecker.InvalidateAll","content":"FSharpChecker.InvalidateAll \nInvalidateAll \n This function is called when the entire environment is known to have changed for reasons not encoded in the ProjectOptions of any project/compilation.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#InvalidateConfiguration","title":"FSharpChecker.InvalidateConfiguration","content":"FSharpChecker.InvalidateConfiguration \nInvalidateConfiguration \n\n This function is called when the configuration is known to have changed for reasons not encoded in the ProjectOptions.\n For example, dependent references may have been deleted or created.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#MatchBraces","title":"FSharpChecker.MatchBraces","content":"FSharpChecker.MatchBraces \nMatchBraces \n\n Parse a source code file, returning information about brace matching in the file.\n Return an enumeration of the matching parenthetical tokens in the file.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#MatchBraces","title":"FSharpChecker.MatchBraces","content":"FSharpChecker.MatchBraces \nMatchBraces \n\n Parse a source code file, returning information about brace matching in the file.\n Return an enumeration of the matching parenthetical tokens in the file.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#NotifyFileChanged","title":"FSharpChecker.NotifyFileChanged","content":"FSharpChecker.NotifyFileChanged \nNotifyFileChanged \n Notify the checker that given file has changed. This needs to be used when checker is created with documentSource = Custom.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#NotifyProjectCleaned","title":"FSharpChecker.NotifyProjectCleaned","content":"FSharpChecker.NotifyProjectCleaned \nNotifyProjectCleaned \n\n This function is called when a project has been cleaned/rebuilt, and thus any live type providers should be refreshed.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ParseAndCheckFileInProject","title":"FSharpChecker.ParseAndCheckFileInProject","content":"FSharpChecker.ParseAndCheckFileInProject \nParseAndCheckFileInProject \n\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Parse and check a source code file, returning a handle to the results\n \u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Note: all files except the one being checked are read from the FileSystem API\n \u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\n Return FSharpCheckFileAnswer.Aborted if a parse tree was not available.\n \u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ParseAndCheckProject","title":"FSharpChecker.ParseAndCheckProject","content":"FSharpChecker.ParseAndCheckProject \nParseAndCheckProject \n\u003Cp class=\u0027fsdocs-para\u0027\u003EParse and typecheck all files in a project.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EAll files are read from the FileSystem API\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003ECan cause a second type-check on the entire project when \u0060enablePartialTypeChecking\u0060 is true on the FSharpChecker.\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ParseFile","title":"FSharpChecker.ParseFile","content":"FSharpChecker.ParseFile \nParseFile \n\n Parses a source code for a file and caches the results. Returns an AST that can be traversed for various features.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ParseFileInProject","title":"FSharpChecker.ParseFileInProject","content":"FSharpChecker.ParseFileInProject \nParseFileInProject \n\n Parses a source code for a file. Returns an AST that can be traversed for various features.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#TokenizeFile","title":"FSharpChecker.TokenizeFile","content":"FSharpChecker.TokenizeFile \nTokenizeFile \n Tokenize an entire file, line by line","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#TokenizeLine","title":"FSharpChecker.TokenizeLine","content":"FSharpChecker.TokenizeLine \nTokenizeLine \n Tokenize a single line, returning token information and a tokenization state represented by an integer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#TryGetRecentCheckResultsForFile","title":"FSharpChecker.TryGetRecentCheckResultsForFile","content":"FSharpChecker.TryGetRecentCheckResultsForFile \nTryGetRecentCheckResultsForFile \n\n Try to get type check results for a file. This looks up the results of recent type checks of the\n same file, regardless of contents. The version tag specified in the original check of the file is returned.\n If the source of the file has changed the results returned by this function may be out of date, though may\n still be usable for generating intellisense menus and information.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#FileChecked","title":"FSharpChecker.FileChecked","content":"FSharpChecker.FileChecked \nFileChecked \n Raised after a check of a file in the background analysis.\n\n The event will be raised on a background thread.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ProjectChecked","title":"FSharpChecker.ProjectChecked","content":"FSharpChecker.ProjectChecked \nProjectChecked \n Notify the host that a project has been fully checked in the background (using file contents provided by the file system API)\n\n The event may be raised on a background thread.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#BeforeBackgroundFileCheck","title":"FSharpChecker.BeforeBackgroundFileCheck","content":"FSharpChecker.BeforeBackgroundFileCheck \nBeforeBackgroundFileCheck \n Notify the host that the logical type checking context for a file has now been updated internally\n and that the file has become eligible to be re-typechecked for errors.\n The event will be raised on a background thread.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#FileParsed","title":"FSharpChecker.FileParsed","content":"FSharpChecker.FileParsed \nFileParsed \n Raised after a parse of a file in the background analysis.\n\n The event will be raised on a background thread.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#Create","title":"FSharpChecker.Create","content":"FSharpChecker.Create \nCreate \n\n Create an instance of an FSharpChecker.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ActualCheckFileCount","title":"FSharpChecker.ActualCheckFileCount","content":"FSharpChecker.ActualCheckFileCount \nActualCheckFileCount \n Report a statistic for testability","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#ActualParseFileCount","title":"FSharpChecker.ActualParseFileCount","content":"FSharpChecker.ActualParseFileCount \nActualParseFileCount \n Report a statistic for testability","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpchecker.html#Instance","title":"FSharpChecker.Instance","content":"FSharpChecker.Instance \nInstance \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html","title":"FSharpParseFileResults","content":"FSharpParseFileResults \n Represents the results of parsing an F# file and a set of analysis operations based on the parse tree alone. \nFSharpParseFileResults.FindParameterLocations \nFindParameterLocations \nFSharpParseFileResults.GetAllArgumentsForFunctionApplicationAtPosition \nGetAllArgumentsForFunctionApplicationAtPosition \nFSharpParseFileResults.GetNavigationItems \nGetNavigationItems \nFSharpParseFileResults.IsBindingALambdaAtPosition \nIsBindingALambdaAtPosition \nFSharpParseFileResults.IsPosContainedInApplication \nIsPosContainedInApplication \nFSharpParseFileResults.IsPositionContainedInACurriedParameter \nIsPositionContainedInACurriedParameter \nFSharpParseFileResults.IsPositionWithinRecordDefinition \nIsPositionWithinRecordDefinition \nFSharpParseFileResults.IsPositionWithinTypeDefinition \nIsPositionWithinTypeDefinition \nFSharpParseFileResults.IsTypeAnnotationGivenAtPosition \nIsTypeAnnotationGivenAtPosition \nFSharpParseFileResults.IsTypeName \nIsTypeName \nFSharpParseFileResults.TryIdentOfPipelineContainingPosAndNumArgsApplied \nTryIdentOfPipelineContainingPosAndNumArgsApplied \nFSharpParseFileResults.TryRangeOfExprInYieldOrReturn \nTryRangeOfExprInYieldOrReturn \nFSharpParseFileResults.TryRangeOfExpressionBeingDereferencedContainingPos \nTryRangeOfExpressionBeingDereferencedContainingPos \nFSharpParseFileResults.TryRangeOfFunctionOrMethodBeingApplied \nTryRangeOfFunctionOrMethodBeingApplied \nFSharpParseFileResults.TryRangeOfNameOfNearestOuterBindingContainingPos \nTryRangeOfNameOfNearestOuterBindingContainingPos \nFSharpParseFileResults.TryRangeOfParenEnclosingOpEqualsGreaterUsage \nTryRangeOfParenEnclosingOpEqualsGreaterUsage \nFSharpParseFileResults.TryRangeOfRecordExpressionContainingPos \nTryRangeOfRecordExpressionContainingPos \nFSharpParseFileResults.TryRangeOfRefCellDereferenceContainingPos \nTryRangeOfRefCellDereferenceContainingPos \nFSharpParseFileResults.TryRangeOfReturnTypeHint \nTryRangeOfReturnTypeHint \nFSharpParseFileResults.TryRangeOfStringInterpolationContainingPos \nTryRangeOfStringInterpolationContainingPos \nFSharpParseFileResults.ValidateBreakpointLocation \nValidateBreakpointLocation \nFSharpParseFileResults.FileName \nFileName \nFSharpParseFileResults.ParseHadErrors \nParseHadErrors \nFSharpParseFileResults.Diagnostics \nDiagnostics \nFSharpParseFileResults.DependencyFiles \nDependencyFiles \nFSharpParseFileResults.ParseTree \nParseTree","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#FindParameterLocations","title":"FSharpParseFileResults.FindParameterLocations","content":"FSharpParseFileResults.FindParameterLocations \nFindParameterLocations \n Notable parse info for ParameterInfo at a given location","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#GetAllArgumentsForFunctionApplicationAtPosition","title":"FSharpParseFileResults.GetAllArgumentsForFunctionApplicationAtPosition","content":"FSharpParseFileResults.GetAllArgumentsForFunctionApplicationAtPosition \nGetAllArgumentsForFunctionApplicationAtPosition \n Gets the ranges of all arguments, if they can be found, for a function application at the given position.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#GetNavigationItems","title":"FSharpParseFileResults.GetNavigationItems","content":"FSharpParseFileResults.GetNavigationItems \nGetNavigationItems \n Get declared items and the selected item at the specified location","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsBindingALambdaAtPosition","title":"FSharpParseFileResults.IsBindingALambdaAtPosition","content":"FSharpParseFileResults.IsBindingALambdaAtPosition \nIsBindingALambdaAtPosition \n Determines if the binding at the given position is bound to a lambda expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsPosContainedInApplication","title":"FSharpParseFileResults.IsPosContainedInApplication","content":"FSharpParseFileResults.IsPosContainedInApplication \nIsPosContainedInApplication \n Determines if the given position is inside a function or method application.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsPositionContainedInACurriedParameter","title":"FSharpParseFileResults.IsPositionContainedInACurriedParameter","content":"FSharpParseFileResults.IsPositionContainedInACurriedParameter \nIsPositionContainedInACurriedParameter \n Determines if the given position is contained within a curried parameter in a binding.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsPositionWithinRecordDefinition","title":"FSharpParseFileResults.IsPositionWithinRecordDefinition","content":"FSharpParseFileResults.IsPositionWithinRecordDefinition \nIsPositionWithinRecordDefinition \n Determines if the given position is bound to a record definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsPositionWithinTypeDefinition","title":"FSharpParseFileResults.IsPositionWithinTypeDefinition","content":"FSharpParseFileResults.IsPositionWithinTypeDefinition \nIsPositionWithinTypeDefinition \n Determines if the given position is bound to a type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsTypeAnnotationGivenAtPosition","title":"FSharpParseFileResults.IsTypeAnnotationGivenAtPosition","content":"FSharpParseFileResults.IsTypeAnnotationGivenAtPosition \nIsTypeAnnotationGivenAtPosition \n Determines if the expression or pattern at the given position has a type annotation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#IsTypeName","title":"FSharpParseFileResults.IsTypeName","content":"FSharpParseFileResults.IsTypeName \nIsTypeName \n Determines if the range points to a type name in the type definition.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryIdentOfPipelineContainingPosAndNumArgsApplied","title":"FSharpParseFileResults.TryIdentOfPipelineContainingPosAndNumArgsApplied","content":"FSharpParseFileResults.TryIdentOfPipelineContainingPosAndNumArgsApplied \nTryIdentOfPipelineContainingPosAndNumArgsApplied \n Attempts to find an Ident of a pipeline containing the given position, and the number of args already applied in that pipeline.\n For example, \u0027[1..10] |\u003E List.map \u0027 would give back the ident of \u0027|\u003E\u0027 and 1, because it applied 1 arg (the list) to \u0027List.map\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfExprInYieldOrReturn","title":"FSharpParseFileResults.TryRangeOfExprInYieldOrReturn","content":"FSharpParseFileResults.TryRangeOfExprInYieldOrReturn \nTryRangeOfExprInYieldOrReturn \n Attempts to find the range of an expression \u0060expr\u0060 contained in a \u0060yield expr\u0060 or \u0060return expr\u0060 expression (and bang-variants).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfExpressionBeingDereferencedContainingPos","title":"FSharpParseFileResults.TryRangeOfExpressionBeingDereferencedContainingPos","content":"FSharpParseFileResults.TryRangeOfExpressionBeingDereferencedContainingPos \nTryRangeOfExpressionBeingDereferencedContainingPos \n Gets the range of an expression being dereferenced. For \u0060!expr\u0060, gives the range of \u0060expr\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfFunctionOrMethodBeingApplied","title":"FSharpParseFileResults.TryRangeOfFunctionOrMethodBeingApplied","content":"FSharpParseFileResults.TryRangeOfFunctionOrMethodBeingApplied \nTryRangeOfFunctionOrMethodBeingApplied \n Attempts to find the range of a function or method that is being applied. Also accounts for functions in pipelines.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfNameOfNearestOuterBindingContainingPos","title":"FSharpParseFileResults.TryRangeOfNameOfNearestOuterBindingContainingPos","content":"FSharpParseFileResults.TryRangeOfNameOfNearestOuterBindingContainingPos \nTryRangeOfNameOfNearestOuterBindingContainingPos \n Attempts to find the range of the name of the nearest outer binding that contains a given position.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfParenEnclosingOpEqualsGreaterUsage","title":"FSharpParseFileResults.TryRangeOfParenEnclosingOpEqualsGreaterUsage","content":"FSharpParseFileResults.TryRangeOfParenEnclosingOpEqualsGreaterUsage \nTryRangeOfParenEnclosingOpEqualsGreaterUsage \n Attempts to find the range of an attempted lambda expression or pattern, the argument range, and the expr range when writing a C#-style \u0022lambda\u0022 (which is actually an operator application)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfRecordExpressionContainingPos","title":"FSharpParseFileResults.TryRangeOfRecordExpressionContainingPos","content":"FSharpParseFileResults.TryRangeOfRecordExpressionContainingPos \nTryRangeOfRecordExpressionContainingPos \n Attempts to find the range of a record expression containing the given position.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfRefCellDereferenceContainingPos","title":"FSharpParseFileResults.TryRangeOfRefCellDereferenceContainingPos","content":"FSharpParseFileResults.TryRangeOfRefCellDereferenceContainingPos \nTryRangeOfRefCellDereferenceContainingPos \n Given the position of an expression, attempts to find the range of the\n \u0027!\u0027 in a derefence operation of that expression, like:\n \u0027!expr\u0027, \u0027!(expr)\u0027, etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfReturnTypeHint","title":"FSharpParseFileResults.TryRangeOfReturnTypeHint","content":"FSharpParseFileResults.TryRangeOfReturnTypeHint \nTryRangeOfReturnTypeHint \n Gets the range of where a return type hint could be placed for a function binding. This will be right in front of the equals sign.\n Returns None if type annotation is present.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#TryRangeOfStringInterpolationContainingPos","title":"FSharpParseFileResults.TryRangeOfStringInterpolationContainingPos","content":"FSharpParseFileResults.TryRangeOfStringInterpolationContainingPos \nTryRangeOfStringInterpolationContainingPos \n Attempts to find the range of the string interpolation that contains a given position.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#ValidateBreakpointLocation","title":"FSharpParseFileResults.ValidateBreakpointLocation","content":"FSharpParseFileResults.ValidateBreakpointLocation \nValidateBreakpointLocation \n Return the inner-most range associated with a possible breakpoint location","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#FileName","title":"FSharpParseFileResults.FileName","content":"FSharpParseFileResults.FileName \nFileName \n Name of the file for which this information were created","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#ParseHadErrors","title":"FSharpParseFileResults.ParseHadErrors","content":"FSharpParseFileResults.ParseHadErrors \nParseHadErrors \n Indicates if any errors occurred during the parse","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#Diagnostics","title":"FSharpParseFileResults.Diagnostics","content":"FSharpParseFileResults.Diagnostics \nDiagnostics \n Get the errors and warnings for the parse","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#DependencyFiles","title":"FSharpParseFileResults.DependencyFiles","content":"FSharpParseFileResults.DependencyFiles \nDependencyFiles \n When these files change then the build is invalid","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html#ParseTree","title":"FSharpParseFileResults.ParseTree","content":"FSharpParseFileResults.ParseTree \nParseTree \n The syntax tree resulting from the parse","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html","title":"FSharpParsingOptions","content":"FSharpParsingOptions \n Options used to determine active --define conditionals and other options relevant to parsing files in a project \nFSharpParsingOptions.Default \nDefault \nFSharpParsingOptions.SourceFiles \nSourceFiles \nFSharpParsingOptions.ApplyLineDirectives \nApplyLineDirectives \nFSharpParsingOptions.ConditionalDefines \nConditionalDefines \nFSharpParsingOptions.DiagnosticOptions \nDiagnosticOptions \nFSharpParsingOptions.LangVersionText \nLangVersionText \nFSharpParsingOptions.IsInteractive \nIsInteractive \nFSharpParsingOptions.IndentationAwareSyntax \nIndentationAwareSyntax \nFSharpParsingOptions.StrictIndentation \nStrictIndentation \nFSharpParsingOptions.CompilingFSharpCore \nCompilingFSharpCore \nFSharpParsingOptions.IsExe \nIsExe","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#Default","title":"FSharpParsingOptions.Default","content":"FSharpParsingOptions.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#SourceFiles","title":"FSharpParsingOptions.SourceFiles","content":"FSharpParsingOptions.SourceFiles \nSourceFiles \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#ApplyLineDirectives","title":"FSharpParsingOptions.ApplyLineDirectives","content":"FSharpParsingOptions.ApplyLineDirectives \nApplyLineDirectives \n Indicates if the ranges returned by parsing should have \u0027#line\u0027 directives applied to them.\n When compiling code, this should usually be \u0027true\u0027. For editing tools, this is usually \u0027false.\n The default for FSharpParsingOptions.ApplyLineDirectives is \u0027false\u0027. The default for\n FSharpParsingOptions arising from FSharpProjectOptions will be \u0027true\u0027 unless \u0027--ignorelinedirectives\u0027 is used in the\n parameters from which these are derived.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#ConditionalDefines","title":"FSharpParsingOptions.ConditionalDefines","content":"FSharpParsingOptions.ConditionalDefines \nConditionalDefines \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#DiagnosticOptions","title":"FSharpParsingOptions.DiagnosticOptions","content":"FSharpParsingOptions.DiagnosticOptions \nDiagnosticOptions \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#LangVersionText","title":"FSharpParsingOptions.LangVersionText","content":"FSharpParsingOptions.LangVersionText \nLangVersionText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#IsInteractive","title":"FSharpParsingOptions.IsInteractive","content":"FSharpParsingOptions.IsInteractive \nIsInteractive \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#IndentationAwareSyntax","title":"FSharpParsingOptions.IndentationAwareSyntax","content":"FSharpParsingOptions.IndentationAwareSyntax \nIndentationAwareSyntax \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#StrictIndentation","title":"FSharpParsingOptions.StrictIndentation","content":"FSharpParsingOptions.StrictIndentation \nStrictIndentation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#CompilingFSharpCore","title":"FSharpParsingOptions.CompilingFSharpCore","content":"FSharpParsingOptions.CompilingFSharpCore \nCompilingFSharpCore \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html#IsExe","title":"FSharpParsingOptions.IsExe","content":"FSharpParsingOptions.IsExe \nIsExe \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html","title":"FSharpProjectContext","content":"FSharpProjectContext \n Represents the checking context implied by the ProjectOptions \nFSharpProjectContext.GetReferencedAssemblies \nGetReferencedAssemblies \nFSharpProjectContext.ProjectOptions \nProjectOptions \nFSharpProjectContext.AccessibilityRights \nAccessibilityRights","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html#GetReferencedAssemblies","title":"FSharpProjectContext.GetReferencedAssemblies","content":"FSharpProjectContext.GetReferencedAssemblies \nGetReferencedAssemblies \n Get the resolution and full contents of the assemblies referenced by the project options","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html#ProjectOptions","title":"FSharpProjectContext.ProjectOptions","content":"FSharpProjectContext.ProjectOptions \nProjectOptions \n Get the project options","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html#AccessibilityRights","title":"FSharpProjectContext.AccessibilityRights","content":"FSharpProjectContext.AccessibilityRights \nAccessibilityRights \n Get the accessibility rights for this project context w.r.t. InternalsVisibleTo attributes granting access to other assemblies","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html","title":"FSharpProjectOptions","content":"FSharpProjectOptions \nA set of information describing a project or script build configuration. \nFSharpProjectOptions.ProjectFileName \nProjectFileName \nFSharpProjectOptions.ProjectId \nProjectId \nFSharpProjectOptions.SourceFiles \nSourceFiles \nFSharpProjectOptions.OtherOptions \nOtherOptions \nFSharpProjectOptions.ReferencedProjects \nReferencedProjects \nFSharpProjectOptions.IsIncompleteTypeCheckEnvironment \nIsIncompleteTypeCheckEnvironment \nFSharpProjectOptions.UseScriptResolutionRules \nUseScriptResolutionRules \nFSharpProjectOptions.LoadTime \nLoadTime \nFSharpProjectOptions.UnresolvedReferences \nUnresolvedReferences \nFSharpProjectOptions.OriginalLoadReferences \nOriginalLoadReferences \nFSharpProjectOptions.Stamp \nStamp","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#ProjectFileName","title":"FSharpProjectOptions.ProjectFileName","content":"FSharpProjectOptions.ProjectFileName \nProjectFileName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#ProjectId","title":"FSharpProjectOptions.ProjectId","content":"FSharpProjectOptions.ProjectId \nProjectId \n This is the unique identifier for the project, it is case sensitive. If it\u0027s None, will key off of ProjectFileName in our caching.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#SourceFiles","title":"FSharpProjectOptions.SourceFiles","content":"FSharpProjectOptions.SourceFiles \nSourceFiles \n The files in the project","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#OtherOptions","title":"FSharpProjectOptions.OtherOptions","content":"FSharpProjectOptions.OtherOptions \nOtherOptions \n Additional command line argument options for the project. These can include additional files and references.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#ReferencedProjects","title":"FSharpProjectOptions.ReferencedProjects","content":"FSharpProjectOptions.ReferencedProjects \nReferencedProjects \n The command line arguments for the other projects referenced by this project, indexed by the\n exact text used in the \u0022-r:\u0022 reference in FSharpProjectOptions.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#IsIncompleteTypeCheckEnvironment","title":"FSharpProjectOptions.IsIncompleteTypeCheckEnvironment","content":"FSharpProjectOptions.IsIncompleteTypeCheckEnvironment \nIsIncompleteTypeCheckEnvironment \n When true, the typechecking environment is known a priori to be incomplete, for\n example when a .fs file is opened outside of a project. In this case, the number of error\n messages reported is reduced.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#UseScriptResolutionRules","title":"FSharpProjectOptions.UseScriptResolutionRules","content":"FSharpProjectOptions.UseScriptResolutionRules \nUseScriptResolutionRules \n When true, use the reference resolution rules for scripts rather than the rules for compiler.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#LoadTime","title":"FSharpProjectOptions.LoadTime","content":"FSharpProjectOptions.LoadTime \nLoadTime \n Timestamp of project/script load, used to differentiate between different instances of a project load.\n This ensures that a complete reload of the project or script type checking\n context occurs on project or script unload/reload.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#UnresolvedReferences","title":"FSharpProjectOptions.UnresolvedReferences","content":"FSharpProjectOptions.UnresolvedReferences \nUnresolvedReferences \n Unused in this API and should be \u0027None\u0027 when used as user-specified input","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#OriginalLoadReferences","title":"FSharpProjectOptions.OriginalLoadReferences","content":"FSharpProjectOptions.OriginalLoadReferences \nOriginalLoadReferences \n Unused in this API and should be \u0027[]\u0027 when used as user-specified input","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html#Stamp","title":"FSharpProjectOptions.Stamp","content":"FSharpProjectOptions.Stamp \nStamp \n An optional stamp to uniquely identify this set of options\n If two sets of options both have stamps, then they are considered equal\n if and only if the stamps are equal","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html","title":"FSharpReferencedProject","content":"FSharpReferencedProject \n \nFSharpReferencedProject.OutputFile \nOutputFile \nFSharpReferencedProject.FSharpReference \nFSharpReference \nFSharpReferencedProject.PEReference \nPEReference \nFSharpReferencedProject.ILModuleReference \nILModuleReference","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html#OutputFile","title":"FSharpReferencedProject.OutputFile","content":"FSharpReferencedProject.OutputFile \nOutputFile \n\n The fully qualified path to the output of the referenced project. This should be the same value as the \u003Ccode\u003E-r\u003C/code\u003E\n reference in the project options for this referenced project.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html#FSharpReference","title":"FSharpReferencedProject.FSharpReference","content":"FSharpReferencedProject.FSharpReference \nFSharpReference \n\n A reference for an F# project. The physical data for it is stored/cached inside of the compiler service.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html#PEReference","title":"FSharpReferencedProject.PEReference","content":"FSharpReferencedProject.PEReference \nPEReference \n\n A reference for any portable executable, including F#. The stream is owned by this reference.\n The stream will be automatically disposed when there are no references to FSharpReferencedProject and is GC collected.\n Once the stream is evaluated, the function that constructs the stream will no longer be referenced by anything.\n If the stream evaluation throws an exception, it will be automatically handled.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html#ILModuleReference","title":"FSharpReferencedProject.ILModuleReference","content":"FSharpReferencedProject.ILModuleReference \nILModuleReference \n\n A reference from an ILModuleReader.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html","title":"FSharpSymbolUse","content":"FSharpSymbolUse \n Represents the use of an F# symbol from F# source code \nFSharpSymbolUse.IsPrivateToFileAndSignatureFile \nIsPrivateToFileAndSignatureFile \nFSharpSymbolUse.FileName \nFileName \nFSharpSymbolUse.Range \nRange \nFSharpSymbolUse.DisplayContext \nDisplayContext \nFSharpSymbolUse.IsFromUse \nIsFromUse \nFSharpSymbolUse.IsFromPattern \nIsFromPattern \nFSharpSymbolUse.IsPrivateToFile \nIsPrivateToFile \nFSharpSymbolUse.IsFromComputationExpression \nIsFromComputationExpression \nFSharpSymbolUse.GenericArguments \nGenericArguments \nFSharpSymbolUse.IsFromDispatchSlotImplementation \nIsFromDispatchSlotImplementation \nFSharpSymbolUse.IsFromOpenStatement \nIsFromOpenStatement \nFSharpSymbolUse.IsFromType \nIsFromType \nFSharpSymbolUse.IsFromDefinition \nIsFromDefinition \nFSharpSymbolUse.Symbol \nSymbol \nFSharpSymbolUse.IsFromAttribute \nIsFromAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsPrivateToFileAndSignatureFile","title":"FSharpSymbolUse.IsPrivateToFileAndSignatureFile","content":"FSharpSymbolUse.IsPrivateToFileAndSignatureFile \nIsPrivateToFileAndSignatureFile \n Indicates if the FSharpSymbolUse is private to the implementation \u0026 signature file.\n This is true for function and method parameters.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#FileName","title":"FSharpSymbolUse.FileName","content":"FSharpSymbolUse.FileName \nFileName \n The file name the reference occurs in","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#Range","title":"FSharpSymbolUse.Range","content":"FSharpSymbolUse.Range \nRange \n The range of text representing the reference to the symbol","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#DisplayContext","title":"FSharpSymbolUse.DisplayContext","content":"FSharpSymbolUse.DisplayContext \nDisplayContext \n The display context active at the point where the symbol is used. Can be passed to FSharpType.Format\n and other methods to format items in a way that is suitable for a specific source code location.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromUse","title":"FSharpSymbolUse.IsFromUse","content":"FSharpSymbolUse.IsFromUse \nIsFromUse \n Indicates if the reference is used for example at a call site","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromPattern","title":"FSharpSymbolUse.IsFromPattern","content":"FSharpSymbolUse.IsFromPattern \nIsFromPattern \n Indicates if the reference is in a pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsPrivateToFile","title":"FSharpSymbolUse.IsPrivateToFile","content":"FSharpSymbolUse.IsPrivateToFile \nIsPrivateToFile \n Indicates if the FSharpSymbolUse is declared as private","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromComputationExpression","title":"FSharpSymbolUse.IsFromComputationExpression","content":"FSharpSymbolUse.IsFromComputationExpression \nIsFromComputationExpression \n Indicates if the reference is either a builder or a custom operation in a computation expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#GenericArguments","title":"FSharpSymbolUse.GenericArguments","content":"FSharpSymbolUse.GenericArguments \nGenericArguments \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromDispatchSlotImplementation","title":"FSharpSymbolUse.IsFromDispatchSlotImplementation","content":"FSharpSymbolUse.IsFromDispatchSlotImplementation \nIsFromDispatchSlotImplementation \n Indicates if the reference is via the member being implemented in a class or object expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromOpenStatement","title":"FSharpSymbolUse.IsFromOpenStatement","content":"FSharpSymbolUse.IsFromOpenStatement \nIsFromOpenStatement \n Indicates if the reference is in open statement","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromType","title":"FSharpSymbolUse.IsFromType","content":"FSharpSymbolUse.IsFromType \nIsFromType \n Indicates if the reference is in a syntactic type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromDefinition","title":"FSharpSymbolUse.IsFromDefinition","content":"FSharpSymbolUse.IsFromDefinition \nIsFromDefinition \n Indicates if the reference is a definition for the symbol, either in a signature or implementation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#Symbol","title":"FSharpSymbolUse.Symbol","content":"FSharpSymbolUse.Symbol \nSymbol \n The symbol referenced","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html#IsFromAttribute","title":"FSharpSymbolUse.IsFromAttribute","content":"FSharpSymbolUse.IsFromAttribute \nIsFromAttribute \n Indicates if the reference is in an attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-fsharpunresolvedreferencesset.html","title":"FSharpUnresolvedReferencesSet","content":"FSharpUnresolvedReferencesSet \nUnused in this API","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html","title":"ILegacyReferenceResolver","content":"ILegacyReferenceResolver \n \nILegacyReferenceResolver.HighestInstalledNetFrameworkVersion \nHighestInstalledNetFrameworkVersion \nILegacyReferenceResolver.Resolve \nResolve \nILegacyReferenceResolver.DotNetFrameworkReferenceAssembliesRootDirectory \nDotNetFrameworkReferenceAssembliesRootDirectory","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html#HighestInstalledNetFrameworkVersion","title":"ILegacyReferenceResolver.HighestInstalledNetFrameworkVersion","content":"ILegacyReferenceResolver.HighestInstalledNetFrameworkVersion \nHighestInstalledNetFrameworkVersion \n Get the \u0022v4.5.1\u0022-style moniker for the highest installed .NET Framework version.\n This is the value passed back to Resolve if no explicit \u0022mscorlib\u0022 has been given.\n\n Note: If an explicit \u0022mscorlib\u0022 is given, then --noframework is being used, and the whole ReferenceResolver logic is essentially\n unused. However in the future an option may be added to allow an explicit specification of\n a .NET Framework version to use for scripts.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html#Resolve","title":"ILegacyReferenceResolver.Resolve","content":"ILegacyReferenceResolver.Resolve \nResolve \n Perform assembly resolution on the given references under the given conditions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html#DotNetFrameworkReferenceAssembliesRootDirectory","title":"ILegacyReferenceResolver.DotNetFrameworkReferenceAssembliesRootDirectory","content":"ILegacyReferenceResolver.DotNetFrameworkReferenceAssembliesRootDirectory \nDotNetFrameworkReferenceAssembliesRootDirectory \n Get the Reference Assemblies directory for the .NET Framework (on Windows)\n This is added to the default resolution path for\n design-time compilations.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyreferenceresolver.html","title":"LegacyReferenceResolver","content":"LegacyReferenceResolver \n \nLegacyReferenceResolver.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyreferenceresolver.html#\u0060\u0060.ctor\u0060\u0060","title":"LegacyReferenceResolver.\u0060\u0060.ctor\u0060\u0060","content":"LegacyReferenceResolver.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolutionenvironment.html","title":"LegacyResolutionEnvironment","content":"LegacyResolutionEnvironment \n \nLegacyResolutionEnvironment.EditingOrCompilation \nEditingOrCompilation \nLegacyResolutionEnvironment.CompilationAndEvaluation \nCompilationAndEvaluation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolutionenvironment.html#EditingOrCompilation","title":"LegacyResolutionEnvironment.EditingOrCompilation","content":"LegacyResolutionEnvironment.EditingOrCompilation \nEditingOrCompilation \n Indicates a script or source being edited or compiled. Uses reference assemblies (not implementation assemblies).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolutionenvironment.html#CompilationAndEvaluation","title":"LegacyResolutionEnvironment.CompilationAndEvaluation","content":"LegacyResolutionEnvironment.CompilationAndEvaluation \nCompilationAndEvaluation \n Indicates a script or source being dynamically compiled and executed. Uses implementation assemblies.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolutionfailure.html","title":"LegacyResolutionFailure","content":"LegacyResolutionFailure \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html","title":"LegacyResolvedFile","content":"LegacyResolvedFile \n \nLegacyResolvedFile.itemSpec \nitemSpec \nLegacyResolvedFile.prepareToolTip \nprepareToolTip \nLegacyResolvedFile.baggage \nbaggage","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html#itemSpec","title":"LegacyResolvedFile.itemSpec","content":"LegacyResolvedFile.itemSpec \nitemSpec \n Item specification.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html#prepareToolTip","title":"LegacyResolvedFile.prepareToolTip","content":"LegacyResolvedFile.prepareToolTip \nprepareToolTip \n Prepare textual information about where the assembly was resolved from, used for tooltip output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html#baggage","title":"LegacyResolvedFile.baggage","content":"LegacyResolvedFile.baggage \nbaggage \n Round-tripped baggage","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-assemblyresolutionprobe.html","title":"AssemblyResolutionProbe","content":"AssemblyResolutionProbe \n Signature for ResolutionProbe callback\n host implements this, it\u0027s job is to return a list of assembly paths to probe. \nAssemblyResolutionProbe.Invoke \nInvoke","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-assemblyresolutionprobe.html#Invoke","title":"AssemblyResolutionProbe.Invoke","content":"AssemblyResolutionProbe.Invoke \nInvoke \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-assemblyresolvehandler.html","title":"AssemblyResolveHandler","content":"AssemblyResolveHandler \n Handle Assembly resolution \nAssemblyResolveHandler.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-assemblyresolvehandler.html#\u0060\u0060.ctor\u0060\u0060","title":"AssemblyResolveHandler.\u0060\u0060.ctor\u0060\u0060","content":"AssemblyResolveHandler.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new DependencyProvider","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html","title":"DependencyProvider","content":"DependencyProvider \n Provides DependencyManagement functions.\n\n The class incrementally collects IDependencyManagerProvider, indexed by key, and\n queries them. These are found and instantiated with respect to the compilerTools and outputDir\n provided each time the TryFindDependencyManagerByKey and TryFindDependencyManagerInPath are\n executed, which are assumed to be invariant over the lifetime of the DependencyProvider. \nDependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDependencyProvider.ClearResultsCache \nClearResultsCache \nDependencyProvider.CreatePackageManagerUnknownError \nCreatePackageManagerUnknownError \nDependencyProvider.GetRegisteredDependencyManagerHelpText \nGetRegisteredDependencyManagerHelpText \nDependencyProvider.Resolve \nResolve \nDependencyProvider.TryFindDependencyManagerByKey \nTryFindDependencyManagerByKey \nDependencyProvider.TryFindDependencyManagerInPath \nTryFindDependencyManagerInPath","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#\u0060\u0060.ctor\u0060\u0060","title":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060","content":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new DependencyProvider with managed and native resolution and specify caching","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#\u0060\u0060.ctor\u0060\u0060","title":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060","content":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new DependencyProvider with managed and native resolution","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#\u0060\u0060.ctor\u0060\u0060","title":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060","content":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new DependencyProvider with only native resolution and specify caching","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#\u0060\u0060.ctor\u0060\u0060","title":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060","content":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new DependencyProvider with only native resolution","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#\u0060\u0060.ctor\u0060\u0060","title":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060","content":"DependencyProvider.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new DependencyProvider with no dynamic load handlers (only for compilation/analysis)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#ClearResultsCache","title":"DependencyProvider.ClearResultsCache","content":"DependencyProvider.ClearResultsCache \nClearResultsCache \n Clear the DependencyManager results caches","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#CreatePackageManagerUnknownError","title":"DependencyProvider.CreatePackageManagerUnknownError","content":"DependencyProvider.CreatePackageManagerUnknownError \nCreatePackageManagerUnknownError \n Returns a formatted error message for the host to present","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#GetRegisteredDependencyManagerHelpText","title":"DependencyProvider.GetRegisteredDependencyManagerHelpText","content":"DependencyProvider.GetRegisteredDependencyManagerHelpText \nGetRegisteredDependencyManagerHelpText \n Returns a formatted help messages for registered dependencymanagers for the host to present","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#Resolve","title":"DependencyProvider.Resolve","content":"DependencyProvider.Resolve \nResolve \n Resolve reference for a list of package manager lines","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#TryFindDependencyManagerByKey","title":"DependencyProvider.TryFindDependencyManagerByKey","content":"DependencyProvider.TryFindDependencyManagerByKey \nTryFindDependencyManagerByKey \n Fetch a dependencymanager that supports a specific key","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-dependencyprovider.html#TryFindDependencyManagerInPath","title":"DependencyProvider.TryFindDependencyManagerInPath","content":"DependencyProvider.TryFindDependencyManagerInPath \nTryFindDependencyManagerInPath \n TryFindDependencyManagerInPath - given a #r \u0022key:sometext\u0022 go and find a DependencyManager that satisfies the key","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-errorreporttype.html","title":"ErrorReportType","content":"ErrorReportType \n Todo describe this API \nErrorReportType.Warning \nWarning \nErrorReportType.Error \nError","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-errorreporttype.html#Warning","title":"ErrorReportType.Warning","content":"ErrorReportType.Warning \nWarning \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-errorreporttype.html#Error","title":"ErrorReportType.Error","content":"ErrorReportType.Error \nError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html","title":"IDependencyManagerProvider","content":"IDependencyManagerProvider \n Wraps access to a DependencyManager implementation \nIDependencyManagerProvider.ClearResultsCache \nClearResultsCache \nIDependencyManagerProvider.ResolveDependencies \nResolveDependencies \nIDependencyManagerProvider.Key \nKey \nIDependencyManagerProvider.Name \nName \nIDependencyManagerProvider.HelpMessages \nHelpMessages","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html#ClearResultsCache","title":"IDependencyManagerProvider.ClearResultsCache","content":"IDependencyManagerProvider.ClearResultsCache \nClearResultsCache \n Clear the results cache","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html#ResolveDependencies","title":"IDependencyManagerProvider.ResolveDependencies","content":"IDependencyManagerProvider.ResolveDependencies \nResolveDependencies \n Resolve the dependencies, for the given set of arguments, go find the .dll references, scripts and additional include values.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html#Key","title":"IDependencyManagerProvider.Key","content":"IDependencyManagerProvider.Key \nKey \n\u003Cpre\u003E Key that identifies the types of dependencies that this DependencyManager operates on\n E.g\n nuget: indicates that this DM is for nuget packages\n paket: indicates that this DM is for paket scripts, which manage nuget packages, github source dependencies etc ...\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html#Name","title":"IDependencyManagerProvider.Name","content":"IDependencyManagerProvider.Name \nName \n Name of the dependency manager","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html#HelpMessages","title":"IDependencyManagerProvider.HelpMessages","content":"IDependencyManagerProvider.HelpMessages \nHelpMessages \n The help messages for this dependency manager inster","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html","title":"IResolveDependenciesResult","content":"IResolveDependenciesResult \n The results of ResolveDependencies \nIResolveDependenciesResult.Resolutions \nResolutions \nIResolveDependenciesResult.StdOut \nStdOut \nIResolveDependenciesResult.StdError \nStdError \nIResolveDependenciesResult.Roots \nRoots \nIResolveDependenciesResult.SourceFiles \nSourceFiles \nIResolveDependenciesResult.Success \nSuccess","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html#Resolutions","title":"IResolveDependenciesResult.Resolutions","content":"IResolveDependenciesResult.Resolutions \nResolutions \n The resolution paths - the full paths to selected resolved dll\u0027s.\n In scripts this is equivalent to #r @\u0022c:\\somepath\\to\\packages\\ResolvedPackage\\1.1.1\\lib\\netstandard2.0\\ResolvedAssembly.dll\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html#StdOut","title":"IResolveDependenciesResult.StdOut","content":"IResolveDependenciesResult.StdOut \nStdOut \n The resolution output log","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html#StdError","title":"IResolveDependenciesResult.StdError","content":"IResolveDependenciesResult.StdError \nStdError \n The resolution error log (process stderr)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html#Roots","title":"IResolveDependenciesResult.Roots","content":"IResolveDependenciesResult.Roots \nRoots \n\u003Cpre\u003E The roots to package directories\n This points to the root of each located package.\n The layout of the package manager will be package manager specific.\n however, the dependency manager dll understands the nuget package layout\n and so if the package contains folders similar to the nuget layout then\n the dependency manager will be able to probe and resolve any native dependencies\n required by the nuget package.\n\n This path is also equivalent to\n #I @\u0022c:\\somepath\\to\\packages\\1.1.1\\ResolvedPackage\u0022\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html#SourceFiles","title":"IResolveDependenciesResult.SourceFiles","content":"IResolveDependenciesResult.SourceFiles \nSourceFiles \n The source code file paths","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html#Success","title":"IResolveDependenciesResult.Success","content":"IResolveDependenciesResult.Success \nSuccess \n Succeded?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-nativedllresolvehandler.html","title":"NativeDllResolveHandler","content":"NativeDllResolveHandler \n \nNativeDllResolveHandler.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-nativedllresolvehandler.html#\u0060\u0060.ctor\u0060\u0060","title":"NativeDllResolveHandler.\u0060\u0060.ctor\u0060\u0060","content":"NativeDllResolveHandler.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Construct a new NativeDllResolveHandler","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-nativeresolutionprobe.html","title":"NativeResolutionProbe","content":"NativeResolutionProbe \n Signature for Native library resolution probe callback\n host implements this, it\u0027s job is to return a list of package roots to probe. \nNativeResolutionProbe.Invoke \nInvoke","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-nativeresolutionprobe.html#Invoke","title":"NativeResolutionProbe.Invoke","content":"NativeResolutionProbe.Invoke \nInvoke \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-resolvingerrorreport.html","title":"ResolvingErrorReport","content":"ResolvingErrorReport \n \nResolvingErrorReport.Invoke \nInvoke","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-dependencymanager-resolvingerrorreport.html#Invoke","title":"ResolvingErrorReport.Invoke","content":"ResolvingErrorReport.Invoke \nInvoke \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-activitynames.html","title":"ActivityNames","content":"ActivityNames \n For activities following the dotnet distributed tracing concept\n https://learn.microsoft.com/dotnet/core/diagnostics/distributed-tracing-concepts?source=recommendations \nActivityNames.FscSourceName \nFscSourceName \nActivityNames.ProfiledSourceName \nProfiledSourceName \nActivityNames.AllRelevantNames \nAllRelevantNames","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-activitynames.html#FscSourceName","title":"ActivityNames.FscSourceName","content":"ActivityNames.FscSourceName \nFscSourceName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-activitynames.html#ProfiledSourceName","title":"ActivityNames.ProfiledSourceName","content":"ActivityNames.ProfiledSourceName \nProfiledSourceName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-activitynames.html#AllRelevantNames","title":"ActivityNames.AllRelevantNames","content":"ActivityNames.AllRelevantNames \nAllRelevantNames \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-compilerdiagnostics.html","title":"CompilerDiagnostics","content":"CompilerDiagnostics \n Exposes compiler diagnostic error messages. \nCompilerDiagnostics.GetErrorMessage \nGetErrorMessage \nCompilerDiagnostics.GetSuggestedNames \nGetSuggestedNames","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-compilerdiagnostics.html#GetErrorMessage","title":"CompilerDiagnostics.GetErrorMessage","content":"CompilerDiagnostics.GetErrorMessage \nGetErrorMessage \n Given a DiagnosticKind, returns the string representing the error message for that diagnostic.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-compilerdiagnostics.html#GetSuggestedNames","title":"CompilerDiagnostics.GetSuggestedNames","content":"CompilerDiagnostics.GetSuggestedNames \nGetSuggestedNames \n Given a set of names, uses and a string representing an unresolved identifier,\n returns a list of suggested names if there are any feasible candidates.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata.html","title":"ExtendedData","content":"ExtendedData \n \nExtendedData.ArgumentsInSigAndImplMismatchExtendedData \nArgumentsInSigAndImplMismatchExtendedData \nExtendedData.DiagnosticContextInfo \nDiagnosticContextInfo \nExtendedData.ExpressionIsAFunctionExtendedData \nExpressionIsAFunctionExtendedData \nExtendedData.FieldNotContainedDiagnosticExtendedData \nFieldNotContainedDiagnosticExtendedData \nExtendedData.IFSharpDiagnosticExtendedData \nIFSharpDiagnosticExtendedData \nExtendedData.TypeMismatchDiagnosticExtendedData \nTypeMismatchDiagnosticExtendedData \nExtendedData.ValueNotContainedDiagnosticExtendedData \nValueNotContainedDiagnosticExtendedData","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html","title":"ArgumentsInSigAndImplMismatchExtendedData","content":"ArgumentsInSigAndImplMismatchExtendedData \n Additional data for \u0027argument names in the signature and implementation do not match\u0027 diagnostic \nArgumentsInSigAndImplMismatchExtendedData.ImplementationRange \nImplementationRange \nArgumentsInSigAndImplMismatchExtendedData.SignatureRange \nSignatureRange \nArgumentsInSigAndImplMismatchExtendedData.ImplementationName \nImplementationName \nArgumentsInSigAndImplMismatchExtendedData.SignatureName \nSignatureName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html#ImplementationRange","title":"ArgumentsInSigAndImplMismatchExtendedData.ImplementationRange","content":"ArgumentsInSigAndImplMismatchExtendedData.ImplementationRange \nImplementationRange \n Argument identifier range within implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html#SignatureRange","title":"ArgumentsInSigAndImplMismatchExtendedData.SignatureRange","content":"ArgumentsInSigAndImplMismatchExtendedData.SignatureRange \nSignatureRange \n Argument identifier range within signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html#ImplementationName","title":"ArgumentsInSigAndImplMismatchExtendedData.ImplementationName","content":"ArgumentsInSigAndImplMismatchExtendedData.ImplementationName \nImplementationName \n Argument name in implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html#SignatureName","title":"ArgumentsInSigAndImplMismatchExtendedData.SignatureName","content":"ArgumentsInSigAndImplMismatchExtendedData.SignatureName \nSignatureName \n Argument name in signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html","title":"DiagnosticContextInfo","content":"DiagnosticContextInfo \n Information about the context of a type equation in type-mismatch-like diagnostic \nDiagnosticContextInfo.NoContext \nNoContext \nDiagnosticContextInfo.IfExpression \nIfExpression \nDiagnosticContextInfo.OmittedElseBranch \nOmittedElseBranch \nDiagnosticContextInfo.ElseBranchResult \nElseBranchResult \nDiagnosticContextInfo.RecordFields \nRecordFields \nDiagnosticContextInfo.TupleInRecordFields \nTupleInRecordFields \nDiagnosticContextInfo.CollectionElement \nCollectionElement \nDiagnosticContextInfo.ReturnInComputationExpression \nReturnInComputationExpression \nDiagnosticContextInfo.YieldInComputationExpression \nYieldInComputationExpression \nDiagnosticContextInfo.RuntimeTypeTest \nRuntimeTypeTest \nDiagnosticContextInfo.DowncastUsedInsteadOfUpcast \nDowncastUsedInsteadOfUpcast \nDiagnosticContextInfo.FollowingPatternMatchClause \nFollowingPatternMatchClause \nDiagnosticContextInfo.PatternMatchGuard \nPatternMatchGuard \nDiagnosticContextInfo.SequenceExpression \nSequenceExpression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#NoContext","title":"DiagnosticContextInfo.NoContext","content":"DiagnosticContextInfo.NoContext \nNoContext \n No context was given","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#IfExpression","title":"DiagnosticContextInfo.IfExpression","content":"DiagnosticContextInfo.IfExpression \nIfExpression \n The type equation comes from an IF expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#OmittedElseBranch","title":"DiagnosticContextInfo.OmittedElseBranch","content":"DiagnosticContextInfo.OmittedElseBranch \nOmittedElseBranch \n The type equation comes from an omitted else branch","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#ElseBranchResult","title":"DiagnosticContextInfo.ElseBranchResult","content":"DiagnosticContextInfo.ElseBranchResult \nElseBranchResult \n The type equation comes from a type check of the result of an else branch","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#RecordFields","title":"DiagnosticContextInfo.RecordFields","content":"DiagnosticContextInfo.RecordFields \nRecordFields \n The type equation comes from the verification of record fields","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#TupleInRecordFields","title":"DiagnosticContextInfo.TupleInRecordFields","content":"DiagnosticContextInfo.TupleInRecordFields \nTupleInRecordFields \n The type equation comes from the verification of a tuple in record fields","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#CollectionElement","title":"DiagnosticContextInfo.CollectionElement","content":"DiagnosticContextInfo.CollectionElement \nCollectionElement \n The type equation comes from a list or array constructor","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#ReturnInComputationExpression","title":"DiagnosticContextInfo.ReturnInComputationExpression","content":"DiagnosticContextInfo.ReturnInComputationExpression \nReturnInComputationExpression \n The type equation comes from a return in a computation expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#YieldInComputationExpression","title":"DiagnosticContextInfo.YieldInComputationExpression","content":"DiagnosticContextInfo.YieldInComputationExpression \nYieldInComputationExpression \n The type equation comes from a yield in a computation expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#RuntimeTypeTest","title":"DiagnosticContextInfo.RuntimeTypeTest","content":"DiagnosticContextInfo.RuntimeTypeTest \nRuntimeTypeTest \n The type equation comes from a runtime type test","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#DowncastUsedInsteadOfUpcast","title":"DiagnosticContextInfo.DowncastUsedInsteadOfUpcast","content":"DiagnosticContextInfo.DowncastUsedInsteadOfUpcast \nDowncastUsedInsteadOfUpcast \n The type equation comes from an downcast where a upcast could be used","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#FollowingPatternMatchClause","title":"DiagnosticContextInfo.FollowingPatternMatchClause","content":"DiagnosticContextInfo.FollowingPatternMatchClause \nFollowingPatternMatchClause \n The type equation comes from a return type of a pattern match clause (not the first clause)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#PatternMatchGuard","title":"DiagnosticContextInfo.PatternMatchGuard","content":"DiagnosticContextInfo.PatternMatchGuard \nPatternMatchGuard \n The type equation comes from a pattern match guard","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html#SequenceExpression","title":"DiagnosticContextInfo.SequenceExpression","content":"DiagnosticContextInfo.SequenceExpression \nSequenceExpression \n The type equation comes from a sequence expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-expressionisafunctionextendeddata.html","title":"ExpressionIsAFunctionExtendedData","content":"ExpressionIsAFunctionExtendedData \n Additional data for \u0027This expression is a function value, i.e. is missing arguments\u0027 diagnostic \nExpressionIsAFunctionExtendedData.ActualType \nActualType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-expressionisafunctionextendeddata.html#ActualType","title":"ExpressionIsAFunctionExtendedData.ActualType","content":"ExpressionIsAFunctionExtendedData.ActualType \nActualType \n Represents F# type of the expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-fieldnotcontaineddiagnosticextendeddata.html","title":"FieldNotContainedDiagnosticExtendedData","content":"FieldNotContainedDiagnosticExtendedData \n Additional data for diagnostics about a field whose declarations differ in signature and implementation \nFieldNotContainedDiagnosticExtendedData.SignatureField \nSignatureField \nFieldNotContainedDiagnosticExtendedData.ImplementationField \nImplementationField","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-fieldnotcontaineddiagnosticextendeddata.html#SignatureField","title":"FieldNotContainedDiagnosticExtendedData.SignatureField","content":"FieldNotContainedDiagnosticExtendedData.SignatureField \nSignatureField \n Represents F# field in signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-fieldnotcontaineddiagnosticextendeddata.html#ImplementationField","title":"FieldNotContainedDiagnosticExtendedData.ImplementationField","content":"FieldNotContainedDiagnosticExtendedData.ImplementationField \nImplementationField \n Represents F# field in implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-ifsharpdiagnosticextendeddata.html","title":"IFSharpDiagnosticExtendedData","content":"IFSharpDiagnosticExtendedData \n Contextually-relevant data to each particular diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html","title":"TypeMismatchDiagnosticExtendedData","content":"TypeMismatchDiagnosticExtendedData \n Additional data for type-mismatch-like (usually with ErrorNumber = 1) diagnostics \nTypeMismatchDiagnosticExtendedData.DisplayContext \nDisplayContext \nTypeMismatchDiagnosticExtendedData.ActualType \nActualType \nTypeMismatchDiagnosticExtendedData.ContextInfo \nContextInfo \nTypeMismatchDiagnosticExtendedData.ExpectedType \nExpectedType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html#DisplayContext","title":"TypeMismatchDiagnosticExtendedData.DisplayContext","content":"TypeMismatchDiagnosticExtendedData.DisplayContext \nDisplayContext \n Represents the information needed to format types","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html#ActualType","title":"TypeMismatchDiagnosticExtendedData.ActualType","content":"TypeMismatchDiagnosticExtendedData.ActualType \nActualType \n Represents F# type type actual in the current context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html#ContextInfo","title":"TypeMismatchDiagnosticExtendedData.ContextInfo","content":"TypeMismatchDiagnosticExtendedData.ContextInfo \nContextInfo \n The context in which the type mismatch was found","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html#ExpectedType","title":"TypeMismatchDiagnosticExtendedData.ExpectedType","content":"TypeMismatchDiagnosticExtendedData.ExpectedType \nExpectedType \n Represents F# type expected in the current context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-valuenotcontaineddiagnosticextendeddata.html","title":"ValueNotContainedDiagnosticExtendedData","content":"ValueNotContainedDiagnosticExtendedData \n Additional data for diagnostics about a value whose declarations differ in signature and implementation \nValueNotContainedDiagnosticExtendedData.SignatureValue \nSignatureValue \nValueNotContainedDiagnosticExtendedData.ImplementationValue \nImplementationValue","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-valuenotcontaineddiagnosticextendeddata.html#SignatureValue","title":"ValueNotContainedDiagnosticExtendedData.SignatureValue","content":"ValueNotContainedDiagnosticExtendedData.SignatureValue \nSignatureValue \n Represents F# value in signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-extendeddata-valuenotcontaineddiagnosticextendeddata.html#ImplementationValue","title":"ValueNotContainedDiagnosticExtendedData.ImplementationValue","content":"ValueNotContainedDiagnosticExtendedData.ImplementationValue \nImplementationValue \n Represents F# value in implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html","title":"FSharpDiagnostic","content":"FSharpDiagnostic \n Represents a diagnostic produced by the F# compiler \nFSharpDiagnostic.Start \nStart \nFSharpDiagnostic.FileName \nFileName \nFSharpDiagnostic.Range \nRange \nFSharpDiagnostic.EndColumn \nEndColumn \nFSharpDiagnostic.ExtendedData \nExtendedData \nFSharpDiagnostic.Subcategory \nSubcategory \nFSharpDiagnostic.Message \nMessage \nFSharpDiagnostic.StartColumn \nStartColumn \nFSharpDiagnostic.End \nEnd \nFSharpDiagnostic.Severity \nSeverity \nFSharpDiagnostic.ErrorNumberPrefix \nErrorNumberPrefix \nFSharpDiagnostic.EndLine \nEndLine \nFSharpDiagnostic.StartLine \nStartLine \nFSharpDiagnostic.ErrorNumberText \nErrorNumberText \nFSharpDiagnostic.ErrorNumber \nErrorNumber \nFSharpDiagnostic.Create \nCreate \nFSharpDiagnostic.NewlineifyErrorString \nNewlineifyErrorString \nFSharpDiagnostic.NormalizeErrorString \nNormalizeErrorString","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#Start","title":"FSharpDiagnostic.Start","content":"FSharpDiagnostic.Start \nStart \n Gets the start position for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#FileName","title":"FSharpDiagnostic.FileName","content":"FSharpDiagnostic.FileName \nFileName \n Gets the file name for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#Range","title":"FSharpDiagnostic.Range","content":"FSharpDiagnostic.Range \nRange \n Gets the range for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#EndColumn","title":"FSharpDiagnostic.EndColumn","content":"FSharpDiagnostic.EndColumn \nEndColumn \n Gets the end column for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#ExtendedData","title":"FSharpDiagnostic.ExtendedData","content":"FSharpDiagnostic.ExtendedData \nExtendedData \n Gets the contextually-relevant data to each particular diagnostic for things like code fixes","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#Subcategory","title":"FSharpDiagnostic.Subcategory","content":"FSharpDiagnostic.Subcategory \nSubcategory \n Gets the sub-category for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#Message","title":"FSharpDiagnostic.Message","content":"FSharpDiagnostic.Message \nMessage \n Gets the message for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#StartColumn","title":"FSharpDiagnostic.StartColumn","content":"FSharpDiagnostic.StartColumn \nStartColumn \n Gets the start column for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#End","title":"FSharpDiagnostic.End","content":"FSharpDiagnostic.End \nEnd \n Gets the end position for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#Severity","title":"FSharpDiagnostic.Severity","content":"FSharpDiagnostic.Severity \nSeverity \n Gets the severity for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#ErrorNumberPrefix","title":"FSharpDiagnostic.ErrorNumberPrefix","content":"FSharpDiagnostic.ErrorNumberPrefix \nErrorNumberPrefix \n Gets the number prefix for the diagnostic, usually \u0022FS\u0022 but may differ for analyzers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#EndLine","title":"FSharpDiagnostic.EndLine","content":"FSharpDiagnostic.EndLine \nEndLine \n Gets the end line for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#StartLine","title":"FSharpDiagnostic.StartLine","content":"FSharpDiagnostic.StartLine \nStartLine \n Gets the start line for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#ErrorNumberText","title":"FSharpDiagnostic.ErrorNumberText","content":"FSharpDiagnostic.ErrorNumberText \nErrorNumberText \n Gets the full error number text e.g \u0022FS0031\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#ErrorNumber","title":"FSharpDiagnostic.ErrorNumber","content":"FSharpDiagnostic.ErrorNumber \nErrorNumber \n Gets the number for the diagnostic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#Create","title":"FSharpDiagnostic.Create","content":"FSharpDiagnostic.Create \nCreate \n Creates a diagnostic, e.g. for reporting from an analyzer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#NewlineifyErrorString","title":"FSharpDiagnostic.NewlineifyErrorString","content":"FSharpDiagnostic.NewlineifyErrorString \nNewlineifyErrorString \n Newlines are recognized and replaced with (ASCII 29, the \u0027group separator\u0027),\n which is decoded by the IDE with \u0027NewlineifyErrorString\u0027 back into newlines, so that multi-line errors can be displayed in QuickInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html#NormalizeErrorString","title":"FSharpDiagnostic.NormalizeErrorString","content":"FSharpDiagnostic.NormalizeErrorString \nNormalizeErrorString \n Newlines are recognized and replaced with (ASCII 29, the \u0027group separator\u0027),\n which is decoded by the IDE with \u0027NewlineifyErrorString\u0027 back into newlines, so that multi-line errors can be displayed in QuickInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html","title":"FSharpDiagnosticKind","content":"FSharpDiagnosticKind \n Supported kinds of diagnostics by this service. \nFSharpDiagnosticKind.AddIndexerDot \nAddIndexerDot \nFSharpDiagnosticKind.ReplaceWithSuggestion \nReplaceWithSuggestion \nFSharpDiagnosticKind.RemoveIndexerDot \nRemoveIndexerDot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html#AddIndexerDot","title":"FSharpDiagnosticKind.AddIndexerDot","content":"FSharpDiagnosticKind.AddIndexerDot \nAddIndexerDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html#ReplaceWithSuggestion","title":"FSharpDiagnosticKind.ReplaceWithSuggestion","content":"FSharpDiagnosticKind.ReplaceWithSuggestion \nReplaceWithSuggestion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html#RemoveIndexerDot","title":"FSharpDiagnosticKind.RemoveIndexerDot","content":"FSharpDiagnosticKind.RemoveIndexerDot \nRemoveIndexerDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html","title":"FSharpDiagnosticOptions","content":"FSharpDiagnosticOptions \n \nFSharpDiagnosticOptions.CheckXmlDocs \nCheckXmlDocs \nFSharpDiagnosticOptions.Default \nDefault \nFSharpDiagnosticOptions.WarnLevel \nWarnLevel \nFSharpDiagnosticOptions.GlobalWarnAsError \nGlobalWarnAsError \nFSharpDiagnosticOptions.WarnOff \nWarnOff \nFSharpDiagnosticOptions.WarnOn \nWarnOn \nFSharpDiagnosticOptions.WarnAsError \nWarnAsError \nFSharpDiagnosticOptions.WarnAsWarn \nWarnAsWarn","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#CheckXmlDocs","title":"FSharpDiagnosticOptions.CheckXmlDocs","content":"FSharpDiagnosticOptions.CheckXmlDocs \nCheckXmlDocs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#Default","title":"FSharpDiagnosticOptions.Default","content":"FSharpDiagnosticOptions.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#WarnLevel","title":"FSharpDiagnosticOptions.WarnLevel","content":"FSharpDiagnosticOptions.WarnLevel \nWarnLevel \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#GlobalWarnAsError","title":"FSharpDiagnosticOptions.GlobalWarnAsError","content":"FSharpDiagnosticOptions.GlobalWarnAsError \nGlobalWarnAsError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#WarnOff","title":"FSharpDiagnosticOptions.WarnOff","content":"FSharpDiagnosticOptions.WarnOff \nWarnOff \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#WarnOn","title":"FSharpDiagnosticOptions.WarnOn","content":"FSharpDiagnosticOptions.WarnOn \nWarnOn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#WarnAsError","title":"FSharpDiagnosticOptions.WarnAsError","content":"FSharpDiagnosticOptions.WarnAsError \nWarnAsError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html#WarnAsWarn","title":"FSharpDiagnosticOptions.WarnAsWarn","content":"FSharpDiagnosticOptions.WarnAsWarn \nWarnAsWarn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html","title":"FSharpDiagnosticSeverity","content":"FSharpDiagnosticSeverity \n \nFSharpDiagnosticSeverity.Hidden \nHidden \nFSharpDiagnosticSeverity.Info \nInfo \nFSharpDiagnosticSeverity.Warning \nWarning \nFSharpDiagnosticSeverity.Error \nError","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html#Hidden","title":"FSharpDiagnosticSeverity.Hidden","content":"FSharpDiagnosticSeverity.Hidden \nHidden \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html#Info","title":"FSharpDiagnosticSeverity.Info","content":"FSharpDiagnosticSeverity.Info \nInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html#Warning","title":"FSharpDiagnosticSeverity.Warning","content":"FSharpDiagnosticSeverity.Warning \nWarning \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html#Error","title":"FSharpDiagnosticSeverity.Error","content":"FSharpDiagnosticSeverity.Error \nError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblycontent.html","title":"AssemblyContent","content":"AssemblyContent \n Provides assembly content. \nAssemblyContent.GetAssemblySignatureContent \nGetAssemblySignatureContent \nAssemblyContent.GetAssemblyContent \nGetAssemblyContent","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblycontent.html#GetAssemblySignatureContent","title":"AssemblyContent.GetAssemblySignatureContent","content":"AssemblyContent.GetAssemblySignatureContent \nGetAssemblySignatureContent \n Given a \u0060FSharpAssemblySignature\u0060, returns assembly content.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblycontent.html#GetAssemblyContent","title":"AssemblyContent.GetAssemblyContent","content":"AssemblyContent.GetAssemblyContent \nGetAssemblyContent \n Returns (possibly cached) assembly content.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html","title":"InterfaceStubGenerator","content":"InterfaceStubGenerator \n \nInterfaceStubGenerator.GetInterfaceMembers \nGetInterfaceMembers \nInterfaceStubGenerator.HasNoInterfaceMember \nHasNoInterfaceMember \nInterfaceStubGenerator.GetMemberNameAndRanges \nGetMemberNameAndRanges \nInterfaceStubGenerator.GetImplementedMemberSignatures \nGetImplementedMemberSignatures \nInterfaceStubGenerator.IsInterface \nIsInterface \nInterfaceStubGenerator.FormatInterface \nFormatInterface \nInterfaceStubGenerator.TryFindInterfaceDeclaration \nTryFindInterfaceDeclaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#GetInterfaceMembers","title":"InterfaceStubGenerator.GetInterfaceMembers","content":"InterfaceStubGenerator.GetInterfaceMembers \nGetInterfaceMembers \n Get members in the decreasing order of inheritance chain","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#HasNoInterfaceMember","title":"InterfaceStubGenerator.HasNoInterfaceMember","content":"InterfaceStubGenerator.HasNoInterfaceMember \nHasNoInterfaceMember \n Check whether an interface is empty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#GetMemberNameAndRanges","title":"InterfaceStubGenerator.GetMemberNameAndRanges","content":"InterfaceStubGenerator.GetMemberNameAndRanges \nGetMemberNameAndRanges \n Get associated member names and ranges.\n In case of properties, intrinsic ranges might not be correct for the purpose of getting\n positions of \u0027member\u0027, which indicate the indentation for generating new members","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#GetImplementedMemberSignatures","title":"InterfaceStubGenerator.GetImplementedMemberSignatures","content":"InterfaceStubGenerator.GetImplementedMemberSignatures \nGetImplementedMemberSignatures \n Get interface member signatures","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#IsInterface","title":"InterfaceStubGenerator.IsInterface","content":"InterfaceStubGenerator.IsInterface \nIsInterface \n Check whether an entity is an interface or type abbreviation of an interface","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#FormatInterface","title":"InterfaceStubGenerator.FormatInterface","content":"InterfaceStubGenerator.FormatInterface \nFormatInterface \n Generate stub implementation of an interface at a start column","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacestubgenerator.html#TryFindInterfaceDeclaration","title":"InterfaceStubGenerator.TryFindInterfaceDeclaration","content":"InterfaceStubGenerator.TryFindInterfaceDeclaration \nTryFindInterfaceDeclaration \n Find corresponding interface declaration at a given position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigateto.html","title":"NavigateTo","content":"NavigateTo \n \nNavigateTo.GetNavigableItems \nGetNavigableItems","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigateto.html#GetNavigableItems","title":"NavigateTo.GetNavigableItems","content":"NavigateTo.GetNavigableItems \nGetNavigableItems \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigation.html","title":"Navigation","content":"Navigation \n \nNavigation.getNavigation \ngetNavigation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigation.html#getNavigation","title":"Navigation.getNavigation","content":"Navigation.getNavigation \ngetNavigation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html","title":"ParsedInput","content":"ParsedInput \n Operations querying the entire syntax tree \nParsedInput.TryFindExpressionASTLeftOfDotLeftOfCursor \nTryFindExpressionASTLeftOfDotLeftOfCursor \nParsedInput.GetRangeOfExprLeftOfDot \nGetRangeOfExprLeftOfDot \nParsedInput.TryFindExpressionIslandInPosition \nTryFindExpressionIslandInPosition \nParsedInput.TryGetCompletionContext \nTryGetCompletionContext \nParsedInput.GetEntityKind \nGetEntityKind \nParsedInput.GetFullNameOfSmallestModuleOrNamespaceAtPoint \nGetFullNameOfSmallestModuleOrNamespaceAtPoint \nParsedInput.TryFindInsertionContext \nTryFindInsertionContext \nParsedInput.FindNearestPointToInsertOpenDeclaration \nFindNearestPointToInsertOpenDeclaration \nParsedInput.GetLongIdentAt \nGetLongIdentAt \nParsedInput.AdjustInsertionPoint \nAdjustInsertionPoint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#TryFindExpressionASTLeftOfDotLeftOfCursor","title":"ParsedInput.TryFindExpressionASTLeftOfDotLeftOfCursor","content":"ParsedInput.TryFindExpressionASTLeftOfDotLeftOfCursor \nTryFindExpressionASTLeftOfDotLeftOfCursor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#GetRangeOfExprLeftOfDot","title":"ParsedInput.GetRangeOfExprLeftOfDot","content":"ParsedInput.GetRangeOfExprLeftOfDot \nGetRangeOfExprLeftOfDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#TryFindExpressionIslandInPosition","title":"ParsedInput.TryFindExpressionIslandInPosition","content":"ParsedInput.TryFindExpressionIslandInPosition \nTryFindExpressionIslandInPosition \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#TryGetCompletionContext","title":"ParsedInput.TryGetCompletionContext","content":"ParsedInput.TryGetCompletionContext \nTryGetCompletionContext \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#GetEntityKind","title":"ParsedInput.GetEntityKind","content":"ParsedInput.GetEntityKind \nGetEntityKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#GetFullNameOfSmallestModuleOrNamespaceAtPoint","title":"ParsedInput.GetFullNameOfSmallestModuleOrNamespaceAtPoint","content":"ParsedInput.GetFullNameOfSmallestModuleOrNamespaceAtPoint \nGetFullNameOfSmallestModuleOrNamespaceAtPoint \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#TryFindInsertionContext","title":"ParsedInput.TryFindInsertionContext","content":"ParsedInput.TryFindInsertionContext \nTryFindInsertionContext \n Returns \u0060InsertContext\u0060 based on current position and symbol idents.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#FindNearestPointToInsertOpenDeclaration","title":"ParsedInput.FindNearestPointToInsertOpenDeclaration","content":"ParsedInput.FindNearestPointToInsertOpenDeclaration \nFindNearestPointToInsertOpenDeclaration \n Returns \u0060InsertContext\u0060 based on current position and symbol idents.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#GetLongIdentAt","title":"ParsedInput.GetLongIdentAt","content":"ParsedInput.GetLongIdentAt \nGetLongIdentAt \n Returns long identifier at position.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parsedinput.html#AdjustInsertionPoint","title":"ParsedInput.AdjustInsertionPoint","content":"ParsedInput.AdjustInsertionPoint \nAdjustInsertionPoint \n Corrects insertion line number based on kind of scope and text surrounding the insertion point.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html","title":"QuickParse","content":"QuickParse \n\u003Cpre\u003E Methods for cheaply and inaccurately parsing F#.\n\n These methods are very old and are mostly to do with extracting \u0022long identifier islands\u0022\n A.B.C\n from F# source code, an approach taken from pre-F# VS samples for implementing intelliense.\n\n This code should really no longer be needed since the language service has access to\n parsed F# source code ASTs. However, the long identifiers are still passed back to GetDeclarations and friends in the\n F# Compiler Service and it\u0027s annoyingly hard to remove their use completely.\n\n In general it is unlikely much progress will be made by fixing this code - it will be better to\n extract more information from the F# ASTs.\n\n It\u0027s also surprising how hard even the job of getting long identifier islands can be. For example the code\n below is inaccurate for long identifier chains involving \u0060\u0060...\u0060\u0060 identifiers. And there are special cases\n for active pattern names and so on.\u003C/pre\u003E \nQuickParse.MagicalAdjustmentConstant \nMagicalAdjustmentConstant \nQuickParse.CorrectIdentifierToken \nCorrectIdentifierToken \nQuickParse.GetCompleteIdentifierIsland \nGetCompleteIdentifierIsland \nQuickParse.GetPartialLongName \nGetPartialLongName \nQuickParse.GetPartialLongNameEx \nGetPartialLongNameEx \nQuickParse.TestMemberOrOverrideDeclaration \nTestMemberOrOverrideDeclaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html#MagicalAdjustmentConstant","title":"QuickParse.MagicalAdjustmentConstant","content":"QuickParse.MagicalAdjustmentConstant \nMagicalAdjustmentConstant \n Puts us after the last character.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html#CorrectIdentifierToken","title":"QuickParse.CorrectIdentifierToken","content":"QuickParse.CorrectIdentifierToken \nCorrectIdentifierToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html#GetCompleteIdentifierIsland","title":"QuickParse.GetCompleteIdentifierIsland","content":"QuickParse.GetCompleteIdentifierIsland \nGetCompleteIdentifierIsland \n\u003Cpre\u003E Given a string and a position in that string, find an identifier as\n expected by \u0060GotoDefinition\u0060. This will work when the cursor is\n immediately before the identifier, within the identifier, or immediately\n after the identifier.\n\n \u0027tolerateJustAfter\u0027 indicates that we tolerate being one character after the identifier, used\n for goto-definition\n\n In general, only identifiers composed from upper/lower letters and \u0027.\u0027 are supported, but there\n are a couple of explicitly handled exceptions to allow some common scenarios:\n - When the name contains only letters and \u0027|\u0027 symbol, it may be an active pattern, so we\n treat it as a valid identifier - e.g. let ( |Identity| ) a = a\n (but other identifiers that include \u0027|\u0027 are not allowed - e.g. \u0027||\u0027 operator)\n - It searches for double tick (\u0060\u0060) to see if the identifier could be something like \u0060\u0060a b\u0060\u0060\n\n REVIEW: Also support, e.g., operators, performing the necessary mangling.\n (i.e., I would like that the name returned here can be passed as-is\n (post \u0060.\u0060-chopping) to \u0060GetDeclarationLocation.)\n\n In addition, return the position where a \u0060.\u0060 would go if we were making\n a call to \u0060DeclItemsForNamesAtPosition\u0060 for intellisense. This will\n allow us to use find the correct qualified items rather than resorting\n to the more expensive and less accurate environment lookup.\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html#GetPartialLongName","title":"QuickParse.GetPartialLongName","content":"QuickParse.GetPartialLongName \nGetPartialLongName \n Get the partial long name of the identifier to the left of index.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html#GetPartialLongNameEx","title":"QuickParse.GetPartialLongNameEx","content":"QuickParse.GetPartialLongNameEx \nGetPartialLongNameEx \n Get the partial long name of the identifier to the left of index.\n For example, for \u0060System.DateTime.Now\u0060 it returns PartialLongName ([|\u0022System\u0022; \u0022DateTime\u0022|], \u0022Now\u0022, Some 32), where \u002232\u0022 pos of the last dot.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-quickparse.html#TestMemberOrOverrideDeclaration","title":"QuickParse.TestMemberOrOverrideDeclaration","content":"QuickParse.TestMemberOrOverrideDeclaration \nTestMemberOrOverrideDeclaration \n Tests whether the user is typing something like \u0022member x.\u0022 or \u0022override (*comment*) x.\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-simplifynames.html","title":"SimplifyNames","content":"SimplifyNames \n \nSimplifyNames.SimplifiableRange \nSimplifiableRange \nSimplifyNames.getSimplifiableNames \ngetSimplifiableNames","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-simplifynames.html#getSimplifiableNames","title":"SimplifyNames.getSimplifiableNames","content":"SimplifyNames.getSimplifiableNames \ngetSimplifiableNames \n Get all ranges that can be simplified in a file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-simplifynames-simplifiablerange.html","title":"SimplifiableRange","content":"SimplifiableRange \n Data for use in finding unnecessarily-qualified names and generating diagnostics to simplify them \nSimplifiableRange.Range \nRange \nSimplifiableRange.RelativeName \nRelativeName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-simplifynames-simplifiablerange.html#Range","title":"SimplifiableRange.Range","content":"SimplifiableRange.Range \nRange \n The range of a name that can be simplified","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-simplifynames-simplifiablerange.html#RelativeName","title":"SimplifiableRange.RelativeName","content":"SimplifiableRange.RelativeName \nRelativeName \n The relative name that can be applied to a simplifiable name","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure.html","title":"Structure","content":"Structure \n \nStructure.Collapse \nCollapse \nStructure.Scope \nScope \nStructure.ScopeRange \nScopeRange \nStructure.getOutliningRanges \ngetOutliningRanges","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure.html#getOutliningRanges","title":"Structure.getOutliningRanges","content":"Structure.getOutliningRanges \ngetOutliningRanges \n Returns outlining ranges for given parsed input.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-collapse.html","title":"Collapse","content":"Collapse \n Collapse indicates the way a range/snapshot should be collapsed. \u0060Same\u0060 is for a scope inside\n some kind of scope delimiter, e.g. \u0060[| ... |]\u0060, \u0060[ ... ]\u0060, \u0060{ ... }\u0060, etc. \u0060Below\u0060 is for expressions\n following a binding or the right hand side of a pattern, e.g. \u0060let x = ...\u0060 \nCollapse.Below \nBelow \nCollapse.Same \nSame","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-collapse.html#Below","title":"Collapse.Below","content":"Collapse.Below \nBelow \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-collapse.html#Same","title":"Collapse.Same","content":"Collapse.Same \nSame \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html","title":"Scope","content":"Scope \n Tag to identify the construct that can be stored alongside its associated ranges \nScope.Open \nOpen \nScope.Namespace \nNamespace \nScope.Module \nModule \nScope.Type \nType \nScope.Member \nMember \nScope.LetOrUse \nLetOrUse \nScope.Val \nVal \nScope.ComputationExpr \nComputationExpr \nScope.IfThenElse \nIfThenElse \nScope.ThenInIfThenElse \nThenInIfThenElse \nScope.ElseInIfThenElse \nElseInIfThenElse \nScope.TryWith \nTryWith \nScope.TryInTryWith \nTryInTryWith \nScope.WithInTryWith \nWithInTryWith \nScope.TryFinally \nTryFinally \nScope.TryInTryFinally \nTryInTryFinally \nScope.FinallyInTryFinally \nFinallyInTryFinally \nScope.ArrayOrList \nArrayOrList \nScope.ObjExpr \nObjExpr \nScope.For \nFor \nScope.While \nWhile \nScope.Match \nMatch \nScope.MatchBang \nMatchBang \nScope.MatchLambda \nMatchLambda \nScope.MatchClause \nMatchClause \nScope.Lambda \nLambda \nScope.Quote \nQuote \nScope.Record \nRecord \nScope.SpecialFunc \nSpecialFunc \nScope.Do \nDo \nScope.New \nNew \nScope.Attribute \nAttribute \nScope.Interface \nInterface \nScope.HashDirective \nHashDirective \nScope.LetOrUseBang \nLetOrUseBang \nScope.TypeExtension \nTypeExtension \nScope.YieldOrReturn \nYieldOrReturn \nScope.YieldOrReturnBang \nYieldOrReturnBang \nScope.Tuple \nTuple \nScope.UnionCase \nUnionCase \nScope.EnumCase \nEnumCase \nScope.RecordField \nRecordField \nScope.RecordDefn \nRecordDefn \nScope.UnionDefn \nUnionDefn \nScope.Comment \nComment \nScope.XmlDocComment \nXmlDocComment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Open","title":"Scope.Open","content":"Scope.Open \nOpen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Namespace","title":"Scope.Namespace","content":"Scope.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Module","title":"Scope.Module","content":"Scope.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Type","title":"Scope.Type","content":"Scope.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Member","title":"Scope.Member","content":"Scope.Member \nMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#LetOrUse","title":"Scope.LetOrUse","content":"Scope.LetOrUse \nLetOrUse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Val","title":"Scope.Val","content":"Scope.Val \nVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#ComputationExpr","title":"Scope.ComputationExpr","content":"Scope.ComputationExpr \nComputationExpr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#IfThenElse","title":"Scope.IfThenElse","content":"Scope.IfThenElse \nIfThenElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#ThenInIfThenElse","title":"Scope.ThenInIfThenElse","content":"Scope.ThenInIfThenElse \nThenInIfThenElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#ElseInIfThenElse","title":"Scope.ElseInIfThenElse","content":"Scope.ElseInIfThenElse \nElseInIfThenElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#TryWith","title":"Scope.TryWith","content":"Scope.TryWith \nTryWith \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#TryInTryWith","title":"Scope.TryInTryWith","content":"Scope.TryInTryWith \nTryInTryWith \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#WithInTryWith","title":"Scope.WithInTryWith","content":"Scope.WithInTryWith \nWithInTryWith \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#TryFinally","title":"Scope.TryFinally","content":"Scope.TryFinally \nTryFinally \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#TryInTryFinally","title":"Scope.TryInTryFinally","content":"Scope.TryInTryFinally \nTryInTryFinally \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#FinallyInTryFinally","title":"Scope.FinallyInTryFinally","content":"Scope.FinallyInTryFinally \nFinallyInTryFinally \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#ArrayOrList","title":"Scope.ArrayOrList","content":"Scope.ArrayOrList \nArrayOrList \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#ObjExpr","title":"Scope.ObjExpr","content":"Scope.ObjExpr \nObjExpr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#For","title":"Scope.For","content":"Scope.For \nFor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#While","title":"Scope.While","content":"Scope.While \nWhile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Match","title":"Scope.Match","content":"Scope.Match \nMatch \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#MatchBang","title":"Scope.MatchBang","content":"Scope.MatchBang \nMatchBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#MatchLambda","title":"Scope.MatchLambda","content":"Scope.MatchLambda \nMatchLambda \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#MatchClause","title":"Scope.MatchClause","content":"Scope.MatchClause \nMatchClause \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Lambda","title":"Scope.Lambda","content":"Scope.Lambda \nLambda \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Quote","title":"Scope.Quote","content":"Scope.Quote \nQuote \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Record","title":"Scope.Record","content":"Scope.Record \nRecord \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#SpecialFunc","title":"Scope.SpecialFunc","content":"Scope.SpecialFunc \nSpecialFunc \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Do","title":"Scope.Do","content":"Scope.Do \nDo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#New","title":"Scope.New","content":"Scope.New \nNew \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Attribute","title":"Scope.Attribute","content":"Scope.Attribute \nAttribute \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Interface","title":"Scope.Interface","content":"Scope.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#HashDirective","title":"Scope.HashDirective","content":"Scope.HashDirective \nHashDirective \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#LetOrUseBang","title":"Scope.LetOrUseBang","content":"Scope.LetOrUseBang \nLetOrUseBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#TypeExtension","title":"Scope.TypeExtension","content":"Scope.TypeExtension \nTypeExtension \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#YieldOrReturn","title":"Scope.YieldOrReturn","content":"Scope.YieldOrReturn \nYieldOrReturn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#YieldOrReturnBang","title":"Scope.YieldOrReturnBang","content":"Scope.YieldOrReturnBang \nYieldOrReturnBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Tuple","title":"Scope.Tuple","content":"Scope.Tuple \nTuple \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#UnionCase","title":"Scope.UnionCase","content":"Scope.UnionCase \nUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#EnumCase","title":"Scope.EnumCase","content":"Scope.EnumCase \nEnumCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#RecordField","title":"Scope.RecordField","content":"Scope.RecordField \nRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#RecordDefn","title":"Scope.RecordDefn","content":"Scope.RecordDefn \nRecordDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#UnionDefn","title":"Scope.UnionDefn","content":"Scope.UnionDefn \nUnionDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#Comment","title":"Scope.Comment","content":"Scope.Comment \nComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scope.html#XmlDocComment","title":"Scope.XmlDocComment","content":"Scope.XmlDocComment \nXmlDocComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scoperange.html","title":"ScopeRange","content":"ScopeRange \n Stores the range for a construct, the sub-range that should be collapsed for outlinging,\n a tag for the construct type, and a tag for the collapse style \nScopeRange.Scope \nScope \nScopeRange.Collapse \nCollapse \nScopeRange.Range \nRange \nScopeRange.CollapseRange \nCollapseRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scoperange.html#Scope","title":"ScopeRange.Scope","content":"ScopeRange.Scope \nScope \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scoperange.html#Collapse","title":"ScopeRange.Collapse","content":"ScopeRange.Collapse \nCollapse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scoperange.html#Range","title":"ScopeRange.Range","content":"ScopeRange.Range \nRange \n HintSpan in BlockSpan","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-structure-scoperange.html#CollapseRange","title":"ScopeRange.CollapseRange","content":"ScopeRange.CollapseRange \nCollapseRange \n TextSpan in BlockSpan","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unnecessaryparentheses.html","title":"UnnecessaryParentheses","content":"UnnecessaryParentheses \n \nUnnecessaryParentheses.getUnnecessaryParentheses \ngetUnnecessaryParentheses","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unnecessaryparentheses.html#getUnnecessaryParentheses","title":"UnnecessaryParentheses.getUnnecessaryParentheses","content":"UnnecessaryParentheses.getUnnecessaryParentheses \ngetUnnecessaryParentheses \n Gets the ranges of all unnecessary pairs of parentheses in a file.\n\n Note that this may include pairs of nested ranges each of whose\n lack of necessity depends on the other\u0027s presence, such\n that it is valid to remove either set of parentheses but not both, e.g.:\n\n (x.M(y)).N \u2192 (x.M y).N \u21AE x.M(y).N","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unuseddeclarations.html","title":"UnusedDeclarations","content":"UnusedDeclarations \n \nUnusedDeclarations.getUnusedDeclarations \ngetUnusedDeclarations","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unuseddeclarations.html#getUnusedDeclarations","title":"UnusedDeclarations.getUnusedDeclarations","content":"UnusedDeclarations.getUnusedDeclarations \ngetUnusedDeclarations \n Get all unused declarations in a file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unusedopens.html","title":"UnusedOpens","content":"UnusedOpens \n \nUnusedOpens.getUnusedOpens \ngetUnusedOpens","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unusedopens.html#getUnusedOpens","title":"UnusedOpens.getUnusedOpens","content":"UnusedOpens.getUnusedOpens \ngetUnusedOpens \n Get all unused open declarations in a file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-xmldoccomment.html","title":"XmlDocComment","content":"XmlDocComment \n \nXmlDocComment.IsBlank \nIsBlank","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-xmldoccomment.html#IsBlank","title":"XmlDocComment.IsBlank","content":"XmlDocComment.IsBlank \nIsBlank \n if it\u0027s a blank XML comment with trailing \u0022\u003C\u0022, returns Some (index of the \u0022\u003C\u0022), otherwise returns None","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-xmldocparser.html","title":"XmlDocParser","content":"XmlDocParser \n \nXmlDocParser.GetXmlDocables \nGetXmlDocables","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-xmldocparser.html#GetXmlDocables","title":"XmlDocParser.GetXmlDocables","content":"XmlDocParser.GetXmlDocables \nGetXmlDocables \n Get the list of Xml documentation from current source code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblycontenttype.html","title":"AssemblyContentType","content":"AssemblyContentType \n Assembly content type. \nAssemblyContentType.Public \nPublic \nAssemblyContentType.Full \nFull","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblycontenttype.html#Public","title":"AssemblyContentType.Public","content":"AssemblyContentType.Public \nPublic \n Public assembly content only.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblycontenttype.html#Full","title":"AssemblyContentType.Full","content":"AssemblyContentType.Full \nFull \n All assembly content.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html","title":"AssemblySymbol","content":"AssemblySymbol \n Represents type, module, member, function or value in a compiled assembly. \nAssemblySymbol.FullName \nFullName \nAssemblySymbol.CleanedIdents \nCleanedIdents \nAssemblySymbol.Namespace \nNamespace \nAssemblySymbol.NearestRequireQualifiedAccessParent \nNearestRequireQualifiedAccessParent \nAssemblySymbol.TopRequireQualifiedAccessParent \nTopRequireQualifiedAccessParent \nAssemblySymbol.AutoOpenParent \nAutoOpenParent \nAssemblySymbol.Symbol \nSymbol \nAssemblySymbol.Kind \nKind \nAssemblySymbol.UnresolvedSymbol \nUnresolvedSymbol","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#FullName","title":"AssemblySymbol.FullName","content":"AssemblySymbol.FullName \nFullName \n Full entity name as it\u0027s seen in compiled code (raw FSharpEntity.FullName, FSharpValueOrFunction.FullName).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#CleanedIdents","title":"AssemblySymbol.CleanedIdents","content":"AssemblySymbol.CleanedIdents \nCleanedIdents \n Entity name parts with removed module suffixes (Ns.M1Module.M2Module.M3.entity -\u003E Ns.M1.M2.M3.entity)\n and replaced compiled names with display names (FSharpEntity.DisplayName, FSharpValueOrFunction.DisplayName).\n Note: *all* parts are cleaned, not the last one.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#Namespace","title":"AssemblySymbol.Namespace","content":"AssemblySymbol.Namespace \nNamespace \n \u0060FSharpEntity.Namespace\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#NearestRequireQualifiedAccessParent","title":"AssemblySymbol.NearestRequireQualifiedAccessParent","content":"AssemblySymbol.NearestRequireQualifiedAccessParent \nNearestRequireQualifiedAccessParent \n The most narrative parent module that has \u0060RequireQualifiedAccess\u0060 attribute.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#TopRequireQualifiedAccessParent","title":"AssemblySymbol.TopRequireQualifiedAccessParent","content":"AssemblySymbol.TopRequireQualifiedAccessParent \nTopRequireQualifiedAccessParent \n Parent module that has the largest scope and has \u0060RequireQualifiedAccess\u0060 attribute.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#AutoOpenParent","title":"AssemblySymbol.AutoOpenParent","content":"AssemblySymbol.AutoOpenParent \nAutoOpenParent \n Parent module that has \u0060AutoOpen\u0060 attribute.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#Symbol","title":"AssemblySymbol.Symbol","content":"AssemblySymbol.Symbol \nSymbol \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#Kind","title":"AssemblySymbol.Kind","content":"AssemblySymbol.Kind \nKind \n Function that returns \u0060EntityKind\u0060 based of given \u0060LookupKind\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-assemblysymbol.html#UnresolvedSymbol","title":"AssemblySymbol.UnresolvedSymbol","content":"AssemblySymbol.UnresolvedSymbol \nUnresolvedSymbol \n Cache display name and namespace, used for completion.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html","title":"CompletionContext","content":"CompletionContext \n \nCompletionContext.Invalid \nInvalid \nCompletionContext.Inherit \nInherit \nCompletionContext.RecordField \nRecordField \nCompletionContext.RangeOperator \nRangeOperator \nCompletionContext.ParameterList \nParameterList \nCompletionContext.AttributeApplication \nAttributeApplication \nCompletionContext.OpenDeclaration \nOpenDeclaration \nCompletionContext.Type \nType \nCompletionContext.UnionCaseFieldsDeclaration \nUnionCaseFieldsDeclaration \nCompletionContext.TypeAbbreviationOrSingleCaseUnion \nTypeAbbreviationOrSingleCaseUnion \nCompletionContext.Pattern \nPattern \nCompletionContext.MethodOverride \nMethodOverride","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#Invalid","title":"CompletionContext.Invalid","content":"CompletionContext.Invalid \nInvalid \n Completion context cannot be determined due to errors","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#Inherit","title":"CompletionContext.Inherit","content":"CompletionContext.Inherit \nInherit \n Completing something after the inherit keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#RecordField","title":"CompletionContext.RecordField","content":"CompletionContext.RecordField \nRecordField \n Completing records field","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#RangeOperator","title":"CompletionContext.RangeOperator","content":"CompletionContext.RangeOperator \nRangeOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#ParameterList","title":"CompletionContext.ParameterList","content":"CompletionContext.ParameterList \nParameterList \n Completing named parameters\\setters in parameter list of attributes\\constructor\\method calls\n end of name ast node * list of properties\\parameters that were already set","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#AttributeApplication","title":"CompletionContext.AttributeApplication","content":"CompletionContext.AttributeApplication \nAttributeApplication \n Completing an attribute name, outside of the constructor","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#OpenDeclaration","title":"CompletionContext.OpenDeclaration","content":"CompletionContext.OpenDeclaration \nOpenDeclaration \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#Type","title":"CompletionContext.Type","content":"CompletionContext.Type \nType \n Completing a type annotation (e.g. foo (x: |))\n Completing a type application (e.g. typeof\u003Cstr| \u003E)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#UnionCaseFieldsDeclaration","title":"CompletionContext.UnionCaseFieldsDeclaration","content":"CompletionContext.UnionCaseFieldsDeclaration \nUnionCaseFieldsDeclaration \n Completing union case fields declaration (e.g. \u0027A of stri|\u0027 but not \u0027B of tex|: string\u0027)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#TypeAbbreviationOrSingleCaseUnion","title":"CompletionContext.TypeAbbreviationOrSingleCaseUnion","content":"CompletionContext.TypeAbbreviationOrSingleCaseUnion \nTypeAbbreviationOrSingleCaseUnion \n Completing a type abbreviation (e.g. type Long = int6|)\n or a single case union without a bar (type SomeUnion = Abc|)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#Pattern","title":"CompletionContext.Pattern","content":"CompletionContext.Pattern \nPattern \n Completing a pattern in a match clause, member/let binding or lambda","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completioncontext.html#MethodOverride","title":"CompletionContext.MethodOverride","content":"CompletionContext.MethodOverride \nMethodOverride \n Completing a method override (e.g. override this.ToStr|)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html","title":"CompletionItemKind","content":"CompletionItemKind \n \nCompletionItemKind.SuggestedName \nSuggestedName \nCompletionItemKind.Field \nField \nCompletionItemKind.Property \nProperty \nCompletionItemKind.Method \nMethod \nCompletionItemKind.Event \nEvent \nCompletionItemKind.Argument \nArgument \nCompletionItemKind.CustomOperation \nCustomOperation \nCompletionItemKind.Other \nOther","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#SuggestedName","title":"CompletionItemKind.SuggestedName","content":"CompletionItemKind.SuggestedName \nSuggestedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#Field","title":"CompletionItemKind.Field","content":"CompletionItemKind.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#Property","title":"CompletionItemKind.Property","content":"CompletionItemKind.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#Method","title":"CompletionItemKind.Method","content":"CompletionItemKind.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#Event","title":"CompletionItemKind.Event","content":"CompletionItemKind.Event \nEvent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#Argument","title":"CompletionItemKind.Argument","content":"CompletionItemKind.Argument \nArgument \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#CustomOperation","title":"CompletionItemKind.CustomOperation","content":"CompletionItemKind.CustomOperation \nCustomOperation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-completionitemkind.html#Other","title":"CompletionItemKind.Other","content":"CompletionItemKind.Other \nOther \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistinfo.html","title":"DeclarationListInfo","content":"DeclarationListInfo \n Represents a set of declarations in F# source code, with information attached ready for display by an editor.\n Returned by GetDeclarations. \nDeclarationListInfo.Items \nItems \nDeclarationListInfo.IsForType \nIsForType \nDeclarationListInfo.IsError \nIsError \nDeclarationListInfo.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistinfo.html#Items","title":"DeclarationListInfo.Items","content":"DeclarationListInfo.Items \nItems \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistinfo.html#IsForType","title":"DeclarationListInfo.IsForType","content":"DeclarationListInfo.IsForType \nIsForType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistinfo.html#IsError","title":"DeclarationListInfo.IsError","content":"DeclarationListInfo.IsError \nIsError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistinfo.html#Empty","title":"DeclarationListInfo.Empty","content":"DeclarationListInfo.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html","title":"DeclarationListItem","content":"DeclarationListItem \n Represents a declaration in F# source code, with information attached ready for display by an editor.\n Returned by GetDeclarations. \nDeclarationListItem.NameInCode \nNameInCode \nDeclarationListItem.NameInList \nNameInList \nDeclarationListItem.Accessibility \nAccessibility \nDeclarationListItem.IsResolved \nIsResolved \nDeclarationListItem.FullName \nFullName \nDeclarationListItem.IsOwnMember \nIsOwnMember \nDeclarationListItem.Description \nDescription \nDeclarationListItem.NamespaceToOpen \nNamespaceToOpen \nDeclarationListItem.Name \nName \nDeclarationListItem.Glyph \nGlyph \nDeclarationListItem.Kind \nKind \nDeclarationListItem.MinorPriority \nMinorPriority","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#NameInCode","title":"DeclarationListItem.NameInCode","content":"DeclarationListItem.NameInCode \nNameInCode \n Get the text for the declaration as it\u0027s to be inserted into source code.\n\n This is a display name with backticks if necessary.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#NameInList","title":"DeclarationListItem.NameInList","content":"DeclarationListItem.NameInList \nNameInList \n Get the text to display in the declaration list for the declaration.\n\n This is a display name without backticks.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#Accessibility","title":"DeclarationListItem.Accessibility","content":"DeclarationListItem.Accessibility \nAccessibility \n Get the accessibility of the item","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#IsResolved","title":"DeclarationListItem.IsResolved","content":"DeclarationListItem.IsResolved \nIsResolved \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#FullName","title":"DeclarationListItem.FullName","content":"DeclarationListItem.FullName \nFullName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#IsOwnMember","title":"DeclarationListItem.IsOwnMember","content":"DeclarationListItem.IsOwnMember \nIsOwnMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#Description","title":"DeclarationListItem.Description","content":"DeclarationListItem.Description \nDescription \n Get the description","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#NamespaceToOpen","title":"DeclarationListItem.NamespaceToOpen","content":"DeclarationListItem.NamespaceToOpen \nNamespaceToOpen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#Name","title":"DeclarationListItem.Name","content":"DeclarationListItem.Name \nName \n Get the text to display in the declaration list for the declaration.\n\n This is a display name without backticks.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#Glyph","title":"DeclarationListItem.Glyph","content":"DeclarationListItem.Glyph \nGlyph \n Get the glyph to use","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#Kind","title":"DeclarationListItem.Kind","content":"DeclarationListItem.Kind \nKind \n Get the completion kind of the item","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-declarationlistitem.html#MinorPriority","title":"DeclarationListItem.MinorPriority","content":"DeclarationListItem.MinorPriority \nMinorPriority \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitycache.html","title":"EntityCache","content":"EntityCache \n Thread safe wrapper over \u0060IAssemblyContentCache\u0060. \nEntityCache.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nEntityCache.Clear \nClear \nEntityCache.Locking \nLocking","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitycache.html#\u0060\u0060.ctor\u0060\u0060","title":"EntityCache.\u0060\u0060.ctor\u0060\u0060","content":"EntityCache.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitycache.html#Clear","title":"EntityCache.Clear","content":"EntityCache.Clear \nClear \n Clears the cache.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitycache.html#Locking","title":"EntityCache.Locking","content":"EntityCache.Locking \nLocking \n Performs an operation on the cache in thread safe manner.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitykind.html","title":"EntityKind","content":"EntityKind \n \nEntityKind.Attribute \nAttribute \nEntityKind.Type \nType \nEntityKind.FunctionOrValue \nFunctionOrValue \nEntityKind.Module \nModule","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitykind.html#Attribute","title":"EntityKind.Attribute","content":"EntityKind.Attribute \nAttribute \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitykind.html#Type","title":"EntityKind.Type","content":"EntityKind.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitykind.html#FunctionOrValue","title":"EntityKind.FunctionOrValue","content":"EntityKind.FunctionOrValue \nFunctionOrValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-entitykind.html#Module","title":"EntityKind.Module","content":"EntityKind.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html","title":"FSharpGlyph","content":"FSharpGlyph \n \nFSharpGlyph.Class \nClass \nFSharpGlyph.Constant \nConstant \nFSharpGlyph.Delegate \nDelegate \nFSharpGlyph.Enum \nEnum \nFSharpGlyph.EnumMember \nEnumMember \nFSharpGlyph.Event \nEvent \nFSharpGlyph.Exception \nException \nFSharpGlyph.Field \nField \nFSharpGlyph.Interface \nInterface \nFSharpGlyph.Method \nMethod \nFSharpGlyph.OverridenMethod \nOverridenMethod \nFSharpGlyph.Module \nModule \nFSharpGlyph.NameSpace \nNameSpace \nFSharpGlyph.Property \nProperty \nFSharpGlyph.Struct \nStruct \nFSharpGlyph.Typedef \nTypedef \nFSharpGlyph.Type \nType \nFSharpGlyph.Union \nUnion \nFSharpGlyph.Variable \nVariable \nFSharpGlyph.ExtensionMethod \nExtensionMethod \nFSharpGlyph.Error \nError \nFSharpGlyph.TypeParameter \nTypeParameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Class","title":"FSharpGlyph.Class","content":"FSharpGlyph.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Constant","title":"FSharpGlyph.Constant","content":"FSharpGlyph.Constant \nConstant \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Delegate","title":"FSharpGlyph.Delegate","content":"FSharpGlyph.Delegate \nDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Enum","title":"FSharpGlyph.Enum","content":"FSharpGlyph.Enum \nEnum \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#EnumMember","title":"FSharpGlyph.EnumMember","content":"FSharpGlyph.EnumMember \nEnumMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Event","title":"FSharpGlyph.Event","content":"FSharpGlyph.Event \nEvent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Exception","title":"FSharpGlyph.Exception","content":"FSharpGlyph.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Field","title":"FSharpGlyph.Field","content":"FSharpGlyph.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Interface","title":"FSharpGlyph.Interface","content":"FSharpGlyph.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Method","title":"FSharpGlyph.Method","content":"FSharpGlyph.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#OverridenMethod","title":"FSharpGlyph.OverridenMethod","content":"FSharpGlyph.OverridenMethod \nOverridenMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Module","title":"FSharpGlyph.Module","content":"FSharpGlyph.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#NameSpace","title":"FSharpGlyph.NameSpace","content":"FSharpGlyph.NameSpace \nNameSpace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Property","title":"FSharpGlyph.Property","content":"FSharpGlyph.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Struct","title":"FSharpGlyph.Struct","content":"FSharpGlyph.Struct \nStruct \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Typedef","title":"FSharpGlyph.Typedef","content":"FSharpGlyph.Typedef \nTypedef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Type","title":"FSharpGlyph.Type","content":"FSharpGlyph.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Union","title":"FSharpGlyph.Union","content":"FSharpGlyph.Union \nUnion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Variable","title":"FSharpGlyph.Variable","content":"FSharpGlyph.Variable \nVariable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#ExtensionMethod","title":"FSharpGlyph.ExtensionMethod","content":"FSharpGlyph.ExtensionMethod \nExtensionMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#Error","title":"FSharpGlyph.Error","content":"FSharpGlyph.Error \nError \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-fsharpglyph.html#TypeParameter","title":"FSharpGlyph.TypeParameter","content":"FSharpGlyph.TypeParameter \nTypeParameter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalparam.html","title":"FindDeclExternalParam","content":"FindDeclExternalParam \n Represents the type of a single method parameter \nFindDeclExternalParam.IsByRef \nIsByRef \nFindDeclExternalParam.ParameterType \nParameterType \nFindDeclExternalParam.Create \nCreate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalparam.html#IsByRef","title":"FindDeclExternalParam.IsByRef","content":"FindDeclExternalParam.IsByRef \nIsByRef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalparam.html#ParameterType","title":"FindDeclExternalParam.ParameterType","content":"FindDeclExternalParam.ParameterType \nParameterType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalparam.html#Create","title":"FindDeclExternalParam.Create","content":"FindDeclExternalParam.Create \nCreate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html","title":"FindDeclExternalSymbol","content":"FindDeclExternalSymbol \n Represents a symbol in an external (non F#) assembly \nFindDeclExternalSymbol.Type \nType \nFindDeclExternalSymbol.Constructor \nConstructor \nFindDeclExternalSymbol.Method \nMethod \nFindDeclExternalSymbol.Field \nField \nFindDeclExternalSymbol.Event \nEvent \nFindDeclExternalSymbol.Property \nProperty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html#Type","title":"FindDeclExternalSymbol.Type","content":"FindDeclExternalSymbol.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html#Constructor","title":"FindDeclExternalSymbol.Constructor","content":"FindDeclExternalSymbol.Constructor \nConstructor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html#Method","title":"FindDeclExternalSymbol.Method","content":"FindDeclExternalSymbol.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html#Field","title":"FindDeclExternalSymbol.Field","content":"FindDeclExternalSymbol.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html#Event","title":"FindDeclExternalSymbol.Event","content":"FindDeclExternalSymbol.Event \nEvent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html#Property","title":"FindDeclExternalSymbol.Property","content":"FindDeclExternalSymbol.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternaltype.html","title":"FindDeclExternalType","content":"FindDeclExternalType \n Represents a type in an external (non F#) assembly. \nFindDeclExternalType.Type \nType \nFindDeclExternalType.Array \nArray \nFindDeclExternalType.Pointer \nPointer \nFindDeclExternalType.TypeVar \nTypeVar","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternaltype.html#Type","title":"FindDeclExternalType.Type","content":"FindDeclExternalType.Type \nType \n Type defined in non-F# assembly.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternaltype.html#Array","title":"FindDeclExternalType.Array","content":"FindDeclExternalType.Array \nArray \n Array of type that is defined in non-F# assembly.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternaltype.html#Pointer","title":"FindDeclExternalType.Pointer","content":"FindDeclExternalType.Pointer \nPointer \n Pointer defined in non-F# assembly.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclexternaltype.html#TypeVar","title":"FindDeclExternalType.TypeVar","content":"FindDeclExternalType.TypeVar \nTypeVar \n Type variable defined in non-F# assembly.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclfailurereason.html","title":"FindDeclFailureReason","content":"FindDeclFailureReason \n Represents the reason why the GetDeclarationLocation operation failed. \nFindDeclFailureReason.Unknown \nUnknown \nFindDeclFailureReason.NoSourceCode \nNoSourceCode \nFindDeclFailureReason.ProvidedType \nProvidedType \nFindDeclFailureReason.ProvidedMember \nProvidedMember","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclfailurereason.html#Unknown","title":"FindDeclFailureReason.Unknown","content":"FindDeclFailureReason.Unknown \nUnknown \n Generic reason: no particular information about error apart from a message","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclfailurereason.html#NoSourceCode","title":"FindDeclFailureReason.NoSourceCode","content":"FindDeclFailureReason.NoSourceCode \nNoSourceCode \n Source code file is not available","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclfailurereason.html#ProvidedType","title":"FindDeclFailureReason.ProvidedType","content":"FindDeclFailureReason.ProvidedType \nProvidedType \n Trying to find declaration of ProvidedType without TypeProviderDefinitionLocationAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclfailurereason.html#ProvidedMember","title":"FindDeclFailureReason.ProvidedMember","content":"FindDeclFailureReason.ProvidedMember \nProvidedMember \n Trying to find declaration of ProvidedMember without TypeProviderDefinitionLocationAttribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclresult.html","title":"FindDeclResult","content":"FindDeclResult \n Represents the result of the GetDeclarationLocation operation. \nFindDeclResult.DeclNotFound \nDeclNotFound \nFindDeclResult.DeclFound \nDeclFound \nFindDeclResult.ExternalDecl \nExternalDecl","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclresult.html#DeclNotFound","title":"FindDeclResult.DeclNotFound","content":"FindDeclResult.DeclNotFound \nDeclNotFound \n Indicates a declaration location was not found, with an additional reason","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclresult.html#DeclFound","title":"FindDeclResult.DeclFound","content":"FindDeclResult.DeclFound \nDeclFound \n Indicates a declaration location was found","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-finddeclresult.html#ExternalDecl","title":"FindDeclResult.ExternalDecl","content":"FindDeclResult.ExternalDecl \nExternalDecl \n Indicates an external declaration was found","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-iassemblycontentcache.html","title":"IAssemblyContentCache","content":"IAssemblyContentCache \n Assembly content cache. \nIAssemblyContentCache.Set \nSet \nIAssemblyContentCache.TryGet \nTryGet","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-iassemblycontentcache.html#Set","title":"IAssemblyContentCache.Set","content":"IAssemblyContentCache.Set \nSet \n Store an assembly content.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-iassemblycontentcache.html#TryGet","title":"IAssemblyContentCache.TryGet","content":"IAssemblyContentCache.TryGet \nTryGet \n Try get an assembly cached content.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-inheritancecontext.html","title":"InheritanceContext","content":"InheritanceContext \n \nInheritanceContext.Class \nClass \nInheritanceContext.Interface \nInterface \nInheritanceContext.Unknown \nUnknown","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-inheritancecontext.html#Class","title":"InheritanceContext.Class","content":"InheritanceContext.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-inheritancecontext.html#Interface","title":"InheritanceContext.Interface","content":"InheritanceContext.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-inheritancecontext.html#Unknown","title":"InheritanceContext.Unknown","content":"InheritanceContext.Unknown \nUnknown \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontext.html","title":"InsertionContext","content":"InsertionContext \n Insert open namespace context. \nInsertionContext.ScopeKind \nScopeKind \nInsertionContext.Pos \nPos","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontext.html#ScopeKind","title":"InsertionContext.ScopeKind","content":"InsertionContext.ScopeKind \nScopeKind \n Current scope kind.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontext.html#Pos","title":"InsertionContext.Pos","content":"InsertionContext.Pos \nPos \n Current position (F# compiler line number).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontextentity.html","title":"InsertionContextEntity","content":"InsertionContextEntity \n Helper data structure representing a symbol, suitable for implementing unresolved identifiers resolution code fixes. \nInsertionContextEntity.FullRelativeName \nFullRelativeName \nInsertionContextEntity.Qualifier \nQualifier \nInsertionContextEntity.Namespace \nNamespace \nInsertionContextEntity.FullDisplayName \nFullDisplayName \nInsertionContextEntity.LastIdent \nLastIdent","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontextentity.html#FullRelativeName","title":"InsertionContextEntity.FullRelativeName","content":"InsertionContextEntity.FullRelativeName \nFullRelativeName \n Full name, relative to the current scope.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontextentity.html#Qualifier","title":"InsertionContextEntity.Qualifier","content":"InsertionContextEntity.Qualifier \nQualifier \n Ident parts needed to append to the current ident to make it resolvable in current scope.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontextentity.html#Namespace","title":"InsertionContextEntity.Namespace","content":"InsertionContextEntity.Namespace \nNamespace \n Namespace that is needed to open to make the entity resolvable in the current scope.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontextentity.html#FullDisplayName","title":"InsertionContextEntity.FullDisplayName","content":"InsertionContextEntity.FullDisplayName \nFullDisplayName \n Full display name (i.e. last ident plus modules with \u0060RequireQualifiedAccess\u0060 attribute prefixed).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-insertioncontextentity.html#LastIdent","title":"InsertionContextEntity.LastIdent","content":"InsertionContextEntity.LastIdent \nLastIdent \n Last part of the entity\u0027s full name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacedata.html","title":"InterfaceData","content":"InterfaceData \n Capture information about an interface in ASTs \nInterfaceData.Range \nRange \nInterfaceData.TypeParameters \nTypeParameters \nInterfaceData.Interface \nInterface \nInterfaceData.ObjExpr \nObjExpr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacedata.html#Range","title":"InterfaceData.Range","content":"InterfaceData.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacedata.html#TypeParameters","title":"InterfaceData.TypeParameters","content":"InterfaceData.TypeParameters \nTypeParameters \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacedata.html#Interface","title":"InterfaceData.Interface","content":"InterfaceData.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-interfacedata.html#ObjExpr","title":"InterfaceData.ObjExpr","content":"InterfaceData.ObjExpr \nObjExpr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-lookuptype.html","title":"LookupType","content":"LookupType \n Entity lookup type. \nLookupType.Fuzzy \nFuzzy \nLookupType.Precise \nPrecise","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-lookuptype.html#Fuzzy","title":"LookupType.Fuzzy","content":"LookupType.Fuzzy \nFuzzy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-lookuptype.html#Precise","title":"LookupType.Precise","content":"LookupType.Precise \nPrecise \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-maybeunresolvedident.html","title":"MaybeUnresolvedIdent","content":"MaybeUnresolvedIdent \n \u0060ShortIdent\u0060 with a flag indicating if it\u0027s resolved in some scope. \nMaybeUnresolvedIdent.Ident \nIdent \nMaybeUnresolvedIdent.Resolved \nResolved","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-maybeunresolvedident.html#Ident","title":"MaybeUnresolvedIdent.Ident","content":"MaybeUnresolvedIdent.Ident \nIdent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-maybeunresolvedident.html#Resolved","title":"MaybeUnresolvedIdent.Resolved","content":"MaybeUnresolvedIdent.Resolved \nResolved \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroup.html","title":"MethodGroup","content":"MethodGroup \n Represents a group of methods (or other items) returned by GetMethods. \nMethodGroup.MethodName \nMethodName \nMethodGroup.Methods \nMethods","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroup.html#MethodName","title":"MethodGroup.MethodName","content":"MethodGroup.MethodName \nMethodName \n The shared name of the methods (or other items) in the group","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroup.html#Methods","title":"MethodGroup.Methods","content":"MethodGroup.Methods \nMethods \n The methods (or other items) in the group","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html","title":"MethodGroupItem","content":"MethodGroupItem \n Represents one method (or other item) in a method group. The item may represent either a method or \n a single, non-overloaded item such as union case or a named function value. \nMethodGroupItem.Parameters \nParameters \nMethodGroupItem.Description \nDescription \nMethodGroupItem.StaticParameters \nStaticParameters \nMethodGroupItem.HasParameters \nHasParameters \nMethodGroupItem.ReturnTypeText \nReturnTypeText \nMethodGroupItem.HasParamArrayArg \nHasParamArrayArg \nMethodGroupItem.XmlDoc \nXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#Parameters","title":"MethodGroupItem.Parameters","content":"MethodGroupItem.Parameters \nParameters \n The parameters of the method in the overload set","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#Description","title":"MethodGroupItem.Description","content":"MethodGroupItem.Description \nDescription \n The description representation for the method (or other item)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#StaticParameters","title":"MethodGroupItem.StaticParameters","content":"MethodGroupItem.StaticParameters \nStaticParameters \n Does the type name or method support a static arguments list, like TP\u003C42,\u0022foo\u0022\u003E or conn.CreateCommand\u003C42, \u0022foo\u0022\u003E(arg1, arg2)?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#HasParameters","title":"MethodGroupItem.HasParameters","content":"MethodGroupItem.HasParameters \nHasParameters \n Does the method support an arguments list? This is always true except for static type instantiations like TP\u003C42,\u0022foo\u0022\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#ReturnTypeText","title":"MethodGroupItem.ReturnTypeText","content":"MethodGroupItem.ReturnTypeText \nReturnTypeText \n The tagged text for the return type for the method (or other item)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#HasParamArrayArg","title":"MethodGroupItem.HasParamArrayArg","content":"MethodGroupItem.HasParamArrayArg \nHasParamArrayArg \n Does the method support a params list arg?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitem.html#XmlDoc","title":"MethodGroupItem.XmlDoc","content":"MethodGroupItem.XmlDoc \nXmlDoc \n The documentation for the item","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html","title":"MethodGroupItemParameter","content":"MethodGroupItemParameter \n Represents one parameter for one method (or other item) in a group. \nMethodGroupItemParameter.IsOptional \nIsOptional \nMethodGroupItemParameter.ParameterName \nParameterName \nMethodGroupItemParameter.Display \nDisplay \nMethodGroupItemParameter.CanonicalTypeTextForSorting \nCanonicalTypeTextForSorting","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html#IsOptional","title":"MethodGroupItemParameter.IsOptional","content":"MethodGroupItemParameter.IsOptional \nIsOptional \n Is the parameter optional","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html#ParameterName","title":"MethodGroupItemParameter.ParameterName","content":"MethodGroupItemParameter.ParameterName \nParameterName \n The name of the parameter.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html#Display","title":"MethodGroupItemParameter.Display","content":"MethodGroupItemParameter.Display \nDisplay \n The representation for the parameter including its name, its type and visual indicators of other\n information such as whether it is optional.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html#CanonicalTypeTextForSorting","title":"MethodGroupItemParameter.CanonicalTypeTextForSorting","content":"MethodGroupItemParameter.CanonicalTypeTextForSorting \nCanonicalTypeTextForSorting \n A key that can be used for sorting the parameters, used to help sort overloads.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-modulekind.html","title":"ModuleKind","content":"ModuleKind \n \nModuleKind.IsAutoOpen \nIsAutoOpen \nModuleKind.HasModuleSuffix \nHasModuleSuffix","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-modulekind.html#IsAutoOpen","title":"ModuleKind.IsAutoOpen","content":"ModuleKind.IsAutoOpen \nIsAutoOpen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-modulekind.html#HasModuleSuffix","title":"ModuleKind.HasModuleSuffix","content":"ModuleKind.HasModuleSuffix \nHasModuleSuffix \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainer.html","title":"NavigableContainer","content":"NavigableContainer \n \nNavigableContainer.FullName \nFullName \nNavigableContainer.Type \nType \nNavigableContainer.Name \nName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainer.html#FullName","title":"NavigableContainer.FullName","content":"NavigableContainer.FullName \nFullName \n The fully qualified name of the container.\n For files it returns empty string.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainer.html#Type","title":"NavigableContainer.Type","content":"NavigableContainer.Type \nType \n The kind of container.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainer.html#Name","title":"NavigableContainer.Name","content":"NavigableContainer.Name \nName \n The name of the container or file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainertype.html","title":"NavigableContainerType","content":"NavigableContainerType \n \nNavigableContainerType.File \nFile \nNavigableContainerType.Namespace \nNamespace \nNavigableContainerType.Module \nModule \nNavigableContainerType.Type \nType \nNavigableContainerType.Exception \nException","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainertype.html#File","title":"NavigableContainerType.File","content":"NavigableContainerType.File \nFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainertype.html#Namespace","title":"NavigableContainerType.Namespace","content":"NavigableContainerType.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainertype.html#Module","title":"NavigableContainerType.Module","content":"NavigableContainerType.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainertype.html#Type","title":"NavigableContainerType.Type","content":"NavigableContainerType.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigablecontainertype.html#Exception","title":"NavigableContainerType.Exception","content":"NavigableContainerType.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html","title":"NavigableItem","content":"NavigableItem \n \nNavigableItem.Name \nName \nNavigableItem.NeedsBackticks \nNeedsBackticks \nNavigableItem.Range \nRange \nNavigableItem.IsSignature \nIsSignature \nNavigableItem.Kind \nKind \nNavigableItem.Container \nContainer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html#Name","title":"NavigableItem.Name","content":"NavigableItem.Name \nName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html#NeedsBackticks","title":"NavigableItem.NeedsBackticks","content":"NavigableItem.NeedsBackticks \nNeedsBackticks \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html#Range","title":"NavigableItem.Range","content":"NavigableItem.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html#IsSignature","title":"NavigableItem.IsSignature","content":"NavigableItem.IsSignature \nIsSignature \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html#Kind","title":"NavigableItem.Kind","content":"NavigableItem.Kind \nKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitem.html#Container","title":"NavigableItem.Container","content":"NavigableItem.Container \nContainer \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html","title":"NavigableItemKind","content":"NavigableItemKind \n \nNavigableItemKind.Module \nModule \nNavigableItemKind.ModuleAbbreviation \nModuleAbbreviation \nNavigableItemKind.Exception \nException \nNavigableItemKind.Type \nType \nNavigableItemKind.ModuleValue \nModuleValue \nNavigableItemKind.Field \nField \nNavigableItemKind.Property \nProperty \nNavigableItemKind.Constructor \nConstructor \nNavigableItemKind.Member \nMember \nNavigableItemKind.EnumCase \nEnumCase \nNavigableItemKind.UnionCase \nUnionCase","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Module","title":"NavigableItemKind.Module","content":"NavigableItemKind.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#ModuleAbbreviation","title":"NavigableItemKind.ModuleAbbreviation","content":"NavigableItemKind.ModuleAbbreviation \nModuleAbbreviation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Exception","title":"NavigableItemKind.Exception","content":"NavigableItemKind.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Type","title":"NavigableItemKind.Type","content":"NavigableItemKind.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#ModuleValue","title":"NavigableItemKind.ModuleValue","content":"NavigableItemKind.ModuleValue \nModuleValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Field","title":"NavigableItemKind.Field","content":"NavigableItemKind.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Property","title":"NavigableItemKind.Property","content":"NavigableItemKind.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Constructor","title":"NavigableItemKind.Constructor","content":"NavigableItemKind.Constructor \nConstructor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#Member","title":"NavigableItemKind.Member","content":"NavigableItemKind.Member \nMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#EnumCase","title":"NavigableItemKind.EnumCase","content":"NavigableItemKind.EnumCase \nEnumCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigableitemkind.html#UnionCase","title":"NavigableItemKind.UnionCase","content":"NavigableItemKind.UnionCase \nUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html","title":"NavigationEntityKind","content":"NavigationEntityKind \n \nNavigationEntityKind.Namespace \nNamespace \nNavigationEntityKind.Module \nModule \nNavigationEntityKind.Class \nClass \nNavigationEntityKind.Exception \nException \nNavigationEntityKind.Interface \nInterface \nNavigationEntityKind.Record \nRecord \nNavigationEntityKind.Enum \nEnum \nNavigationEntityKind.Union \nUnion","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Namespace","title":"NavigationEntityKind.Namespace","content":"NavigationEntityKind.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Module","title":"NavigationEntityKind.Module","content":"NavigationEntityKind.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Class","title":"NavigationEntityKind.Class","content":"NavigationEntityKind.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Exception","title":"NavigationEntityKind.Exception","content":"NavigationEntityKind.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Interface","title":"NavigationEntityKind.Interface","content":"NavigationEntityKind.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Record","title":"NavigationEntityKind.Record","content":"NavigationEntityKind.Record \nRecord \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Enum","title":"NavigationEntityKind.Enum","content":"NavigationEntityKind.Enum \nEnum \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationentitykind.html#Union","title":"NavigationEntityKind.Union","content":"NavigationEntityKind.Union \nUnion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html","title":"NavigationItem","content":"NavigationItem \n Represents an item to be displayed in the navigation bar \nNavigationItem.Range \nRange \nNavigationItem.LogicalName \nLogicalName \nNavigationItem.EnclosingEntityKind \nEnclosingEntityKind \nNavigationItem.Access \nAccess \nNavigationItem.BodyRange \nBodyRange \nNavigationItem.IsAbstract \nIsAbstract \nNavigationItem.Glyph \nGlyph \nNavigationItem.IsSingleTopLevel \nIsSingleTopLevel \nNavigationItem.Kind \nKind \nNavigationItem.UniqueName \nUniqueName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#Range","title":"NavigationItem.Range","content":"NavigationItem.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#LogicalName","title":"NavigationItem.LogicalName","content":"NavigationItem.LogicalName \nLogicalName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#EnclosingEntityKind","title":"NavigationItem.EnclosingEntityKind","content":"NavigationItem.EnclosingEntityKind \nEnclosingEntityKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#Access","title":"NavigationItem.Access","content":"NavigationItem.Access \nAccess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#BodyRange","title":"NavigationItem.BodyRange","content":"NavigationItem.BodyRange \nBodyRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#IsAbstract","title":"NavigationItem.IsAbstract","content":"NavigationItem.IsAbstract \nIsAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#Glyph","title":"NavigationItem.Glyph","content":"NavigationItem.Glyph \nGlyph \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#IsSingleTopLevel","title":"NavigationItem.IsSingleTopLevel","content":"NavigationItem.IsSingleTopLevel \nIsSingleTopLevel \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#Kind","title":"NavigationItem.Kind","content":"NavigationItem.Kind \nKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitem.html#UniqueName","title":"NavigationItem.UniqueName","content":"NavigationItem.UniqueName \nUniqueName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html","title":"NavigationItemKind","content":"NavigationItemKind \n Indicates a kind of item to show in an F# navigation bar \nNavigationItemKind.Namespace \nNamespace \nNavigationItemKind.ModuleFile \nModuleFile \nNavigationItemKind.Exception \nException \nNavigationItemKind.Module \nModule \nNavigationItemKind.Type \nType \nNavigationItemKind.Method \nMethod \nNavigationItemKind.Property \nProperty \nNavigationItemKind.Field \nField \nNavigationItemKind.Other \nOther","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Namespace","title":"NavigationItemKind.Namespace","content":"NavigationItemKind.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#ModuleFile","title":"NavigationItemKind.ModuleFile","content":"NavigationItemKind.ModuleFile \nModuleFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Exception","title":"NavigationItemKind.Exception","content":"NavigationItemKind.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Module","title":"NavigationItemKind.Module","content":"NavigationItemKind.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Type","title":"NavigationItemKind.Type","content":"NavigationItemKind.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Method","title":"NavigationItemKind.Method","content":"NavigationItemKind.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Property","title":"NavigationItemKind.Property","content":"NavigationItemKind.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Field","title":"NavigationItemKind.Field","content":"NavigationItemKind.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitemkind.html#Other","title":"NavigationItemKind.Other","content":"NavigationItemKind.Other \nOther \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitems.html","title":"NavigationItems","content":"NavigationItems \n Represents result of \u0027GetNavigationItems\u0027 operation - this contains\n all the members and currently selected indices. First level correspond to\n types \u0026 modules and second level are methods etc. \nNavigationItems.Declarations \nDeclarations","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationitems.html#Declarations","title":"NavigationItems.Declarations","content":"NavigationItems.Declarations \nDeclarations \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationtopleveldeclaration.html","title":"NavigationTopLevelDeclaration","content":"NavigationTopLevelDeclaration \n Represents top-level declarations (that should be in the type drop-down)\n with nested declarations (that can be shown in the member drop-down) \nNavigationTopLevelDeclaration.Declaration \nDeclaration \nNavigationTopLevelDeclaration.Nested \nNested","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationtopleveldeclaration.html#Declaration","title":"NavigationTopLevelDeclaration.Declaration","content":"NavigationTopLevelDeclaration.Declaration \nDeclaration \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-navigationtopleveldeclaration.html#Nested","title":"NavigationTopLevelDeclaration.Nested","content":"NavigationTopLevelDeclaration.Nested \nNested \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-openstatementinsertionpoint.html","title":"OpenStatementInsertionPoint","content":"OpenStatementInsertionPoint \n Where open statements should be added. \nOpenStatementInsertionPoint.TopLevel \nTopLevel \nOpenStatementInsertionPoint.Nearest \nNearest","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-openstatementinsertionpoint.html#TopLevel","title":"OpenStatementInsertionPoint.TopLevel","content":"OpenStatementInsertionPoint.TopLevel \nTopLevel \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-openstatementinsertionpoint.html#Nearest","title":"OpenStatementInsertionPoint.Nearest","content":"OpenStatementInsertionPoint.Nearest \nNearest \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html","title":"ParameterLocations","content":"ParameterLocations \n Represents the locations relevant to activating parameter info in an IDE \nParameterLocations.LongId \nLongId \nParameterLocations.ArgumentLocations \nArgumentLocations \nParameterLocations.IsThereACloseParen \nIsThereACloseParen \nParameterLocations.TupleEndLocations \nTupleEndLocations \nParameterLocations.LongIdEndLocation \nLongIdEndLocation \nParameterLocations.LongIdStartLocation \nLongIdStartLocation \nParameterLocations.NamedParamNames \nNamedParamNames \nParameterLocations.OpenParenLocation \nOpenParenLocation \nParameterLocations.Find \nFind","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#LongId","title":"ParameterLocations.LongId","content":"ParameterLocations.LongId \nLongId \n The text of the long identifier prior to the open-parentheses","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#ArgumentLocations","title":"ParameterLocations.ArgumentLocations","content":"ParameterLocations.ArgumentLocations \nArgumentLocations \n Array of locations for each argument, and a flag if that argument is named","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#IsThereACloseParen","title":"ParameterLocations.IsThereACloseParen","content":"ParameterLocations.IsThereACloseParen \nIsThereACloseParen \n Is false if either this is a call without parens \u0022f x\u0022 or the parser recovered as in \u0022f(x,y\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#TupleEndLocations","title":"ParameterLocations.TupleEndLocations","content":"ParameterLocations.TupleEndLocations \nTupleEndLocations \n The locations of commas and close parenthesis (or, last char of last arg, if no final close parenthesis)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#LongIdEndLocation","title":"ParameterLocations.LongIdEndLocation","content":"ParameterLocations.LongIdEndLocation \nLongIdEndLocation \n The end location of long identifier prior to the open-parentheses","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#LongIdStartLocation","title":"ParameterLocations.LongIdStartLocation","content":"ParameterLocations.LongIdStartLocation \nLongIdStartLocation \n The start location of long identifier prior to the open-parentheses","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#NamedParamNames","title":"ParameterLocations.NamedParamNames","content":"ParameterLocations.NamedParamNames \nNamedParamNames \n Either empty or a name if an actual named parameter; f(0,a=4,?b=None) would be [|None; Some \u0022a\u0022; Some \u0022b\u0022|]","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#OpenParenLocation","title":"ParameterLocations.OpenParenLocation","content":"ParameterLocations.OpenParenLocation \nOpenParenLocation \n The location of the open-parentheses","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-parameterlocations.html#Find","title":"ParameterLocations.Find","content":"ParameterLocations.Find \nFind \n Find the information about parameter info locations at a particular source location","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-partiallongname.html","title":"PartialLongName","content":"PartialLongName \n Qualified long name. \nPartialLongName.Empty \nEmpty \nPartialLongName.QualifyingIdents \nQualifyingIdents \nPartialLongName.PartialIdent \nPartialIdent \nPartialLongName.EndColumn \nEndColumn \nPartialLongName.LastDotPos \nLastDotPos","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-partiallongname.html#Empty","title":"PartialLongName.Empty","content":"PartialLongName.Empty \nEmpty \n Empty partial long name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-partiallongname.html#QualifyingIdents","title":"PartialLongName.QualifyingIdents","content":"PartialLongName.QualifyingIdents \nQualifyingIdents \n Qualifying idents, prior to the last dot, not including the last part.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-partiallongname.html#PartialIdent","title":"PartialLongName.PartialIdent","content":"PartialLongName.PartialIdent \nPartialIdent \n Last part of long ident.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-partiallongname.html#EndColumn","title":"PartialLongName.EndColumn","content":"PartialLongName.EndColumn \nEndColumn \n The column number at the end of full partial name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-partiallongname.html#LastDotPos","title":"PartialLongName.LastDotPos","content":"PartialLongName.LastDotPos \nLastDotPos \n Position of the last dot.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-patterncontext.html","title":"PatternContext","content":"PatternContext \n \nPatternContext.PositionalUnionCaseField \nPositionalUnionCaseField \nPatternContext.NamedUnionCaseField \nNamedUnionCaseField \nPatternContext.UnionCaseFieldIdentifier \nUnionCaseFieldIdentifier \nPatternContext.RecordFieldIdentifier \nRecordFieldIdentifier \nPatternContext.Other \nOther","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-patterncontext.html#PositionalUnionCaseField","title":"PatternContext.PositionalUnionCaseField","content":"PatternContext.PositionalUnionCaseField \nPositionalUnionCaseField \nCompleting union case field pattern (e.g. fun (Some v| ) -\u003E ) or fun (Some (v| )) -\u003E ). In theory, this could also be parameterized active pattern usage.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-patterncontext.html#NamedUnionCaseField","title":"PatternContext.NamedUnionCaseField","content":"PatternContext.NamedUnionCaseField \nNamedUnionCaseField \n Completing union case field pattern (e.g. fun (Some (Value = v| )) -\u003E )","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-patterncontext.html#UnionCaseFieldIdentifier","title":"PatternContext.UnionCaseFieldIdentifier","content":"PatternContext.UnionCaseFieldIdentifier \nUnionCaseFieldIdentifier \n Completing union case field identifier in a pattern (e.g. fun (Case (field1 = a; fie| )) -\u003E )","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-patterncontext.html#RecordFieldIdentifier","title":"PatternContext.RecordFieldIdentifier","content":"PatternContext.RecordFieldIdentifier \nRecordFieldIdentifier \n Completing a record field identifier in a pattern (e.g. fun { Field1 = a; Fie| } -\u003E )","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-patterncontext.html#Other","title":"PatternContext.Other","content":"PatternContext.Other \nOther \n Any other position in a pattern that does not need special handling","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-recordcontext.html","title":"RecordContext","content":"RecordContext \n \nRecordContext.CopyOnUpdate \nCopyOnUpdate \nRecordContext.Constructor \nConstructor \nRecordContext.Empty \nEmpty \nRecordContext.New \nNew \nRecordContext.Declaration \nDeclaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-recordcontext.html#CopyOnUpdate","title":"RecordContext.CopyOnUpdate","content":"RecordContext.CopyOnUpdate \nCopyOnUpdate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-recordcontext.html#Constructor","title":"RecordContext.Constructor","content":"RecordContext.Constructor \nConstructor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-recordcontext.html#Empty","title":"RecordContext.Empty","content":"RecordContext.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-recordcontext.html#New","title":"RecordContext.New","content":"RecordContext.New \nNew \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-recordcontext.html#Declaration","title":"RecordContext.Declaration","content":"RecordContext.Declaration \nDeclaration \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-scopekind.html","title":"ScopeKind","content":"ScopeKind \n Kind of lexical scope. \nScopeKind.Namespace \nNamespace \nScopeKind.TopModule \nTopModule \nScopeKind.NestedModule \nNestedModule \nScopeKind.OpenDeclaration \nOpenDeclaration \nScopeKind.HashDirective \nHashDirective","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-scopekind.html#Namespace","title":"ScopeKind.Namespace","content":"ScopeKind.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-scopekind.html#TopModule","title":"ScopeKind.TopModule","content":"ScopeKind.TopModule \nTopModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-scopekind.html#NestedModule","title":"ScopeKind.NestedModule","content":"ScopeKind.NestedModule \nNestedModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-scopekind.html#OpenDeclaration","title":"ScopeKind.OpenDeclaration","content":"ScopeKind.OpenDeclaration \nOpenDeclaration \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-scopekind.html#HashDirective","title":"ScopeKind.HashDirective","content":"ScopeKind.HashDirective \nHashDirective \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationitem.html","title":"SemanticClassificationItem","content":"SemanticClassificationItem \n \nSemanticClassificationItem.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nSemanticClassificationItem.Range \nRange \nSemanticClassificationItem.Type \nType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationitem.html#\u0060\u0060.ctor\u0060\u0060","title":"SemanticClassificationItem.\u0060\u0060.ctor\u0060\u0060","content":"SemanticClassificationItem.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationitem.html#Range","title":"SemanticClassificationItem.Range","content":"SemanticClassificationItem.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationitem.html#Type","title":"SemanticClassificationItem.Type","content":"SemanticClassificationItem.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html","title":"SemanticClassificationType","content":"SemanticClassificationType \n A kind that determines what range in a source\u0027s text is semantically classified as after type-checking. \nSemanticClassificationType.ReferenceType \nReferenceType \nSemanticClassificationType.ValueType \nValueType \nSemanticClassificationType.UnionCase \nUnionCase \nSemanticClassificationType.UnionCaseField \nUnionCaseField \nSemanticClassificationType.Function \nFunction \nSemanticClassificationType.Property \nProperty \nSemanticClassificationType.MutableVar \nMutableVar \nSemanticClassificationType.Module \nModule \nSemanticClassificationType.Namespace \nNamespace \nSemanticClassificationType.Printf \nPrintf \nSemanticClassificationType.ComputationExpression \nComputationExpression \nSemanticClassificationType.IntrinsicFunction \nIntrinsicFunction \nSemanticClassificationType.Enumeration \nEnumeration \nSemanticClassificationType.Interface \nInterface \nSemanticClassificationType.TypeArgument \nTypeArgument \nSemanticClassificationType.Operator \nOperator \nSemanticClassificationType.DisposableType \nDisposableType \nSemanticClassificationType.DisposableTopLevelValue \nDisposableTopLevelValue \nSemanticClassificationType.DisposableLocalValue \nDisposableLocalValue \nSemanticClassificationType.Method \nMethod \nSemanticClassificationType.ExtensionMethod \nExtensionMethod \nSemanticClassificationType.ConstructorForReferenceType \nConstructorForReferenceType \nSemanticClassificationType.ConstructorForValueType \nConstructorForValueType \nSemanticClassificationType.Literal \nLiteral \nSemanticClassificationType.RecordField \nRecordField \nSemanticClassificationType.MutableRecordField \nMutableRecordField \nSemanticClassificationType.RecordFieldAsFunction \nRecordFieldAsFunction \nSemanticClassificationType.Exception \nException \nSemanticClassificationType.Field \nField \nSemanticClassificationType.Event \nEvent \nSemanticClassificationType.Delegate \nDelegate \nSemanticClassificationType.NamedArgument \nNamedArgument \nSemanticClassificationType.Value \nValue \nSemanticClassificationType.LocalValue \nLocalValue \nSemanticClassificationType.Type \nType \nSemanticClassificationType.TypeDef \nTypeDef \nSemanticClassificationType.Plaintext \nPlaintext","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#ReferenceType","title":"SemanticClassificationType.ReferenceType","content":"SemanticClassificationType.ReferenceType \nReferenceType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#ValueType","title":"SemanticClassificationType.ValueType","content":"SemanticClassificationType.ValueType \nValueType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#UnionCase","title":"SemanticClassificationType.UnionCase","content":"SemanticClassificationType.UnionCase \nUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#UnionCaseField","title":"SemanticClassificationType.UnionCaseField","content":"SemanticClassificationType.UnionCaseField \nUnionCaseField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Function","title":"SemanticClassificationType.Function","content":"SemanticClassificationType.Function \nFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Property","title":"SemanticClassificationType.Property","content":"SemanticClassificationType.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#MutableVar","title":"SemanticClassificationType.MutableVar","content":"SemanticClassificationType.MutableVar \nMutableVar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Module","title":"SemanticClassificationType.Module","content":"SemanticClassificationType.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Namespace","title":"SemanticClassificationType.Namespace","content":"SemanticClassificationType.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Printf","title":"SemanticClassificationType.Printf","content":"SemanticClassificationType.Printf \nPrintf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#ComputationExpression","title":"SemanticClassificationType.ComputationExpression","content":"SemanticClassificationType.ComputationExpression \nComputationExpression \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#IntrinsicFunction","title":"SemanticClassificationType.IntrinsicFunction","content":"SemanticClassificationType.IntrinsicFunction \nIntrinsicFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Enumeration","title":"SemanticClassificationType.Enumeration","content":"SemanticClassificationType.Enumeration \nEnumeration \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Interface","title":"SemanticClassificationType.Interface","content":"SemanticClassificationType.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#TypeArgument","title":"SemanticClassificationType.TypeArgument","content":"SemanticClassificationType.TypeArgument \nTypeArgument \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Operator","title":"SemanticClassificationType.Operator","content":"SemanticClassificationType.Operator \nOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#DisposableType","title":"SemanticClassificationType.DisposableType","content":"SemanticClassificationType.DisposableType \nDisposableType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#DisposableTopLevelValue","title":"SemanticClassificationType.DisposableTopLevelValue","content":"SemanticClassificationType.DisposableTopLevelValue \nDisposableTopLevelValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#DisposableLocalValue","title":"SemanticClassificationType.DisposableLocalValue","content":"SemanticClassificationType.DisposableLocalValue \nDisposableLocalValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Method","title":"SemanticClassificationType.Method","content":"SemanticClassificationType.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#ExtensionMethod","title":"SemanticClassificationType.ExtensionMethod","content":"SemanticClassificationType.ExtensionMethod \nExtensionMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#ConstructorForReferenceType","title":"SemanticClassificationType.ConstructorForReferenceType","content":"SemanticClassificationType.ConstructorForReferenceType \nConstructorForReferenceType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#ConstructorForValueType","title":"SemanticClassificationType.ConstructorForValueType","content":"SemanticClassificationType.ConstructorForValueType \nConstructorForValueType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Literal","title":"SemanticClassificationType.Literal","content":"SemanticClassificationType.Literal \nLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#RecordField","title":"SemanticClassificationType.RecordField","content":"SemanticClassificationType.RecordField \nRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#MutableRecordField","title":"SemanticClassificationType.MutableRecordField","content":"SemanticClassificationType.MutableRecordField \nMutableRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#RecordFieldAsFunction","title":"SemanticClassificationType.RecordFieldAsFunction","content":"SemanticClassificationType.RecordFieldAsFunction \nRecordFieldAsFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Exception","title":"SemanticClassificationType.Exception","content":"SemanticClassificationType.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Field","title":"SemanticClassificationType.Field","content":"SemanticClassificationType.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Event","title":"SemanticClassificationType.Event","content":"SemanticClassificationType.Event \nEvent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Delegate","title":"SemanticClassificationType.Delegate","content":"SemanticClassificationType.Delegate \nDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#NamedArgument","title":"SemanticClassificationType.NamedArgument","content":"SemanticClassificationType.NamedArgument \nNamedArgument \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Value","title":"SemanticClassificationType.Value","content":"SemanticClassificationType.Value \nValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#LocalValue","title":"SemanticClassificationType.LocalValue","content":"SemanticClassificationType.LocalValue \nLocalValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Type","title":"SemanticClassificationType.Type","content":"SemanticClassificationType.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#TypeDef","title":"SemanticClassificationType.TypeDef","content":"SemanticClassificationType.TypeDef \nTypeDef \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationtype.html#Plaintext","title":"SemanticClassificationType.Plaintext","content":"SemanticClassificationType.Plaintext \nPlaintext \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationview.html","title":"SemanticClassificationView","content":"SemanticClassificationView \n Provides a read only view to iterate over the semantic classification contents. \nSemanticClassificationView.ForEach \nForEach","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-semanticclassificationview.html#ForEach","title":"SemanticClassificationView.ForEach","content":"SemanticClassificationView.ForEach \nForEach \n Iterate through the stored SemanticClassificationItem entries from the store and apply the passed function on each entry.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-shortidents.html","title":"ShortIdents","content":"ShortIdents \n An array of \u0060ShortIdent\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelement.html","title":"ToolTipElement","content":"ToolTipElement \n A single tool tip display element \nToolTipElement.Single \nSingle \nToolTipElement.None \nNone \nToolTipElement.Group \nGroup \nToolTipElement.CompositionError \nCompositionError","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelement.html#Single","title":"ToolTipElement.Single","content":"ToolTipElement.Single \nSingle \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelement.html#None","title":"ToolTipElement.None","content":"ToolTipElement.None \nNone \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelement.html#Group","title":"ToolTipElement.Group","content":"ToolTipElement.Group \nGroup \n A single type, method, etc with comment. May represent a method overload group.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelement.html#CompositionError","title":"ToolTipElement.CompositionError","content":"ToolTipElement.CompositionError \nCompositionError \n An error occurred formatting this element","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html","title":"ToolTipElementData","content":"ToolTipElementData \n A single data tip display element \nToolTipElementData.Symbol \nSymbol \nToolTipElementData.MainDescription \nMainDescription \nToolTipElementData.XmlDoc \nXmlDoc \nToolTipElementData.TypeMapping \nTypeMapping \nToolTipElementData.Remarks \nRemarks \nToolTipElementData.ParamName \nParamName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html#Symbol","title":"ToolTipElementData.Symbol","content":"ToolTipElementData.Symbol \nSymbol \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html#MainDescription","title":"ToolTipElementData.MainDescription","content":"ToolTipElementData.MainDescription \nMainDescription \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html#XmlDoc","title":"ToolTipElementData.XmlDoc","content":"ToolTipElementData.XmlDoc \nXmlDoc \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html#TypeMapping","title":"ToolTipElementData.TypeMapping","content":"ToolTipElementData.TypeMapping \nTypeMapping \n typar instantiation text, to go after xml","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html#Remarks","title":"ToolTipElementData.Remarks","content":"ToolTipElementData.Remarks \nRemarks \n Extra text, goes at the end","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltipelementdata.html#ParamName","title":"ToolTipElementData.ParamName","content":"ToolTipElementData.ParamName \nParamName \n Parameter name","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltiptext.html","title":"ToolTipText","content":"ToolTipText \n Information for building a tool tip box. \nToolTipText.ToolTipText \nToolTipText","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tooltiptext.html#ToolTipText","title":"ToolTipText.ToolTipText","content":"ToolTipText.ToolTipText \nToolTipText \n A list of data tip elements to display.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tupledargumentlocation.html","title":"TupledArgumentLocation","content":"TupledArgumentLocation \n Represents the location of a tupled argument, which can optionally be a named argument. \nTupledArgumentLocation.IsNamedArgument \nIsNamedArgument \nTupledArgumentLocation.ArgumentRange \nArgumentRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tupledargumentlocation.html#IsNamedArgument","title":"TupledArgumentLocation.IsNamedArgument","content":"TupledArgumentLocation.IsNamedArgument \nIsNamedArgument \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-tupledargumentlocation.html#ArgumentRange","title":"TupledArgumentLocation.ArgumentRange","content":"TupledArgumentLocation.ArgumentRange \nArgumentRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unresolvedsymbol.html","title":"UnresolvedSymbol","content":"UnresolvedSymbol \n \nUnresolvedSymbol.FullName \nFullName \nUnresolvedSymbol.DisplayName \nDisplayName \nUnresolvedSymbol.Namespace \nNamespace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unresolvedsymbol.html#FullName","title":"UnresolvedSymbol.FullName","content":"UnresolvedSymbol.FullName \nFullName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unresolvedsymbol.html#DisplayName","title":"UnresolvedSymbol.DisplayName","content":"UnresolvedSymbol.DisplayName \nDisplayName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-unresolvedsymbol.html#Namespace","title":"UnresolvedSymbol.Namespace","content":"UnresolvedSymbol.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-xmldocable.html","title":"XmlDocable","content":"XmlDocable \n Represent an Xml documentation block in source code \nXmlDocable.XmlDocable \nXmlDocable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-editorservices-xmldocable.html#XmlDocable","title":"XmlDocable.XmlDocable","content":"XmlDocable.XmlDocable \nXmlDocable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-filesystemautoopens.html","title":"FileSystemAutoOpens","content":"FileSystemAutoOpens \n \nFileSystemAutoOpens.FileSystem \nFileSystem","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-filesystemautoopens.html#FileSystem","title":"FileSystemAutoOpens.FileSystem","content":"FileSystemAutoOpens.FileSystem \nFileSystem \n The global hook into the file system","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html","title":"StreamExtensions","content":"StreamExtensions \n \nStreamExtensions.GetWriter \nGetWriter \nStreamExtensions.WriteAllLines \nWriteAllLines \nStreamExtensions.Write \nWrite \nStreamExtensions.GetReader \nGetReader \nStreamExtensions.ReadBytes \nReadBytes \nStreamExtensions.ReadAllBytes \nReadAllBytes \nStreamExtensions.ReadAllText \nReadAllText \nStreamExtensions.ReadLines \nReadLines \nStreamExtensions.ReadAllLines \nReadAllLines \nStreamExtensions.WriteAllText \nWriteAllText \nStreamExtensions.AsByteMemory \nAsByteMemory","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#GetWriter","title":"StreamExtensions.GetWriter","content":"StreamExtensions.GetWriter \nGetWriter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#WriteAllLines","title":"StreamExtensions.WriteAllLines","content":"StreamExtensions.WriteAllLines \nWriteAllLines \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#Write","title":"StreamExtensions.Write","content":"StreamExtensions.Write \nWrite \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#GetReader","title":"StreamExtensions.GetReader","content":"StreamExtensions.GetReader \nGetReader \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#ReadBytes","title":"StreamExtensions.ReadBytes","content":"StreamExtensions.ReadBytes \nReadBytes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#ReadAllBytes","title":"StreamExtensions.ReadAllBytes","content":"StreamExtensions.ReadAllBytes \nReadAllBytes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#ReadAllText","title":"StreamExtensions.ReadAllText","content":"StreamExtensions.ReadAllText \nReadAllText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#ReadLines","title":"StreamExtensions.ReadLines","content":"StreamExtensions.ReadLines \nReadLines \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#ReadAllLines","title":"StreamExtensions.ReadAllLines","content":"StreamExtensions.ReadAllLines \nReadAllLines \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#WriteAllText","title":"StreamExtensions.WriteAllText","content":"StreamExtensions.WriteAllText \nWriteAllText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-streamextensions.html#AsByteMemory","title":"StreamExtensions.AsByteMemory","content":"StreamExtensions.AsByteMemory \nAsByteMemory \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html","title":"ByteMemory","content":"ByteMemory \n A view over bytes.\n May be backed by managed or unmanaged memory, or memory mapped file. \nByteMemory.AsReadOnly \nAsReadOnly \nByteMemory.AsReadOnlyStream \nAsReadOnlyStream \nByteMemory.AsStream \nAsStream \nByteMemory.Copy \nCopy \nByteMemory.CopyTo \nCopyTo \nByteMemory.ReadAllBytes \nReadAllBytes \nByteMemory.ReadBytes \nReadBytes \nByteMemory.ReadInt32 \nReadInt32 \nByteMemory.ReadUInt16 \nReadUInt16 \nByteMemory.ReadUtf8String \nReadUtf8String \nByteMemory.Slice \nSlice \nByteMemory.ToArray \nToArray \nByteMemory.Length \nLength \nByteMemory.Item \nItem \nByteMemory.FromArray \nFromArray \nByteMemory.FromArray \nFromArray \nByteMemory.FromMemoryMappedFile \nFromMemoryMappedFile \nByteMemory.FromUnsafePointer \nFromUnsafePointer \nByteMemory.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#AsReadOnly","title":"ByteMemory.AsReadOnly","content":"ByteMemory.AsReadOnly \nAsReadOnly \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#AsReadOnlyStream","title":"ByteMemory.AsReadOnlyStream","content":"ByteMemory.AsReadOnlyStream \nAsReadOnlyStream \n Get a stream representation of the backing memory.\n Disposing this will not free up any of the backing memory.\n Stream cannot be written to.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#AsStream","title":"ByteMemory.AsStream","content":"ByteMemory.AsStream \nAsStream \n Get a stream representation of the backing memory.\n Disposing this will not free up any of the backing memory.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#Copy","title":"ByteMemory.Copy","content":"ByteMemory.Copy \nCopy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#CopyTo","title":"ByteMemory.CopyTo","content":"ByteMemory.CopyTo \nCopyTo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#ReadAllBytes","title":"ByteMemory.ReadAllBytes","content":"ByteMemory.ReadAllBytes \nReadAllBytes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#ReadBytes","title":"ByteMemory.ReadBytes","content":"ByteMemory.ReadBytes \nReadBytes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#ReadInt32","title":"ByteMemory.ReadInt32","content":"ByteMemory.ReadInt32 \nReadInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#ReadUInt16","title":"ByteMemory.ReadUInt16","content":"ByteMemory.ReadUInt16 \nReadUInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#ReadUtf8String","title":"ByteMemory.ReadUtf8String","content":"ByteMemory.ReadUtf8String \nReadUtf8String \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#Slice","title":"ByteMemory.Slice","content":"ByteMemory.Slice \nSlice \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#ToArray","title":"ByteMemory.ToArray","content":"ByteMemory.ToArray \nToArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#Length","title":"ByteMemory.Length","content":"ByteMemory.Length \nLength \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#Item","title":"ByteMemory.Item","content":"ByteMemory.Item \nItem \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#FromArray","title":"ByteMemory.FromArray","content":"ByteMemory.FromArray \nFromArray \n Creates a ByteMemory object that is backed by a byte array.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#FromArray","title":"ByteMemory.FromArray","content":"ByteMemory.FromArray \nFromArray \n Creates a ByteMemory object that is backed by a byte array with the specified offset and length.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#FromMemoryMappedFile","title":"ByteMemory.FromMemoryMappedFile","content":"ByteMemory.FromMemoryMappedFile \nFromMemoryMappedFile \n Create a ByteMemory object that has a backing memory mapped file.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#FromUnsafePointer","title":"ByteMemory.FromUnsafePointer","content":"ByteMemory.FromUnsafePointer \nFromUnsafePointer \n Creates a ByteMemory object that is backed by a raw pointer.\n Use with care.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-bytememory.html#Empty","title":"ByteMemory.Empty","content":"ByteMemory.Empty \nEmpty \n Empty byte memory.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultassemblyloader.html","title":"DefaultAssemblyLoader","content":"DefaultAssemblyLoader \n Default implementation for IAssemblyLoader \nDefaultAssemblyLoader.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultassemblyloader.html#\u0060\u0060.ctor\u0060\u0060","title":"DefaultAssemblyLoader.\u0060\u0060.ctor\u0060\u0060","content":"DefaultAssemblyLoader.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html","title":"DefaultFileSystem","content":"DefaultFileSystem \n Represents a default (memory-mapped) implementation of the file system \nDefaultFileSystem.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDefaultFileSystem.ChangeExtensionShim \nChangeExtensionShim \nDefaultFileSystem.CopyShim \nCopyShim \nDefaultFileSystem.DirectoryCreateShim \nDirectoryCreateShim \nDefaultFileSystem.DirectoryDeleteShim \nDirectoryDeleteShim \nDefaultFileSystem.DirectoryExistsShim \nDirectoryExistsShim \nDefaultFileSystem.EnumerateDirectoriesShim \nEnumerateDirectoriesShim \nDefaultFileSystem.EnumerateFilesShim \nEnumerateFilesShim \nDefaultFileSystem.FileDeleteShim \nFileDeleteShim \nDefaultFileSystem.FileExistsShim \nFileExistsShim \nDefaultFileSystem.GetCreationTimeShim \nGetCreationTimeShim \nDefaultFileSystem.GetDirectoryNameShim \nGetDirectoryNameShim \nDefaultFileSystem.GetFullFilePathInDirectoryShim \nGetFullFilePathInDirectoryShim \nDefaultFileSystem.GetFullPathShim \nGetFullPathShim \nDefaultFileSystem.GetLastWriteTimeShim \nGetLastWriteTimeShim \nDefaultFileSystem.GetTempPathShim \nGetTempPathShim \nDefaultFileSystem.IsInvalidPathShim \nIsInvalidPathShim \nDefaultFileSystem.IsPathRootedShim \nIsPathRootedShim \nDefaultFileSystem.IsStableFileHeuristic \nIsStableFileHeuristic \nDefaultFileSystem.NormalizePathShim \nNormalizePathShim \nDefaultFileSystem.OpenFileForReadShim \nOpenFileForReadShim \nDefaultFileSystem.OpenFileForWriteShim \nOpenFileForWriteShim \nDefaultFileSystem.AssemblyLoader \nAssemblyLoader","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#\u0060\u0060.ctor\u0060\u0060","title":"DefaultFileSystem.\u0060\u0060.ctor\u0060\u0060","content":"DefaultFileSystem.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Create a default implementation of the file system","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#ChangeExtensionShim","title":"DefaultFileSystem.ChangeExtensionShim","content":"DefaultFileSystem.ChangeExtensionShim \nChangeExtensionShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#CopyShim","title":"DefaultFileSystem.CopyShim","content":"DefaultFileSystem.CopyShim \nCopyShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#DirectoryCreateShim","title":"DefaultFileSystem.DirectoryCreateShim","content":"DefaultFileSystem.DirectoryCreateShim \nDirectoryCreateShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#DirectoryDeleteShim","title":"DefaultFileSystem.DirectoryDeleteShim","content":"DefaultFileSystem.DirectoryDeleteShim \nDirectoryDeleteShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#DirectoryExistsShim","title":"DefaultFileSystem.DirectoryExistsShim","content":"DefaultFileSystem.DirectoryExistsShim \nDirectoryExistsShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#EnumerateDirectoriesShim","title":"DefaultFileSystem.EnumerateDirectoriesShim","content":"DefaultFileSystem.EnumerateDirectoriesShim \nEnumerateDirectoriesShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#EnumerateFilesShim","title":"DefaultFileSystem.EnumerateFilesShim","content":"DefaultFileSystem.EnumerateFilesShim \nEnumerateFilesShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#FileDeleteShim","title":"DefaultFileSystem.FileDeleteShim","content":"DefaultFileSystem.FileDeleteShim \nFileDeleteShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#FileExistsShim","title":"DefaultFileSystem.FileExistsShim","content":"DefaultFileSystem.FileExistsShim \nFileExistsShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#GetCreationTimeShim","title":"DefaultFileSystem.GetCreationTimeShim","content":"DefaultFileSystem.GetCreationTimeShim \nGetCreationTimeShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#GetDirectoryNameShim","title":"DefaultFileSystem.GetDirectoryNameShim","content":"DefaultFileSystem.GetDirectoryNameShim \nGetDirectoryNameShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#GetFullFilePathInDirectoryShim","title":"DefaultFileSystem.GetFullFilePathInDirectoryShim","content":"DefaultFileSystem.GetFullFilePathInDirectoryShim \nGetFullFilePathInDirectoryShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#GetFullPathShim","title":"DefaultFileSystem.GetFullPathShim","content":"DefaultFileSystem.GetFullPathShim \nGetFullPathShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#GetLastWriteTimeShim","title":"DefaultFileSystem.GetLastWriteTimeShim","content":"DefaultFileSystem.GetLastWriteTimeShim \nGetLastWriteTimeShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#GetTempPathShim","title":"DefaultFileSystem.GetTempPathShim","content":"DefaultFileSystem.GetTempPathShim \nGetTempPathShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#IsInvalidPathShim","title":"DefaultFileSystem.IsInvalidPathShim","content":"DefaultFileSystem.IsInvalidPathShim \nIsInvalidPathShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#IsPathRootedShim","title":"DefaultFileSystem.IsPathRootedShim","content":"DefaultFileSystem.IsPathRootedShim \nIsPathRootedShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#IsStableFileHeuristic","title":"DefaultFileSystem.IsStableFileHeuristic","content":"DefaultFileSystem.IsStableFileHeuristic \nIsStableFileHeuristic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#NormalizePathShim","title":"DefaultFileSystem.NormalizePathShim","content":"DefaultFileSystem.NormalizePathShim \nNormalizePathShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#OpenFileForReadShim","title":"DefaultFileSystem.OpenFileForReadShim","content":"DefaultFileSystem.OpenFileForReadShim \nOpenFileForReadShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#OpenFileForWriteShim","title":"DefaultFileSystem.OpenFileForWriteShim","content":"DefaultFileSystem.OpenFileForWriteShim \nOpenFileForWriteShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-defaultfilesystem.html#AssemblyLoader","title":"DefaultFileSystem.AssemblyLoader","content":"DefaultFileSystem.AssemblyLoader \nAssemblyLoader \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-iassemblyloader.html","title":"IAssemblyLoader","content":"IAssemblyLoader \n Type which we use to load assemblies. \nIAssemblyLoader.AssemblyLoad \nAssemblyLoad \nIAssemblyLoader.AssemblyLoadFrom \nAssemblyLoadFrom","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-iassemblyloader.html#AssemblyLoad","title":"IAssemblyLoader.AssemblyLoad","content":"IAssemblyLoader.AssemblyLoad \nAssemblyLoad \n Used to load a dependency for F# Interactive and in an unused corner-case of type provider loading","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-iassemblyloader.html#AssemblyLoadFrom","title":"IAssemblyLoader.AssemblyLoadFrom","content":"IAssemblyLoader.AssemblyLoadFrom \nAssemblyLoadFrom \n Used to load type providers and located assemblies in F# Interactive","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html","title":"IFileSystem","content":"IFileSystem \n Represents a shim for the file system \nIFileSystem.ChangeExtensionShim \nChangeExtensionShim \nIFileSystem.CopyShim \nCopyShim \nIFileSystem.DirectoryCreateShim \nDirectoryCreateShim \nIFileSystem.DirectoryDeleteShim \nDirectoryDeleteShim \nIFileSystem.DirectoryExistsShim \nDirectoryExistsShim \nIFileSystem.EnumerateDirectoriesShim \nEnumerateDirectoriesShim \nIFileSystem.EnumerateFilesShim \nEnumerateFilesShim \nIFileSystem.FileDeleteShim \nFileDeleteShim \nIFileSystem.FileExistsShim \nFileExistsShim \nIFileSystem.GetCreationTimeShim \nGetCreationTimeShim \nIFileSystem.GetDirectoryNameShim \nGetDirectoryNameShim \nIFileSystem.GetFullFilePathInDirectoryShim \nGetFullFilePathInDirectoryShim \nIFileSystem.GetFullPathShim \nGetFullPathShim \nIFileSystem.GetLastWriteTimeShim \nGetLastWriteTimeShim \nIFileSystem.GetTempPathShim \nGetTempPathShim \nIFileSystem.IsInvalidPathShim \nIsInvalidPathShim \nIFileSystem.IsPathRootedShim \nIsPathRootedShim \nIFileSystem.IsStableFileHeuristic \nIsStableFileHeuristic \nIFileSystem.NormalizePathShim \nNormalizePathShim \nIFileSystem.OpenFileForReadShim \nOpenFileForReadShim \nIFileSystem.OpenFileForWriteShim \nOpenFileForWriteShim \nIFileSystem.AssemblyLoader \nAssemblyLoader","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#ChangeExtensionShim","title":"IFileSystem.ChangeExtensionShim","content":"IFileSystem.ChangeExtensionShim \nChangeExtensionShim \n A shim over Path.ChangeExtension","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#CopyShim","title":"IFileSystem.CopyShim","content":"IFileSystem.CopyShim \nCopyShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#DirectoryCreateShim","title":"IFileSystem.DirectoryCreateShim","content":"IFileSystem.DirectoryCreateShim \nDirectoryCreateShim \n A shim over Directory.Exists, but returns a string, the FullName of the resulting\n DirectoryInfo.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#DirectoryDeleteShim","title":"IFileSystem.DirectoryDeleteShim","content":"IFileSystem.DirectoryDeleteShim \nDirectoryDeleteShim \n A shim over Directory.Delete","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#DirectoryExistsShim","title":"IFileSystem.DirectoryExistsShim","content":"IFileSystem.DirectoryExistsShim \nDirectoryExistsShim \n A shim over Directory.Exists","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#EnumerateDirectoriesShim","title":"IFileSystem.EnumerateDirectoriesShim","content":"IFileSystem.EnumerateDirectoriesShim \nEnumerateDirectoriesShim \n A shim over Directory.EnumerateDirectories","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#EnumerateFilesShim","title":"IFileSystem.EnumerateFilesShim","content":"IFileSystem.EnumerateFilesShim \nEnumerateFilesShim \n A shim over Directory.EnumerateFiles","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#FileDeleteShim","title":"IFileSystem.FileDeleteShim","content":"IFileSystem.FileDeleteShim \nFileDeleteShim \n A shim over File.Delete","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#FileExistsShim","title":"IFileSystem.FileExistsShim","content":"IFileSystem.FileExistsShim \nFileExistsShim \n A shim over File.Exists","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#GetCreationTimeShim","title":"IFileSystem.GetCreationTimeShim","content":"IFileSystem.GetCreationTimeShim \nGetCreationTimeShim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#GetDirectoryNameShim","title":"IFileSystem.GetDirectoryNameShim","content":"IFileSystem.GetDirectoryNameShim \nGetDirectoryNameShim \n A shim for getting directory name from path","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#GetFullFilePathInDirectoryShim","title":"IFileSystem.GetFullFilePathInDirectoryShim","content":"IFileSystem.GetFullFilePathInDirectoryShim \nGetFullFilePathInDirectoryShim \n Take in a directory, filename, and return canonicalized path to the file name in directory.\n If file name path is rooted, ignores directory and returns file name path.\n Otherwise, combines directory with file name and gets full path via GetFullPathShim(string).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#GetFullPathShim","title":"IFileSystem.GetFullPathShim","content":"IFileSystem.GetFullPathShim \nGetFullPathShim \n Take in a file name with an absolute path, and return the same file name\n but canonicalized with respect to extra path separators (e.g. C:\\\\\\\\foo.txt)\n and \u0027..\u0027 portions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#GetLastWriteTimeShim","title":"IFileSystem.GetLastWriteTimeShim","content":"IFileSystem.GetLastWriteTimeShim \nGetLastWriteTimeShim \n Utc time of the last modification","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#GetTempPathShim","title":"IFileSystem.GetTempPathShim","content":"IFileSystem.GetTempPathShim \nGetTempPathShim \n A shim over Path.GetTempPath","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#IsInvalidPathShim","title":"IFileSystem.IsInvalidPathShim","content":"IFileSystem.IsInvalidPathShim \nIsInvalidPathShim \n A shim over Path.IsInvalidPath","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#IsPathRootedShim","title":"IFileSystem.IsPathRootedShim","content":"IFileSystem.IsPathRootedShim \nIsPathRootedShim \n A shim over Path.IsPathRooted","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#IsStableFileHeuristic","title":"IFileSystem.IsStableFileHeuristic","content":"IFileSystem.IsStableFileHeuristic \nIsStableFileHeuristic \n Used to determine if a file will not be subject to deletion during the lifetime of a typical client process.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#NormalizePathShim","title":"IFileSystem.NormalizePathShim","content":"IFileSystem.NormalizePathShim \nNormalizePathShim \n Removes relative parts from any full paths","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#OpenFileForReadShim","title":"IFileSystem.OpenFileForReadShim","content":"IFileSystem.OpenFileForReadShim \nOpenFileForReadShim \n Open the file for read, returns ByteMemory, uses either FileStream (for smaller files) or MemoryMappedFile (for potentially big files, such as dlls).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#OpenFileForWriteShim","title":"IFileSystem.OpenFileForWriteShim","content":"IFileSystem.OpenFileForWriteShim \nOpenFileForWriteShim \n Open the file for writing. Returns a Stream.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-io-ifilesystem.html#AssemblyLoader","title":"IFileSystem.AssemblyLoader","content":"IFileSystem.AssemblyLoader \nAssemblyLoader \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers.html","title":"CtrlBreakHandlers","content":"CtrlBreakHandlers \n \nCtrlBreakHandlers.CtrlBreakClient \nCtrlBreakClient \nCtrlBreakHandlers.CtrlBreakService \nCtrlBreakService","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakclient.html","title":"CtrlBreakClient","content":"CtrlBreakClient \n \nCtrlBreakClient.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCtrlBreakClient.Interrupt \nInterrupt","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakclient.html#\u0060\u0060.ctor\u0060\u0060","title":"CtrlBreakClient.\u0060\u0060.ctor\u0060\u0060","content":"CtrlBreakClient.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakclient.html#Interrupt","title":"CtrlBreakClient.Interrupt","content":"CtrlBreakClient.Interrupt \nInterrupt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html","title":"CtrlBreakService","content":"CtrlBreakService \n \nCtrlBreakService.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCtrlBreakService.Interrupt \nInterrupt \nCtrlBreakService.Run \nRun","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html#\u0060\u0060.ctor\u0060\u0060","title":"CtrlBreakService.\u0060\u0060.ctor\u0060\u0060","content":"CtrlBreakService.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html#Interrupt","title":"CtrlBreakService.Interrupt","content":"CtrlBreakService.Interrupt \nInterrupt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html#Run","title":"CtrlBreakService.Run","content":"CtrlBreakService.Run \nRun \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell.html","title":"Shell","content":"Shell \n \nShell.Settings \nSettings \nShell.CompilerInputStream \nCompilerInputStream \nShell.CompilerOutputStream \nCompilerOutputStream \nShell.EvaluationEventArgs \nEvaluationEventArgs \nShell.FsiBoundValue \nFsiBoundValue \nShell.FsiCompilationException \nFsiCompilationException \nShell.FsiEvaluationSession \nFsiEvaluationSession \nShell.FsiEvaluationSessionHostConfig \nFsiEvaluationSessionHostConfig \nShell.FsiValue \nFsiValue","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings.html","title":"Settings","content":"Settings \n A default implementation of the \u0027fsi\u0027 object, used by GetDefaultConfiguration() \nSettings.IEventLoop \nIEventLoop \nSettings.InteractiveSettings \nInteractiveSettings \nSettings.fsi \nfsi","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings.html#fsi","title":"Settings.fsi","content":"Settings.fsi \nfsi \n A default implementation of the \u0027fsi\u0027 object, used by GetDefaultConfiguration(). Note this\n is a different object to FSharp.Compiler.Interactive.Settings.fsi in FSharp.Compiler.Interactive.Settings.dll,\n which can be used as an alternative implementation of the interactive settings if passed as a parameter\n to GetDefaultConfiguration(fsiObj).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html","title":"IEventLoop","content":"IEventLoop \n\u003Cpre\u003EAn event loop used by the currently executing F# Interactive session to execute code\n in the context of a GUI or another event-based system.\u003C/pre\u003E \nIEventLoop.Invoke \nInvoke \nIEventLoop.Run \nRun \nIEventLoop.ScheduleRestart \nScheduleRestart","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html#Invoke","title":"IEventLoop.Invoke","content":"IEventLoop.Invoke \nInvoke \nRequest that the given operation be run synchronously on the event loop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html#Run","title":"IEventLoop.Run","content":"IEventLoop.Run \nRun \nRun the event loop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html#ScheduleRestart","title":"IEventLoop.ScheduleRestart","content":"IEventLoop.ScheduleRestart \nScheduleRestart \nSchedule a restart for the event loop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html","title":"InteractiveSettings","content":"InteractiveSettings \n Operations supported by the currently executing F# Interactive session. \nInteractiveSettings.AddPrintTransformer \nAddPrintTransformer \nInteractiveSettings.AddPrinter \nAddPrinter \nInteractiveSettings.ShowIEnumerable \nShowIEnumerable \nInteractiveSettings.FormatProvider \nFormatProvider \nInteractiveSettings.PrintDepth \nPrintDepth \nInteractiveSettings.ShowProperties \nShowProperties \nInteractiveSettings.CommandLineArgs \nCommandLineArgs \nInteractiveSettings.PrintSize \nPrintSize \nInteractiveSettings.FloatingPointFormat \nFloatingPointFormat \nInteractiveSettings.ShowDeclarationValues \nShowDeclarationValues \nInteractiveSettings.PrintWidth \nPrintWidth \nInteractiveSettings.PrintLength \nPrintLength \nInteractiveSettings.EventLoop \nEventLoop","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#AddPrintTransformer","title":"InteractiveSettings.AddPrintTransformer","content":"InteractiveSettings.AddPrintTransformer \nAddPrintTransformer \nRegister a print transformer that controls the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#AddPrinter","title":"InteractiveSettings.AddPrinter","content":"InteractiveSettings.AddPrinter \nAddPrinter \nRegister a printer that controls the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#ShowIEnumerable","title":"InteractiveSettings.ShowIEnumerable","content":"InteractiveSettings.ShowIEnumerable \nShowIEnumerable \nWhen set to \u0027false\u0027, disables the display of sequences in the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#FormatProvider","title":"InteractiveSettings.FormatProvider","content":"InteractiveSettings.FormatProvider \nFormatProvider \nGet or set the format provider used in the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#PrintDepth","title":"InteractiveSettings.PrintDepth","content":"InteractiveSettings.PrintDepth \nPrintDepth \nGet or set the print depth of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#ShowProperties","title":"InteractiveSettings.ShowProperties","content":"InteractiveSettings.ShowProperties \nShowProperties \nWhen set to \u0027false\u0027, disables the display of properties of evaluated objects in the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#CommandLineArgs","title":"InteractiveSettings.CommandLineArgs","content":"InteractiveSettings.CommandLineArgs \nCommandLineArgs \n\u003Cpre\u003EThe command line arguments after ignoring the arguments relevant to the interactive\n environment and replacing the first argument with the name of the last script file,\n if any. Thus \u0027fsi.exe test1.fs test2.fs -- hello goodbye\u0027 will give arguments\n \u0027test2.fs\u0027, \u0027hello\u0027, \u0027goodbye\u0027. This value will normally be different to those\n returned by System.Environment.GetCommandLineArgs.\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#PrintSize","title":"InteractiveSettings.PrintSize","content":"InteractiveSettings.PrintSize \nPrintSize \nGet or set the total print size of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#FloatingPointFormat","title":"InteractiveSettings.FloatingPointFormat","content":"InteractiveSettings.FloatingPointFormat \nFloatingPointFormat \nGet or set the floating point format used in the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#ShowDeclarationValues","title":"InteractiveSettings.ShowDeclarationValues","content":"InteractiveSettings.ShowDeclarationValues \nShowDeclarationValues \nWhen set to \u0027false\u0027, disables the display of declaration values in the output of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#PrintWidth","title":"InteractiveSettings.PrintWidth","content":"InteractiveSettings.PrintWidth \nPrintWidth \nGet or set the print width of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#PrintLength","title":"InteractiveSettings.PrintLength","content":"InteractiveSettings.PrintLength \nPrintLength \nGet or set the total print length of the interactive session.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html#EventLoop","title":"InteractiveSettings.EventLoop","content":"InteractiveSettings.EventLoop \nEventLoop \nGets or sets a the current event loop being used to process interactions.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-compilerinputstream.html","title":"CompilerInputStream","content":"CompilerInputStream \n Defines a read-only input stream used to feed content to the hosted F# Interactive dynamic compiler. \nCompilerInputStream.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCompilerInputStream.Add \nAdd","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-compilerinputstream.html#\u0060\u0060.ctor\u0060\u0060","title":"CompilerInputStream.\u0060\u0060.ctor\u0060\u0060","content":"CompilerInputStream.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-compilerinputstream.html#Add","title":"CompilerInputStream.Add","content":"CompilerInputStream.Add \nAdd \n Feeds content into the stream.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-compileroutputstream.html","title":"CompilerOutputStream","content":"CompilerOutputStream \n Defines a write-only stream used to capture output of the hosted F# Interactive dynamic compiler. \nCompilerOutputStream.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nCompilerOutputStream.Read \nRead","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-compileroutputstream.html#\u0060\u0060.ctor\u0060\u0060","title":"CompilerOutputStream.\u0060\u0060.ctor\u0060\u0060","content":"CompilerOutputStream.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-compileroutputstream.html#Read","title":"CompilerOutputStream.Read","content":"CompilerOutputStream.Read \nRead \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html","title":"EvaluationEventArgs","content":"EvaluationEventArgs \n \nEvaluationEventArgs.Name \nName \nEvaluationEventArgs.FsiValue \nFsiValue \nEvaluationEventArgs.ImplementationDeclaration \nImplementationDeclaration \nEvaluationEventArgs.SymbolUse \nSymbolUse \nEvaluationEventArgs.Symbol \nSymbol","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html#Name","title":"EvaluationEventArgs.Name","content":"EvaluationEventArgs.Name \nName \n The display name of the symbol defined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html#FsiValue","title":"EvaluationEventArgs.FsiValue","content":"EvaluationEventArgs.FsiValue \nFsiValue \n The value of the symbol defined, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html#ImplementationDeclaration","title":"EvaluationEventArgs.ImplementationDeclaration","content":"EvaluationEventArgs.ImplementationDeclaration \nImplementationDeclaration \n The details of the expression defined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html#SymbolUse","title":"EvaluationEventArgs.SymbolUse","content":"EvaluationEventArgs.SymbolUse \nSymbolUse \n The FSharpSymbolUse for the symbol defined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html#Symbol","title":"EvaluationEventArgs.Symbol","content":"EvaluationEventArgs.Symbol \nSymbol \n The symbol defined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsiboundvalue.html","title":"FsiBoundValue","content":"FsiBoundValue \n Represents an evaluated F# value that is bound to an identifier \nFsiBoundValue.Name \nName \nFsiBoundValue.Value \nValue","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsiboundvalue.html#Name","title":"FsiBoundValue.Name","content":"FsiBoundValue.Name \nName \n The identifier of the value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsiboundvalue.html#Value","title":"FsiBoundValue.Value","content":"FsiBoundValue.Value \nValue \n The evaluated F# value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsicompilationexception.html","title":"FsiCompilationException","content":"FsiCompilationException \n Thrown when there was an error compiling the given code in FSI. \nFsiCompilationException.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFsiCompilationException.ErrorInfos \nErrorInfos","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsicompilationexception.html#\u0060\u0060.ctor\u0060\u0060","title":"FsiCompilationException.\u0060\u0060.ctor\u0060\u0060","content":"FsiCompilationException.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsicompilationexception.html#ErrorInfos","title":"FsiCompilationException.ErrorInfos","content":"FsiCompilationException.ErrorInfos \nErrorInfos \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html","title":"FsiEvaluationSession","content":"FsiEvaluationSession \n Represents an F# Interactive evaluation session. \nFsiEvaluationSession.AddBoundValue \nAddBoundValue \nFsiEvaluationSession.EvalExpression \nEvalExpression \nFsiEvaluationSession.EvalExpression \nEvalExpression \nFsiEvaluationSession.EvalExpressionNonThrowing \nEvalExpressionNonThrowing \nFsiEvaluationSession.EvalExpressionNonThrowing \nEvalExpressionNonThrowing \nFsiEvaluationSession.EvalInteraction \nEvalInteraction \nFsiEvaluationSession.EvalInteraction \nEvalInteraction \nFsiEvaluationSession.EvalInteractionNonThrowing \nEvalInteractionNonThrowing \nFsiEvaluationSession.EvalInteractionNonThrowing \nEvalInteractionNonThrowing \nFsiEvaluationSession.EvalScript \nEvalScript \nFsiEvaluationSession.EvalScriptNonThrowing \nEvalScriptNonThrowing \nFsiEvaluationSession.FormatValue \nFormatValue \nFsiEvaluationSession.GetBoundValues \nGetBoundValues \nFsiEvaluationSession.GetCompletions \nGetCompletions \nFsiEvaluationSession.Interrupt \nInterrupt \nFsiEvaluationSession.ParseAndCheckInteraction \nParseAndCheckInteraction \nFsiEvaluationSession.ReportUnhandledException \nReportUnhandledException \nFsiEvaluationSession.Run \nRun \nFsiEvaluationSession.TryFindBoundValue \nTryFindBoundValue \nFsiEvaluationSession.ValueBound \nValueBound \nFsiEvaluationSession.LCID \nLCID \nFsiEvaluationSession.InteractiveChecker \nInteractiveChecker \nFsiEvaluationSession.PartialAssemblySignatureUpdated \nPartialAssemblySignatureUpdated \nFsiEvaluationSession.CurrentPartialAssemblySignature \nCurrentPartialAssemblySignature \nFsiEvaluationSession.DynamicAssemblies \nDynamicAssemblies \nFsiEvaluationSession.IsGui \nIsGui \nFsiEvaluationSession.Create \nCreate \nFsiEvaluationSession.GetDefaultConfiguration \nGetDefaultConfiguration \nFsiEvaluationSession.GetDefaultConfiguration \nGetDefaultConfiguration \nFsiEvaluationSession.GetDefaultConfiguration \nGetDefaultConfiguration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#AddBoundValue","title":"FsiEvaluationSession.AddBoundValue","content":"FsiEvaluationSession.AddBoundValue \nAddBoundValue \n Creates a root-level value with the given name and .NET object.\n If the .NET object contains types from assemblies that are not referenced in the interactive session, it will try to implicitly resolve them by default configuration.\n Name must be a valid identifier.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalExpression","title":"FsiEvaluationSession.EvalExpression","content":"FsiEvaluationSession.EvalExpression \nEvalExpression \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors are sent to the output writer. Parsing is performed on the current thread, and execution is performed\n synchronously on the \u0027main\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.\n The scriptFileName parameter is used to report errors including this file name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalExpression","title":"FsiEvaluationSession.EvalExpression","content":"FsiEvaluationSession.EvalExpression \nEvalExpression \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors are sent to the output writer. Parsing is performed on the current thread, and execution is performed\n synchronously on the \u0027main\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalExpressionNonThrowing","title":"FsiEvaluationSession.EvalExpressionNonThrowing","content":"FsiEvaluationSession.EvalExpressionNonThrowing \nEvalExpressionNonThrowing \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors and warnings are collected apart from any exception arising from execution\n which is returned via a Choice. Parsing is performed on the current thread, and execution is performed\n synchronously on the \u0027main\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.\n The scriptFileName parameter is used to report errors including this file name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalExpressionNonThrowing","title":"FsiEvaluationSession.EvalExpressionNonThrowing","content":"FsiEvaluationSession.EvalExpressionNonThrowing \nEvalExpressionNonThrowing \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors and warnings are collected apart from any exception arising from execution\n which is returned via a Choice. Parsing is performed on the current thread, and execution is performed\n synchronously on the \u0027main\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalInteraction","title":"FsiEvaluationSession.EvalInteraction","content":"FsiEvaluationSession.EvalInteraction \nEvalInteraction \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors are sent to the output writer, a \u0027true\u0027 return value indicates there\n were no errors overall. Execution is performed on the \u0027Run()\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.\n The scriptFileName parameter is used to report errors including this file name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalInteraction","title":"FsiEvaluationSession.EvalInteraction","content":"FsiEvaluationSession.EvalInteraction \nEvalInteraction \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors are sent to the output writer, a \u0027true\u0027 return value indicates there\n were no errors overall. Execution is performed on the \u0027Run()\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalInteractionNonThrowing","title":"FsiEvaluationSession.EvalInteractionNonThrowing","content":"FsiEvaluationSession.EvalInteractionNonThrowing \nEvalInteractionNonThrowing \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors and warnings are collected apart from any exception arising from execution\n which is returned via a Choice. Execution is performed on the \u0027Run()\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.\n The scriptFileName parameter is used to report errors including this file name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalInteractionNonThrowing","title":"FsiEvaluationSession.EvalInteractionNonThrowing","content":"FsiEvaluationSession.EvalInteractionNonThrowing \nEvalInteractionNonThrowing \n Execute the code as if it had been entered as one or more interactions, with an\n implicit termination at the end of the input. Stop on first error, discarding the rest\n of the input. Errors and warnings are collected apart from any exception arising from execution\n which is returned via a Choice. Execution is performed on the \u0027Run()\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalScript","title":"FsiEvaluationSession.EvalScript","content":"FsiEvaluationSession.EvalScript \nEvalScript \n Execute the given script. Stop on first error, discarding the rest\n of the script. Errors are sent to the output writer, a \u0027true\u0027 return value indicates there\n were no errors overall. Execution is performed on the \u0027Run()\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#EvalScriptNonThrowing","title":"FsiEvaluationSession.EvalScriptNonThrowing","content":"FsiEvaluationSession.EvalScriptNonThrowing \nEvalScriptNonThrowing \n Execute the given script. Stop on first error, discarding the rest\n of the script. Errors and warnings are collected apart from any exception arising from execution\n which is returned via a Choice. Execution is performed on the \u0027Run()\u0027 thread.\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#FormatValue","title":"FsiEvaluationSession.FormatValue","content":"FsiEvaluationSession.FormatValue \nFormatValue \n Format a value to a string using the current PrintDepth, PrintLength etc settings provided by the active fsi configuration object","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#GetBoundValues","title":"FsiEvaluationSession.GetBoundValues","content":"FsiEvaluationSession.GetBoundValues \nGetBoundValues \n Gets the root-level values that are bound to an identifier","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#GetCompletions","title":"FsiEvaluationSession.GetCompletions","content":"FsiEvaluationSession.GetCompletions \nGetCompletions \n A host calls this to get the completions for a long identifier, e.g. in the console\n\n Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered\n by input from \u0027stdin\u0027.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#Interrupt","title":"FsiEvaluationSession.Interrupt","content":"FsiEvaluationSession.Interrupt \nInterrupt \n A host calls this to request an interrupt on the evaluation thread.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#ParseAndCheckInteraction","title":"FsiEvaluationSession.ParseAndCheckInteraction","content":"FsiEvaluationSession.ParseAndCheckInteraction \nParseAndCheckInteraction \n Typecheck the given script fragment in the type checking context implied by the current state\n of F# Interactive. The results can be used to access intellisense, perform resolutions,\n check brace matching and other information.\n\n Operations may be run concurrently with other requests to the InteractiveChecker.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#ReportUnhandledException","title":"FsiEvaluationSession.ReportUnhandledException","content":"FsiEvaluationSession.ReportUnhandledException \nReportUnhandledException \n A host calls this to report an unhandled exception in a standard way, e.g. an exception on the GUI thread gets printed to stderr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#Run","title":"FsiEvaluationSession.Run","content":"FsiEvaluationSession.Run \nRun \n\u003Cpre\u003E Load the dummy interaction, load the initial files, and,\n if interacting, start the background thread to read the standard input.\n\n Performs these steps:\n - Load the dummy interaction, if any\n - Set up exception handling, if any\n - Load the initial files, if any\n - Start the background thread to read the standard input, if any\n - Sit in the GUI event loop indefinitely, if needed\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#TryFindBoundValue","title":"FsiEvaluationSession.TryFindBoundValue","content":"FsiEvaluationSession.TryFindBoundValue \nTryFindBoundValue \n Tries to find a root-level value that is bound to the given identifier","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#ValueBound","title":"FsiEvaluationSession.ValueBound","content":"FsiEvaluationSession.ValueBound \nValueBound \n Event fires when a root-level value is bound to an identifier, e.g., via \u0060let x = ...\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#LCID","title":"FsiEvaluationSession.LCID","content":"FsiEvaluationSession.LCID \nLCID \n A host calls this to get the active language ID if provided by fsi-server-lcid","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#InteractiveChecker","title":"FsiEvaluationSession.InteractiveChecker","content":"FsiEvaluationSession.InteractiveChecker \nInteractiveChecker \n The single, global interactive checker to use in conjunction with other operations\n on the FsiEvaluationSession.\n\n If you are using an FsiEvaluationSession in this process, you should only use this InteractiveChecker\n for additional checking operations.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#PartialAssemblySignatureUpdated","title":"FsiEvaluationSession.PartialAssemblySignatureUpdated","content":"FsiEvaluationSession.PartialAssemblySignatureUpdated \nPartialAssemblySignatureUpdated \n Raised when an interaction is successfully typechecked and executed, resulting in an update to the\n type checking state.\n\n This event is triggered after parsing and checking, either via input from \u0027stdin\u0027, or via a call to EvalInteraction.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#CurrentPartialAssemblySignature","title":"FsiEvaluationSession.CurrentPartialAssemblySignature","content":"FsiEvaluationSession.CurrentPartialAssemblySignature \nCurrentPartialAssemblySignature \n Get a handle to the resolved view of the current signature of the incrementally generated assembly.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#DynamicAssemblies","title":"FsiEvaluationSession.DynamicAssemblies","content":"FsiEvaluationSession.DynamicAssemblies \nDynamicAssemblies \n Get all the dynamically generated assemblies","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#IsGui","title":"FsiEvaluationSession.IsGui","content":"FsiEvaluationSession.IsGui \nIsGui \n A host calls this to determine if the --gui parameter is active","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#Create","title":"FsiEvaluationSession.Create","content":"FsiEvaluationSession.Create \nCreate \nCreate an FsiEvaluationSession, reading from the given text input, writing to the given text output and error writers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#GetDefaultConfiguration","title":"FsiEvaluationSession.GetDefaultConfiguration","content":"FsiEvaluationSession.GetDefaultConfiguration \nGetDefaultConfiguration \n Get a configuration that uses a private inbuilt implementation of the \u0027fsi\u0027 object and does not\n implicitly reference FSharp.Compiler.Interactive.Settings.dll.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#GetDefaultConfiguration","title":"FsiEvaluationSession.GetDefaultConfiguration","content":"FsiEvaluationSession.GetDefaultConfiguration \nGetDefaultConfiguration \n Get a configuration that uses the \u0027fsi\u0027 object (normally from FSharp.Compiler.Interactive.Settings.dll,\n an object from another DLL with identical characteristics) to provide an implementation of the configuration.\n FSharp.Compiler.Interactive.Settings.dll is referenced by default.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html#GetDefaultConfiguration","title":"FsiEvaluationSession.GetDefaultConfiguration","content":"FsiEvaluationSession.GetDefaultConfiguration \nGetDefaultConfiguration \n Get a configuration that uses the \u0027fsi\u0027 object (normally from FSharp.Compiler.Interactive.Settings.dll,\n an object from another DLL with identical characteristics) to provide an implementation of the configuration.\n The flag indicates if FSharp.Compiler.Interactive.Settings.dll is referenced by default.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html","title":"FsiEvaluationSessionHostConfig","content":"FsiEvaluationSessionHostConfig \n \nFsiEvaluationSessionHostConfig.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFsiEvaluationSessionHostConfig.EventLoopInvoke \nEventLoopInvoke \nFsiEvaluationSessionHostConfig.EventLoopRun \nEventLoopRun \nFsiEvaluationSessionHostConfig.EventLoopScheduleRestart \nEventLoopScheduleRestart \nFsiEvaluationSessionHostConfig.GetOptionalConsoleReadLine \nGetOptionalConsoleReadLine \nFsiEvaluationSessionHostConfig.ReportUserCommandLineArgs \nReportUserCommandLineArgs \nFsiEvaluationSessionHostConfig.StartServer \nStartServer \nFsiEvaluationSessionHostConfig.AddedPrinters \nAddedPrinters \nFsiEvaluationSessionHostConfig.ShowIEnumerable \nShowIEnumerable \nFsiEvaluationSessionHostConfig.FormatProvider \nFormatProvider \nFsiEvaluationSessionHostConfig.PrintDepth \nPrintDepth \nFsiEvaluationSessionHostConfig.ShowProperties \nShowProperties \nFsiEvaluationSessionHostConfig.PrintSize \nPrintSize \nFsiEvaluationSessionHostConfig.FloatingPointFormat \nFloatingPointFormat \nFsiEvaluationSessionHostConfig.ShowDeclarationValues \nShowDeclarationValues \nFsiEvaluationSessionHostConfig.UseFsiAuxLib \nUseFsiAuxLib \nFsiEvaluationSessionHostConfig.PrintWidth \nPrintWidth \nFsiEvaluationSessionHostConfig.PrintLength \nPrintLength \nFsiEvaluationSessionHostConfig.OnEvaluation \nOnEvaluation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#\u0060\u0060.ctor\u0060\u0060","title":"FsiEvaluationSessionHostConfig.\u0060\u0060.ctor\u0060\u0060","content":"FsiEvaluationSessionHostConfig.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#EventLoopInvoke","title":"FsiEvaluationSessionHostConfig.EventLoopInvoke","content":"FsiEvaluationSessionHostConfig.EventLoopInvoke \nEventLoopInvoke \n Request that the given operation be run synchronously on the event loop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#EventLoopRun","title":"FsiEvaluationSessionHostConfig.EventLoopRun","content":"FsiEvaluationSessionHostConfig.EventLoopRun \nEventLoopRun \n Called by the evaluation session to ask the host to enter a dispatch loop like Application.Run().\n Only called if --gui option is used (which is the default).\n Gets called towards the end of startup and every time a ThreadAbort escaped to the backup driver loop.\n Return true if a \u0027restart\u0027 is required, which is a bit meaningless.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#EventLoopScheduleRestart","title":"FsiEvaluationSessionHostConfig.EventLoopScheduleRestart","content":"FsiEvaluationSessionHostConfig.EventLoopScheduleRestart \nEventLoopScheduleRestart \n Schedule a restart for the event loop.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#GetOptionalConsoleReadLine","title":"FsiEvaluationSessionHostConfig.GetOptionalConsoleReadLine","content":"FsiEvaluationSessionHostConfig.GetOptionalConsoleReadLine \nGetOptionalConsoleReadLine \n\u003Cp class=\u0027fsdocs-para\u0027\u003EIndicate a special console \u0022readline\u0022 reader for the evaluation session, if any.\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\u00A0\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EA \u0022console\u0022 gets used if --readline is specified (the default on Windows \u002B .NET); and --fsi-server is not\n given (always combine with --readline-), and OptionalConsoleReadLine is given.\n When a console is used, special rules apply to \u0022peekahead\u0022, which allows early typing on the console.\n Peekahead happens if --peekahead- is not specified (the default).\n In this case, a prompt is printed early, a background thread is created and\n the OptionalConsoleReadLine is used to read the first line.\n If a console is not used, then inReader.Peek() is called early instead.\n \u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\u00A0\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003EFurther lines are read using OptionalConsoleReadLine().\n If not provided, lines are read using inReader.ReadLine().\u003C/p\u003E\u003Cp class=\u0027fsdocs-para\u0027\u003E\u00A0\u003C/p\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#ReportUserCommandLineArgs","title":"FsiEvaluationSessionHostConfig.ReportUserCommandLineArgs","content":"FsiEvaluationSessionHostConfig.ReportUserCommandLineArgs \nReportUserCommandLineArgs \n The evaluation session calls this to report the preferred view of the command line arguments after\n stripping things like \u0022/use:file.fsx\u0022, \u0022-r:Foo.dll\u0022 etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#StartServer","title":"FsiEvaluationSessionHostConfig.StartServer","content":"FsiEvaluationSessionHostConfig.StartServer \nStartServer \n The evaluation session calls this at an appropriate point in the startup phase if the --fsi-server parameter was given","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#AddedPrinters","title":"FsiEvaluationSessionHostConfig.AddedPrinters","content":"FsiEvaluationSessionHostConfig.AddedPrinters \nAddedPrinters \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#ShowIEnumerable","title":"FsiEvaluationSessionHostConfig.ShowIEnumerable","content":"FsiEvaluationSessionHostConfig.ShowIEnumerable \nShowIEnumerable \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#FormatProvider","title":"FsiEvaluationSessionHostConfig.FormatProvider","content":"FsiEvaluationSessionHostConfig.FormatProvider \nFormatProvider \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#PrintDepth","title":"FsiEvaluationSessionHostConfig.PrintDepth","content":"FsiEvaluationSessionHostConfig.PrintDepth \nPrintDepth \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#ShowProperties","title":"FsiEvaluationSessionHostConfig.ShowProperties","content":"FsiEvaluationSessionHostConfig.ShowProperties \nShowProperties \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#PrintSize","title":"FsiEvaluationSessionHostConfig.PrintSize","content":"FsiEvaluationSessionHostConfig.PrintSize \nPrintSize \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#FloatingPointFormat","title":"FsiEvaluationSessionHostConfig.FloatingPointFormat","content":"FsiEvaluationSessionHostConfig.FloatingPointFormat \nFloatingPointFormat \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#ShowDeclarationValues","title":"FsiEvaluationSessionHostConfig.ShowDeclarationValues","content":"FsiEvaluationSessionHostConfig.ShowDeclarationValues \nShowDeclarationValues \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#UseFsiAuxLib","title":"FsiEvaluationSessionHostConfig.UseFsiAuxLib","content":"FsiEvaluationSessionHostConfig.UseFsiAuxLib \nUseFsiAuxLib \n Implicitly reference FSharp.Compiler.Interactive.Settings.dll","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#PrintWidth","title":"FsiEvaluationSessionHostConfig.PrintWidth","content":"FsiEvaluationSessionHostConfig.PrintWidth \nPrintWidth \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#PrintLength","title":"FsiEvaluationSessionHostConfig.PrintLength","content":"FsiEvaluationSessionHostConfig.PrintLength \nPrintLength \n Called by the evaluation session to ask the host for parameters to format text for output","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html#OnEvaluation","title":"FsiEvaluationSessionHostConfig.OnEvaluation","content":"FsiEvaluationSessionHostConfig.OnEvaluation \nOnEvaluation \n Hook for listening for evaluation bindings","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsivalue.html","title":"FsiValue","content":"FsiValue \n Represents an evaluated F# value \nFsiValue.FSharpType \nFSharpType \nFsiValue.ReflectionValue \nReflectionValue \nFsiValue.ReflectionType \nReflectionType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsivalue.html#FSharpType","title":"FsiValue.FSharpType","content":"FsiValue.FSharpType \nFSharpType \n The type of the value, from the point of view of the F# type system","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsivalue.html#ReflectionValue","title":"FsiValue.ReflectionValue","content":"FsiValue.ReflectionValue \nReflectionValue \n The value, as an object","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-interactive-shell-fsivalue.html#ReflectionType","title":"FsiValue.ReflectionType","content":"FsiValue.ReflectionType \nReflectionType \n The type of the value, from the point of view of the .NET type system","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html","title":"FSharpExprPatterns","content":"FSharpExprPatterns \n A collection of active patterns to analyze expressions \nFSharpExprPatterns.(|Value|_|) \n(|Value|_|) \nFSharpExprPatterns.(|Application|_|) \n(|Application|_|) \nFSharpExprPatterns.(|TypeLambda|_|) \n(|TypeLambda|_|) \nFSharpExprPatterns.(|DecisionTree|_|) \n(|DecisionTree|_|) \nFSharpExprPatterns.(|DecisionTreeSuccess|_|) \n(|DecisionTreeSuccess|_|) \nFSharpExprPatterns.(|Lambda|_|) \n(|Lambda|_|) \nFSharpExprPatterns.(|IfThenElse|_|) \n(|IfThenElse|_|) \nFSharpExprPatterns.(|Let|_|) \n(|Let|_|) \nFSharpExprPatterns.(|Call|_|) \n(|Call|_|) \nFSharpExprPatterns.(|CallWithWitnesses|_|) \n(|CallWithWitnesses|_|) \nFSharpExprPatterns.(|NewObject|_|) \n(|NewObject|_|) \nFSharpExprPatterns.(|ThisValue|_|) \n(|ThisValue|_|) \nFSharpExprPatterns.(|BaseValue|_|) \n(|BaseValue|_|) \nFSharpExprPatterns.(|Quote|_|) \n(|Quote|_|) \nFSharpExprPatterns.(|LetRec|_|) \n(|LetRec|_|) \nFSharpExprPatterns.(|NewRecord|_|) \n(|NewRecord|_|) \nFSharpExprPatterns.(|NewAnonRecord|_|) \n(|NewAnonRecord|_|) \nFSharpExprPatterns.(|AnonRecordGet|_|) \n(|AnonRecordGet|_|) \nFSharpExprPatterns.(|FSharpFieldGet|_|) \n(|FSharpFieldGet|_|) \nFSharpExprPatterns.(|FSharpFieldSet|_|) \n(|FSharpFieldSet|_|) \nFSharpExprPatterns.(|NewUnionCase|_|) \n(|NewUnionCase|_|) \nFSharpExprPatterns.(|UnionCaseGet|_|) \n(|UnionCaseGet|_|) \nFSharpExprPatterns.(|UnionCaseSet|_|) \n(|UnionCaseSet|_|) \nFSharpExprPatterns.(|UnionCaseTag|_|) \n(|UnionCaseTag|_|) \nFSharpExprPatterns.(|UnionCaseTest|_|) \n(|UnionCaseTest|_|) \nFSharpExprPatterns.(|NewTuple|_|) \n(|NewTuple|_|) \nFSharpExprPatterns.(|TupleGet|_|) \n(|TupleGet|_|) \nFSharpExprPatterns.(|Coerce|_|) \n(|Coerce|_|) \nFSharpExprPatterns.(|NewArray|_|) \n(|NewArray|_|) \nFSharpExprPatterns.(|TypeTest|_|) \n(|TypeTest|_|) \nFSharpExprPatterns.(|AddressSet|_|) \n(|AddressSet|_|) \nFSharpExprPatterns.(|ValueSet|_|) \n(|ValueSet|_|) \nFSharpExprPatterns.(|DefaultValue|_|) \n(|DefaultValue|_|) \nFSharpExprPatterns.(|Const|_|) \n(|Const|_|) \nFSharpExprPatterns.(|AddressOf|_|) \n(|AddressOf|_|) \nFSharpExprPatterns.(|Sequential|_|) \n(|Sequential|_|) \nFSharpExprPatterns.(|DebugPoint|_|) \n(|DebugPoint|_|) \nFSharpExprPatterns.(|FastIntegerForLoop|_|) \n(|FastIntegerForLoop|_|) \nFSharpExprPatterns.(|WhileLoop|_|) \n(|WhileLoop|_|) \nFSharpExprPatterns.(|TryFinally|_|) \n(|TryFinally|_|) \nFSharpExprPatterns.(|TryWith|_|) \n(|TryWith|_|) \nFSharpExprPatterns.(|NewDelegate|_|) \n(|NewDelegate|_|) \nFSharpExprPatterns.(|ILAsm|_|) \n(|ILAsm|_|) \nFSharpExprPatterns.(|ILFieldGet|_|) \n(|ILFieldGet|_|) \nFSharpExprPatterns.(|ILFieldSet|_|) \n(|ILFieldSet|_|) \nFSharpExprPatterns.(|ObjectExpr|_|) \n(|ObjectExpr|_|) \nFSharpExprPatterns.(|TraitCall|_|) \n(|TraitCall|_|) \nFSharpExprPatterns.(|WitnessArg|_|) \n(|WitnessArg|_|)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Value|_|)","title":"FSharpExprPatterns.(|Value|_|)","content":"FSharpExprPatterns.(|Value|_|) \n(|Value|_|) \n Matches expressions which are uses of values","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Application|_|)","title":"FSharpExprPatterns.(|Application|_|)","content":"FSharpExprPatterns.(|Application|_|) \n(|Application|_|) \n Matches expressions which are the application of function values","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|TypeLambda|_|)","title":"FSharpExprPatterns.(|TypeLambda|_|)","content":"FSharpExprPatterns.(|TypeLambda|_|) \n(|TypeLambda|_|) \n Matches expressions which are type abstractions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|DecisionTree|_|)","title":"FSharpExprPatterns.(|DecisionTree|_|)","content":"FSharpExprPatterns.(|DecisionTree|_|) \n(|DecisionTree|_|) \n Matches expressions with a decision expression, each branch of which ends in DecisionTreeSuccess passing control and values to one of the targets.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|DecisionTreeSuccess|_|)","title":"FSharpExprPatterns.(|DecisionTreeSuccess|_|)","content":"FSharpExprPatterns.(|DecisionTreeSuccess|_|) \n(|DecisionTreeSuccess|_|) \n Special expressions at the end of a conditional decision structure in the decision expression node of a DecisionTree .\n The given expressions are passed as values to the decision tree target.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Lambda|_|)","title":"FSharpExprPatterns.(|Lambda|_|)","content":"FSharpExprPatterns.(|Lambda|_|) \n(|Lambda|_|) \n Matches expressions which are lambda abstractions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|IfThenElse|_|)","title":"FSharpExprPatterns.(|IfThenElse|_|)","content":"FSharpExprPatterns.(|IfThenElse|_|) \n(|IfThenElse|_|) \n Matches expressions which are conditionals","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Let|_|)","title":"FSharpExprPatterns.(|Let|_|)","content":"FSharpExprPatterns.(|Let|_|) \n(|Let|_|) \n Matches expressions which are let definitions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Call|_|)","title":"FSharpExprPatterns.(|Call|_|)","content":"FSharpExprPatterns.(|Call|_|) \n(|Call|_|) \n Matches expressions which are calls to members or module-defined functions. When calling curried functions and members the\n arguments are collapsed to a single collection of arguments, as done in the compiled version of these.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|CallWithWitnesses|_|)","title":"FSharpExprPatterns.(|CallWithWitnesses|_|)","content":"FSharpExprPatterns.(|CallWithWitnesses|_|) \n(|CallWithWitnesses|_|) \n Like Call but also indicates witness arguments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewObject|_|)","title":"FSharpExprPatterns.(|NewObject|_|)","content":"FSharpExprPatterns.(|NewObject|_|) \n(|NewObject|_|) \n Matches expressions which are calls to object constructors","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|ThisValue|_|)","title":"FSharpExprPatterns.(|ThisValue|_|)","content":"FSharpExprPatterns.(|ThisValue|_|) \n(|ThisValue|_|) \n Matches expressions which are uses of the \u0027this\u0027 value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|BaseValue|_|)","title":"FSharpExprPatterns.(|BaseValue|_|)","content":"FSharpExprPatterns.(|BaseValue|_|) \n(|BaseValue|_|) \n Matches expressions which are uses of the \u0027base\u0027 value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Quote|_|)","title":"FSharpExprPatterns.(|Quote|_|)","content":"FSharpExprPatterns.(|Quote|_|) \n(|Quote|_|) \n Matches expressions which are quotation literals","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|LetRec|_|)","title":"FSharpExprPatterns.(|LetRec|_|)","content":"FSharpExprPatterns.(|LetRec|_|) \n(|LetRec|_|) \n Matches expressions which are let-rec definitions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewRecord|_|)","title":"FSharpExprPatterns.(|NewRecord|_|)","content":"FSharpExprPatterns.(|NewRecord|_|) \n(|NewRecord|_|) \n Matches record expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewAnonRecord|_|)","title":"FSharpExprPatterns.(|NewAnonRecord|_|)","content":"FSharpExprPatterns.(|NewAnonRecord|_|) \n(|NewAnonRecord|_|) \n Matches anonymous record expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|AnonRecordGet|_|)","title":"FSharpExprPatterns.(|AnonRecordGet|_|)","content":"FSharpExprPatterns.(|AnonRecordGet|_|) \n(|AnonRecordGet|_|) \n Matches expressions getting a field from an anonymous record. The integer represents the\n index into the sorted fields of the anonymous record.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|FSharpFieldGet|_|)","title":"FSharpExprPatterns.(|FSharpFieldGet|_|)","content":"FSharpExprPatterns.(|FSharpFieldGet|_|) \n(|FSharpFieldGet|_|) \n Matches expressions which get a field from a record or class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|FSharpFieldSet|_|)","title":"FSharpExprPatterns.(|FSharpFieldSet|_|)","content":"FSharpExprPatterns.(|FSharpFieldSet|_|) \n(|FSharpFieldSet|_|) \n Matches expressions which set a field in a record or class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewUnionCase|_|)","title":"FSharpExprPatterns.(|NewUnionCase|_|)","content":"FSharpExprPatterns.(|NewUnionCase|_|) \n(|NewUnionCase|_|) \n Matches expressions which create an object corresponding to a union case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|UnionCaseGet|_|)","title":"FSharpExprPatterns.(|UnionCaseGet|_|)","content":"FSharpExprPatterns.(|UnionCaseGet|_|) \n(|UnionCaseGet|_|) \n Matches expressions which get a field from a union case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|UnionCaseSet|_|)","title":"FSharpExprPatterns.(|UnionCaseSet|_|)","content":"FSharpExprPatterns.(|UnionCaseSet|_|) \n(|UnionCaseSet|_|) \n Matches expressions which set a field from a union case (only used in FSharp.Core itself)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|UnionCaseTag|_|)","title":"FSharpExprPatterns.(|UnionCaseTag|_|)","content":"FSharpExprPatterns.(|UnionCaseTag|_|) \n(|UnionCaseTag|_|) \n Matches expressions which gets the tag for a union case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|UnionCaseTest|_|)","title":"FSharpExprPatterns.(|UnionCaseTest|_|)","content":"FSharpExprPatterns.(|UnionCaseTest|_|) \n(|UnionCaseTest|_|) \n Matches expressions which test if an expression corresponds to a particular union case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewTuple|_|)","title":"FSharpExprPatterns.(|NewTuple|_|)","content":"FSharpExprPatterns.(|NewTuple|_|) \n(|NewTuple|_|) \n Matches tuple expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|TupleGet|_|)","title":"FSharpExprPatterns.(|TupleGet|_|)","content":"FSharpExprPatterns.(|TupleGet|_|) \n(|TupleGet|_|) \n Matches expressions which get a value from a tuple","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Coerce|_|)","title":"FSharpExprPatterns.(|Coerce|_|)","content":"FSharpExprPatterns.(|Coerce|_|) \n(|Coerce|_|) \n Matches expressions which coerce the type of a value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewArray|_|)","title":"FSharpExprPatterns.(|NewArray|_|)","content":"FSharpExprPatterns.(|NewArray|_|) \n(|NewArray|_|) \n Matches array expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|TypeTest|_|)","title":"FSharpExprPatterns.(|TypeTest|_|)","content":"FSharpExprPatterns.(|TypeTest|_|) \n(|TypeTest|_|) \n Matches expressions which test the runtime type of a value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|AddressSet|_|)","title":"FSharpExprPatterns.(|AddressSet|_|)","content":"FSharpExprPatterns.(|AddressSet|_|) \n(|AddressSet|_|) \n Matches expressions which set the contents of an address","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|ValueSet|_|)","title":"FSharpExprPatterns.(|ValueSet|_|)","content":"FSharpExprPatterns.(|ValueSet|_|) \n(|ValueSet|_|) \n Matches expressions which set the contents of a mutable variable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|DefaultValue|_|)","title":"FSharpExprPatterns.(|DefaultValue|_|)","content":"FSharpExprPatterns.(|DefaultValue|_|) \n(|DefaultValue|_|) \n Matches default-value expressions, including null expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Const|_|)","title":"FSharpExprPatterns.(|Const|_|)","content":"FSharpExprPatterns.(|Const|_|) \n(|Const|_|) \n Matches constant expressions, including signed and unsigned integers, strings, characters, booleans, arrays\n of bytes and arrays of unit16.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|AddressOf|_|)","title":"FSharpExprPatterns.(|AddressOf|_|)","content":"FSharpExprPatterns.(|AddressOf|_|) \n(|AddressOf|_|) \n Matches expressions which take the address of a location","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|Sequential|_|)","title":"FSharpExprPatterns.(|Sequential|_|)","content":"FSharpExprPatterns.(|Sequential|_|) \n(|Sequential|_|) \n Matches sequential expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|DebugPoint|_|)","title":"FSharpExprPatterns.(|DebugPoint|_|)","content":"FSharpExprPatterns.(|DebugPoint|_|) \n(|DebugPoint|_|) \n Matches debug points at leaf expressions in control flow","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|FastIntegerForLoop|_|)","title":"FSharpExprPatterns.(|FastIntegerForLoop|_|)","content":"FSharpExprPatterns.(|FastIntegerForLoop|_|) \n(|FastIntegerForLoop|_|) \n Matches fast-integer loops (up or down)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|WhileLoop|_|)","title":"FSharpExprPatterns.(|WhileLoop|_|)","content":"FSharpExprPatterns.(|WhileLoop|_|) \n(|WhileLoop|_|) \n Matches while loops","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|TryFinally|_|)","title":"FSharpExprPatterns.(|TryFinally|_|)","content":"FSharpExprPatterns.(|TryFinally|_|) \n(|TryFinally|_|) \n Matches try/finally expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|TryWith|_|)","title":"FSharpExprPatterns.(|TryWith|_|)","content":"FSharpExprPatterns.(|TryWith|_|) \n(|TryWith|_|) \n Matches try/with expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|NewDelegate|_|)","title":"FSharpExprPatterns.(|NewDelegate|_|)","content":"FSharpExprPatterns.(|NewDelegate|_|) \n(|NewDelegate|_|) \n Matches expressions which create an instance of a delegate type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|ILAsm|_|)","title":"FSharpExprPatterns.(|ILAsm|_|)","content":"FSharpExprPatterns.(|ILAsm|_|) \n(|ILAsm|_|) \n Matches expressions which are IL assembly code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|ILFieldGet|_|)","title":"FSharpExprPatterns.(|ILFieldGet|_|)","content":"FSharpExprPatterns.(|ILFieldGet|_|) \n(|ILFieldGet|_|) \n Matches expressions which fetch a field from a .NET type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|ILFieldSet|_|)","title":"FSharpExprPatterns.(|ILFieldSet|_|)","content":"FSharpExprPatterns.(|ILFieldSet|_|) \n(|ILFieldSet|_|) \n Matches expressions which set a field in a .NET type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|ObjectExpr|_|)","title":"FSharpExprPatterns.(|ObjectExpr|_|)","content":"FSharpExprPatterns.(|ObjectExpr|_|) \n(|ObjectExpr|_|) \n Matches object expressions, returning the base type, the base call, the overrides and the interface implementations","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|TraitCall|_|)","title":"FSharpExprPatterns.(|TraitCall|_|)","content":"FSharpExprPatterns.(|TraitCall|_|) \n(|TraitCall|_|) \n Matches expressions for an unresolved call to a trait","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexprpatterns.html#(|WitnessArg|_|)","title":"FSharpExprPatterns.(|WitnessArg|_|)","content":"FSharpExprPatterns.(|WitnessArg|_|) \n(|WitnessArg|_|) \n Indicates a witness argument index from the witness arguments supplied to the enclosing method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html","title":"FSharpSymbolPatterns","content":"FSharpSymbolPatterns \n Patterns over FSharpSymbol and derivatives. \nFSharpSymbolPatterns.(|AbbreviatedType|_|) \n(|AbbreviatedType|_|) \nFSharpSymbolPatterns.(|TypeWithDefinition|_|) \n(|TypeWithDefinition|_|) \nFSharpSymbolPatterns.(|Attribute|_|) \n(|Attribute|_|) \nFSharpSymbolPatterns.(|ValueType|_|) \n(|ValueType|_|) \nFSharpSymbolPatterns.(|Class|_|) \n(|Class|_|) \nFSharpSymbolPatterns.(|Record|_|) \n(|Record|_|) \nFSharpSymbolPatterns.(|UnionType|_|) \n(|UnionType|_|) \nFSharpSymbolPatterns.(|Delegate|_|) \n(|Delegate|_|) \nFSharpSymbolPatterns.(|FSharpException|_|) \n(|FSharpException|_|) \nFSharpSymbolPatterns.(|Interface|_|) \n(|Interface|_|) \nFSharpSymbolPatterns.(|AbstractClass|_|) \n(|AbstractClass|_|) \nFSharpSymbolPatterns.(|FSharpType|_|) \n(|FSharpType|_|) \nFSharpSymbolPatterns.(|ProvidedType|_|) \n(|ProvidedType|_|) \nFSharpSymbolPatterns.(|ByRef|_|) \n(|ByRef|_|) \nFSharpSymbolPatterns.(|Array|_|) \n(|Array|_|) \nFSharpSymbolPatterns.(|FSharpModule|_|) \n(|FSharpModule|_|) \nFSharpSymbolPatterns.(|Namespace|_|) \n(|Namespace|_|) \nFSharpSymbolPatterns.(|ProvidedAndErasedType|_|) \n(|ProvidedAndErasedType|_|) \nFSharpSymbolPatterns.(|Enum|_|) \n(|Enum|_|) \nFSharpSymbolPatterns.(|Tuple|_|) \n(|Tuple|_|) \nFSharpSymbolPatterns.(|RefCell|_|) \n(|RefCell|_|) \nFSharpSymbolPatterns.(|FunctionType|_|) \n(|FunctionType|_|) \nFSharpSymbolPatterns.(|Pattern|_|) \n(|Pattern|_|) \nFSharpSymbolPatterns.(|Field|_|) \n(|Field|_|) \nFSharpSymbolPatterns.(|MutableVar|_|) \n(|MutableVar|_|) \nFSharpSymbolPatterns.(|FSharpEntity|_|) \n(|FSharpEntity|_|) \nFSharpSymbolPatterns.(|Parameter|_|) \n(|Parameter|_|) \nFSharpSymbolPatterns.(|UnionCase|_|) \n(|UnionCase|_|) \nFSharpSymbolPatterns.(|RecordField|_|) \n(|RecordField|_|) \nFSharpSymbolPatterns.(|ActivePatternCase|_|) \n(|ActivePatternCase|_|) \nFSharpSymbolPatterns.(|MemberFunctionOrValue|_|) \n(|MemberFunctionOrValue|_|) \nFSharpSymbolPatterns.(|Constructor|_|) \n(|Constructor|_|) \nFSharpSymbolPatterns.(|Function|_|) \n(|Function|_|) \nFSharpSymbolPatterns.(|ExtensionMember|_|) \n(|ExtensionMember|_|) \nFSharpSymbolPatterns.(|Event|_|) \n(|Event|_|)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|AbbreviatedType|_|)","title":"FSharpSymbolPatterns.(|AbbreviatedType|_|)","content":"FSharpSymbolPatterns.(|AbbreviatedType|_|) \n(|AbbreviatedType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|TypeWithDefinition|_|)","title":"FSharpSymbolPatterns.(|TypeWithDefinition|_|)","content":"FSharpSymbolPatterns.(|TypeWithDefinition|_|) \n(|TypeWithDefinition|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Attribute|_|)","title":"FSharpSymbolPatterns.(|Attribute|_|)","content":"FSharpSymbolPatterns.(|Attribute|_|) \n(|Attribute|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|ValueType|_|)","title":"FSharpSymbolPatterns.(|ValueType|_|)","content":"FSharpSymbolPatterns.(|ValueType|_|) \n(|ValueType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Class|_|)","title":"FSharpSymbolPatterns.(|Class|_|)","content":"FSharpSymbolPatterns.(|Class|_|) \n(|Class|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Record|_|)","title":"FSharpSymbolPatterns.(|Record|_|)","content":"FSharpSymbolPatterns.(|Record|_|) \n(|Record|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|UnionType|_|)","title":"FSharpSymbolPatterns.(|UnionType|_|)","content":"FSharpSymbolPatterns.(|UnionType|_|) \n(|UnionType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Delegate|_|)","title":"FSharpSymbolPatterns.(|Delegate|_|)","content":"FSharpSymbolPatterns.(|Delegate|_|) \n(|Delegate|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|FSharpException|_|)","title":"FSharpSymbolPatterns.(|FSharpException|_|)","content":"FSharpSymbolPatterns.(|FSharpException|_|) \n(|FSharpException|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Interface|_|)","title":"FSharpSymbolPatterns.(|Interface|_|)","content":"FSharpSymbolPatterns.(|Interface|_|) \n(|Interface|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|AbstractClass|_|)","title":"FSharpSymbolPatterns.(|AbstractClass|_|)","content":"FSharpSymbolPatterns.(|AbstractClass|_|) \n(|AbstractClass|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|FSharpType|_|)","title":"FSharpSymbolPatterns.(|FSharpType|_|)","content":"FSharpSymbolPatterns.(|FSharpType|_|) \n(|FSharpType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|ProvidedType|_|)","title":"FSharpSymbolPatterns.(|ProvidedType|_|)","content":"FSharpSymbolPatterns.(|ProvidedType|_|) \n(|ProvidedType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|ByRef|_|)","title":"FSharpSymbolPatterns.(|ByRef|_|)","content":"FSharpSymbolPatterns.(|ByRef|_|) \n(|ByRef|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Array|_|)","title":"FSharpSymbolPatterns.(|Array|_|)","content":"FSharpSymbolPatterns.(|Array|_|) \n(|Array|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|FSharpModule|_|)","title":"FSharpSymbolPatterns.(|FSharpModule|_|)","content":"FSharpSymbolPatterns.(|FSharpModule|_|) \n(|FSharpModule|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Namespace|_|)","title":"FSharpSymbolPatterns.(|Namespace|_|)","content":"FSharpSymbolPatterns.(|Namespace|_|) \n(|Namespace|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|ProvidedAndErasedType|_|)","title":"FSharpSymbolPatterns.(|ProvidedAndErasedType|_|)","content":"FSharpSymbolPatterns.(|ProvidedAndErasedType|_|) \n(|ProvidedAndErasedType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Enum|_|)","title":"FSharpSymbolPatterns.(|Enum|_|)","content":"FSharpSymbolPatterns.(|Enum|_|) \n(|Enum|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Tuple|_|)","title":"FSharpSymbolPatterns.(|Tuple|_|)","content":"FSharpSymbolPatterns.(|Tuple|_|) \n(|Tuple|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|RefCell|_|)","title":"FSharpSymbolPatterns.(|RefCell|_|)","content":"FSharpSymbolPatterns.(|RefCell|_|) \n(|RefCell|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|FunctionType|_|)","title":"FSharpSymbolPatterns.(|FunctionType|_|)","content":"FSharpSymbolPatterns.(|FunctionType|_|) \n(|FunctionType|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Pattern|_|)","title":"FSharpSymbolPatterns.(|Pattern|_|)","content":"FSharpSymbolPatterns.(|Pattern|_|) \n(|Pattern|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Field|_|)","title":"FSharpSymbolPatterns.(|Field|_|)","content":"FSharpSymbolPatterns.(|Field|_|) \n(|Field|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|MutableVar|_|)","title":"FSharpSymbolPatterns.(|MutableVar|_|)","content":"FSharpSymbolPatterns.(|MutableVar|_|) \n(|MutableVar|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|FSharpEntity|_|)","title":"FSharpSymbolPatterns.(|FSharpEntity|_|)","content":"FSharpSymbolPatterns.(|FSharpEntity|_|) \n(|FSharpEntity|_|) \n Returns (originalEntity, abbreviatedEntity, abbreviatedType)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Parameter|_|)","title":"FSharpSymbolPatterns.(|Parameter|_|)","content":"FSharpSymbolPatterns.(|Parameter|_|) \n(|Parameter|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|UnionCase|_|)","title":"FSharpSymbolPatterns.(|UnionCase|_|)","content":"FSharpSymbolPatterns.(|UnionCase|_|) \n(|UnionCase|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|RecordField|_|)","title":"FSharpSymbolPatterns.(|RecordField|_|)","content":"FSharpSymbolPatterns.(|RecordField|_|) \n(|RecordField|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|ActivePatternCase|_|)","title":"FSharpSymbolPatterns.(|ActivePatternCase|_|)","content":"FSharpSymbolPatterns.(|ActivePatternCase|_|) \n(|ActivePatternCase|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|MemberFunctionOrValue|_|)","title":"FSharpSymbolPatterns.(|MemberFunctionOrValue|_|)","content":"FSharpSymbolPatterns.(|MemberFunctionOrValue|_|) \n(|MemberFunctionOrValue|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Constructor|_|)","title":"FSharpSymbolPatterns.(|Constructor|_|)","content":"FSharpSymbolPatterns.(|Constructor|_|) \n(|Constructor|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Function|_|)","title":"FSharpSymbolPatterns.(|Function|_|)","content":"FSharpSymbolPatterns.(|Function|_|) \n(|Function|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|ExtensionMember|_|)","title":"FSharpSymbolPatterns.(|ExtensionMember|_|)","content":"FSharpSymbolPatterns.(|ExtensionMember|_|) \n(|ExtensionMember|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html#(|Event|_|)","title":"FSharpSymbolPatterns.(|Event|_|)","content":"FSharpSymbolPatterns.(|Event|_|) \n(|Event|_|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html","title":"FSharpAbstractParameter","content":"FSharpAbstractParameter \n Represents a parameter in an abstract method of a class or interface \nFSharpAbstractParameter.IsInArg \nIsInArg \nFSharpAbstractParameter.Attributes \nAttributes \nFSharpAbstractParameter.IsOptionalArg \nIsOptionalArg \nFSharpAbstractParameter.IsOutArg \nIsOutArg \nFSharpAbstractParameter.Type \nType \nFSharpAbstractParameter.Name \nName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html#IsInArg","title":"FSharpAbstractParameter.IsInArg","content":"FSharpAbstractParameter.IsInArg \nIsInArg \n Indicate this is an in argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html#Attributes","title":"FSharpAbstractParameter.Attributes","content":"FSharpAbstractParameter.Attributes \nAttributes \n The declared attributes of the parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html#IsOptionalArg","title":"FSharpAbstractParameter.IsOptionalArg","content":"FSharpAbstractParameter.IsOptionalArg \nIsOptionalArg \n Indicate this is an optional argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html#IsOutArg","title":"FSharpAbstractParameter.IsOutArg","content":"FSharpAbstractParameter.IsOutArg \nIsOutArg \n Indicate this is an out argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html#Type","title":"FSharpAbstractParameter.Type","content":"FSharpAbstractParameter.Type \nType \n The declared or inferred type of the parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractparameter.html#Name","title":"FSharpAbstractParameter.Name","content":"FSharpAbstractParameter.Name \nName \n The optional name of the parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html","title":"FSharpAbstractSignature","content":"FSharpAbstractSignature \n Represents the signature of an abstract slot of a class or interface \nFSharpAbstractSignature.DeclaringType \nDeclaringType \nFSharpAbstractSignature.AbstractReturnType \nAbstractReturnType \nFSharpAbstractSignature.DeclaringTypeGenericParameters \nDeclaringTypeGenericParameters \nFSharpAbstractSignature.Name \nName \nFSharpAbstractSignature.AbstractArguments \nAbstractArguments \nFSharpAbstractSignature.MethodGenericParameters \nMethodGenericParameters","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html#DeclaringType","title":"FSharpAbstractSignature.DeclaringType","content":"FSharpAbstractSignature.DeclaringType \nDeclaringType \n Get the declaring type of the abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html#AbstractReturnType","title":"FSharpAbstractSignature.AbstractReturnType","content":"FSharpAbstractSignature.AbstractReturnType \nAbstractReturnType \n Get the return type of the abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html#DeclaringTypeGenericParameters","title":"FSharpAbstractSignature.DeclaringTypeGenericParameters","content":"FSharpAbstractSignature.DeclaringTypeGenericParameters \nDeclaringTypeGenericParameters \n Get the generic arguments of the type defining the abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html#Name","title":"FSharpAbstractSignature.Name","content":"FSharpAbstractSignature.Name \nName \n Get the name of the abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html#AbstractArguments","title":"FSharpAbstractSignature.AbstractArguments","content":"FSharpAbstractSignature.AbstractArguments \nAbstractArguments \n Get the arguments of the abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpabstractsignature.html#MethodGenericParameters","title":"FSharpAbstractSignature.MethodGenericParameters","content":"FSharpAbstractSignature.MethodGenericParameters \nMethodGenericParameters \n Get the generic arguments of the abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpaccessibility.html","title":"FSharpAccessibility","content":"FSharpAccessibility \n Indicates the accessibility of a symbol, as seen by the F# language \nFSharpAccessibility.IsProtected \nIsProtected \nFSharpAccessibility.IsPublic \nIsPublic \nFSharpAccessibility.IsInternal \nIsInternal \nFSharpAccessibility.IsPrivate \nIsPrivate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpaccessibility.html#IsProtected","title":"FSharpAccessibility.IsProtected","content":"FSharpAccessibility.IsProtected \nIsProtected \n Indicates the symbol has protected accessibility.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpaccessibility.html#IsPublic","title":"FSharpAccessibility.IsPublic","content":"FSharpAccessibility.IsPublic \nIsPublic \n Indicates the symbol has public accessibility.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpaccessibility.html#IsInternal","title":"FSharpAccessibility.IsInternal","content":"FSharpAccessibility.IsInternal \nIsInternal \n Indicates the symbol has internal accessibility.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpaccessibility.html#IsPrivate","title":"FSharpAccessibility.IsPrivate","content":"FSharpAccessibility.IsPrivate \nIsPrivate \n Indicates the symbol has private accessibility.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpaccessibilityrights.html","title":"FSharpAccessibilityRights","content":"FSharpAccessibilityRights \n Represents the rights of a compilation to access symbols","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html","title":"FSharpActivePatternCase","content":"FSharpActivePatternCase \n A subtype of FSharpSymbol that represents a single case within an active pattern \nFSharpActivePatternCase.Index \nIndex \nFSharpActivePatternCase.Group \nGroup \nFSharpActivePatternCase.DeclarationLocation \nDeclarationLocation \nFSharpActivePatternCase.XmlDocSig \nXmlDocSig \nFSharpActivePatternCase.Name \nName \nFSharpActivePatternCase.XmlDoc \nXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html#Index","title":"FSharpActivePatternCase.Index","content":"FSharpActivePatternCase.Index \nIndex \n Index of the case in the pattern group","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html#Group","title":"FSharpActivePatternCase.Group","content":"FSharpActivePatternCase.Group \nGroup \n The group of active pattern cases this belongs to","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html#DeclarationLocation","title":"FSharpActivePatternCase.DeclarationLocation","content":"FSharpActivePatternCase.DeclarationLocation \nDeclarationLocation \n The location of declaration of the active pattern case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html#XmlDocSig","title":"FSharpActivePatternCase.XmlDocSig","content":"FSharpActivePatternCase.XmlDocSig \nXmlDocSig \n XML documentation signature for the active pattern case, used for .xml file lookup for compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html#Name","title":"FSharpActivePatternCase.Name","content":"FSharpActivePatternCase.Name \nName \n The name of the active pattern case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html#XmlDoc","title":"FSharpActivePatternCase.XmlDoc","content":"FSharpActivePatternCase.XmlDoc \nXmlDoc \n Get the XML documentation for the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html","title":"FSharpActivePatternGroup","content":"FSharpActivePatternGroup \n Represents all cases within an active pattern \nFSharpActivePatternGroup.Names \nNames \nFSharpActivePatternGroup.OverallType \nOverallType \nFSharpActivePatternGroup.DeclaringEntity \nDeclaringEntity \nFSharpActivePatternGroup.Name \nName \nFSharpActivePatternGroup.IsTotal \nIsTotal","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html#Names","title":"FSharpActivePatternGroup.Names","content":"FSharpActivePatternGroup.Names \nNames \n The names of the active pattern cases","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html#OverallType","title":"FSharpActivePatternGroup.OverallType","content":"FSharpActivePatternGroup.OverallType \nOverallType \n Get the type indicating signature of the active pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html#DeclaringEntity","title":"FSharpActivePatternGroup.DeclaringEntity","content":"FSharpActivePatternGroup.DeclaringEntity \nDeclaringEntity \n Try to get the entity in which the active pattern is declared","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html#Name","title":"FSharpActivePatternGroup.Name","content":"FSharpActivePatternGroup.Name \nName \n The whole group name","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html#IsTotal","title":"FSharpActivePatternGroup.IsTotal","content":"FSharpActivePatternGroup.IsTotal \nIsTotal \n Indicate this is a total active pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html","title":"FSharpAnonRecordTypeDetails","content":"FSharpAnonRecordTypeDetails \n A subtype of FSharpSymbol that represents a record or union case field as seen by the F# language \nFSharpAnonRecordTypeDetails.SortedFieldNames \nSortedFieldNames \nFSharpAnonRecordTypeDetails.Assembly \nAssembly \nFSharpAnonRecordTypeDetails.EnclosingCompiledTypeNames \nEnclosingCompiledTypeNames \nFSharpAnonRecordTypeDetails.CompiledName \nCompiledName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html#SortedFieldNames","title":"FSharpAnonRecordTypeDetails.SortedFieldNames","content":"FSharpAnonRecordTypeDetails.SortedFieldNames \nSortedFieldNames \n The sorted labels of the anonymous type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html#Assembly","title":"FSharpAnonRecordTypeDetails.Assembly","content":"FSharpAnonRecordTypeDetails.Assembly \nAssembly \n The assembly where the compiled form of the anonymous type is defined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html#EnclosingCompiledTypeNames","title":"FSharpAnonRecordTypeDetails.EnclosingCompiledTypeNames","content":"FSharpAnonRecordTypeDetails.EnclosingCompiledTypeNames \nEnclosingCompiledTypeNames \n Names of any enclosing types of the compiled form of the anonymous type (if the anonymous type was defined as a nested type)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html#CompiledName","title":"FSharpAnonRecordTypeDetails.CompiledName","content":"FSharpAnonRecordTypeDetails.CompiledName \nCompiledName \n The name of the compiled form of the anonymous type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassembly.html","title":"FSharpAssembly","content":"FSharpAssembly \n Represents an assembly as seen by the F# language \nFSharpAssembly.FileName \nFileName \nFSharpAssembly.QualifiedName \nQualifiedName \nFSharpAssembly.SimpleName \nSimpleName \nFSharpAssembly.Contents \nContents \nFSharpAssembly.IsProviderGenerated \nIsProviderGenerated","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassembly.html#FileName","title":"FSharpAssembly.FileName","content":"FSharpAssembly.FileName \nFileName \n The file name for the assembly, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassembly.html#QualifiedName","title":"FSharpAssembly.QualifiedName","content":"FSharpAssembly.QualifiedName \nQualifiedName \n The qualified name of the assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassembly.html#SimpleName","title":"FSharpAssembly.SimpleName","content":"FSharpAssembly.SimpleName \nSimpleName \n The simple name for the assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassembly.html#Contents","title":"FSharpAssembly.Contents","content":"FSharpAssembly.Contents \nContents \n The contents of the this assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassembly.html#IsProviderGenerated","title":"FSharpAssembly.IsProviderGenerated","content":"FSharpAssembly.IsProviderGenerated \nIsProviderGenerated \n Indicates if the assembly was generated by a type provider and is due for static linking","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblycontents.html","title":"FSharpAssemblyContents","content":"FSharpAssemblyContents \n Represents the definitional contents of an assembly, as seen by the F# language \nFSharpAssemblyContents.ImplementationFiles \nImplementationFiles","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblycontents.html#ImplementationFiles","title":"FSharpAssemblyContents.ImplementationFiles","content":"FSharpAssemblyContents.ImplementationFiles \nImplementationFiles \n The contents of the implementation files in the assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblysignature.html","title":"FSharpAssemblySignature","content":"FSharpAssemblySignature \n Represents an inferred signature of part of an assembly as seen by the F# language \nFSharpAssemblySignature.FindEntityByPath \nFindEntityByPath \nFSharpAssemblySignature.TryGetEntities \nTryGetEntities \nFSharpAssemblySignature.Attributes \nAttributes \nFSharpAssemblySignature.Entities \nEntities","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblysignature.html#FindEntityByPath","title":"FSharpAssemblySignature.FindEntityByPath","content":"FSharpAssemblySignature.FindEntityByPath \nFindEntityByPath \n Find entity using compiled names","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblysignature.html#TryGetEntities","title":"FSharpAssemblySignature.TryGetEntities","content":"FSharpAssemblySignature.TryGetEntities \nTryGetEntities \n Safe version of \u0060Entities\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblysignature.html#Attributes","title":"FSharpAssemblySignature.Attributes","content":"FSharpAssemblySignature.Attributes \nAttributes \n Get the declared attributes for the assembly.\n Only available when parsing an entire project.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpassemblysignature.html#Entities","title":"FSharpAssemblySignature.Entities","content":"FSharpAssemblySignature.Entities \nEntities \n The (non-nested) module and type definitions in this signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html","title":"FSharpAttribute","content":"FSharpAttribute \n Represents a custom attribute attached to F# source code or a compiler .NET component \nFSharpAttribute.Format \nFormat \nFSharpAttribute.IsAttribute \nIsAttribute \nFSharpAttribute.Range \nRange \nFSharpAttribute.AttributeType \nAttributeType \nFSharpAttribute.ConstructorArguments \nConstructorArguments \nFSharpAttribute.IsUnresolved \nIsUnresolved \nFSharpAttribute.NamedArguments \nNamedArguments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#Format","title":"FSharpAttribute.Format","content":"FSharpAttribute.Format \nFormat \n Format the attribute using the rules of the given display context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#IsAttribute","title":"FSharpAttribute.IsAttribute","content":"FSharpAttribute.IsAttribute \nIsAttribute \n Indicates if attribute matchies the full name of the given type parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#Range","title":"FSharpAttribute.Range","content":"FSharpAttribute.Range \nRange \n Get the range of the name of the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#AttributeType","title":"FSharpAttribute.AttributeType","content":"FSharpAttribute.AttributeType \nAttributeType \n The type of the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#ConstructorArguments","title":"FSharpAttribute.ConstructorArguments","content":"FSharpAttribute.ConstructorArguments \nConstructorArguments \n The arguments to the constructor for the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#IsUnresolved","title":"FSharpAttribute.IsUnresolved","content":"FSharpAttribute.IsUnresolved \nIsUnresolved \n Indicates if the attribute type is in an unresolved assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpattribute.html#NamedArguments","title":"FSharpAttribute.NamedArguments","content":"FSharpAttribute.NamedArguments \nNamedArguments \n The named arguments for the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdelegatesignature.html","title":"FSharpDelegateSignature","content":"FSharpDelegateSignature \n Represents a delegate signature in an F# symbol \nFSharpDelegateSignature.DelegateReturnType \nDelegateReturnType \nFSharpDelegateSignature.DelegateArguments \nDelegateArguments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdelegatesignature.html#DelegateReturnType","title":"FSharpDelegateSignature.DelegateReturnType","content":"FSharpDelegateSignature.DelegateReturnType \nDelegateReturnType \n Get the return type of the delegate signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdelegatesignature.html#DelegateArguments","title":"FSharpDelegateSignature.DelegateArguments","content":"FSharpDelegateSignature.DelegateArguments \nDelegateArguments \n Get the argument types of the delegate signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html","title":"FSharpDisplayContext","content":"FSharpDisplayContext \n Represents the information needed to format types and other information in a style\n suitable for use in F# source text at a particular source location.\n\n Acquired via GetDisplayEnvAtLocationAlternate and similar methods. May be passed\n to the Format method on FSharpType and other methods. \nFSharpDisplayContext.WithPrefixGenericParameters \nWithPrefixGenericParameters \nFSharpDisplayContext.WithShortTypeNames \nWithShortTypeNames \nFSharpDisplayContext.WithSuffixGenericParameters \nWithSuffixGenericParameters \nFSharpDisplayContext.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html#WithPrefixGenericParameters","title":"FSharpDisplayContext.WithPrefixGenericParameters","content":"FSharpDisplayContext.WithPrefixGenericParameters \nWithPrefixGenericParameters \n Causes type signatures to be formatted with prefix-style generic parameters,\n for example \u0060list\u003Cint\u003E\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html#WithShortTypeNames","title":"FSharpDisplayContext.WithShortTypeNames","content":"FSharpDisplayContext.WithShortTypeNames \nWithShortTypeNames \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html#WithSuffixGenericParameters","title":"FSharpDisplayContext.WithSuffixGenericParameters","content":"FSharpDisplayContext.WithSuffixGenericParameters \nWithSuffixGenericParameters \n Causes type signatures to be formatted with suffix-style generic parameters,\n for example \u0060int list\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html#Empty","title":"FSharpDisplayContext.Empty","content":"FSharpDisplayContext.Empty \nEmpty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html","title":"FSharpEntity","content":"FSharpEntity \n A subtype of FSharpSymbol that represents a type definition or module as seen by the F# language \nFSharpEntity.AsType \nAsType \nFSharpEntity.GetPublicNestedEntities \nGetPublicNestedEntities \nFSharpEntity.TryGetFullCompiledName \nTryGetFullCompiledName \nFSharpEntity.TryGetFullDisplayName \nTryGetFullDisplayName \nFSharpEntity.TryGetFullName \nTryGetFullName \nFSharpEntity.TryGetMembersFunctionsAndValues \nTryGetMembersFunctionsAndValues \nFSharpEntity.TryGetMetadataText \nTryGetMetadataText \nFSharpEntity.FSharpDelegateSignature \nFSharpDelegateSignature \nFSharpEntity.RepresentationAccessibility \nRepresentationAccessibility \nFSharpEntity.IsInterface \nIsInterface \nFSharpEntity.AllCompilationPaths \nAllCompilationPaths \nFSharpEntity.IsFSharpModule \nIsFSharpModule \nFSharpEntity.IsUnresolved \nIsUnresolved \nFSharpEntity.UsesPrefixDisplay \nUsesPrefixDisplay \nFSharpEntity.IsNamespace \nIsNamespace \nFSharpEntity.DeclaredInterfaces \nDeclaredInterfaces \nFSharpEntity.DisplayName \nDisplayName \nFSharpEntity.IsAttributeType \nIsAttributeType \nFSharpEntity.IsProvided \nIsProvided \nFSharpEntity.IsProvidedAndGenerated \nIsProvidedAndGenerated \nFSharpEntity.XmlDoc \nXmlDoc \nFSharpEntity.MembersFunctionsAndValues \nMembersFunctionsAndValues \nFSharpEntity.FSharpFields \nFSharpFields \nFSharpEntity.IsValueType \nIsValueType \nFSharpEntity.ActivePatternCases \nActivePatternCases \nFSharpEntity.CompiledName \nCompiledName \nFSharpEntity.IsEnum \nIsEnum \nFSharpEntity.IsMeasure \nIsMeasure \nFSharpEntity.IsAbstractClass \nIsAbstractClass \nFSharpEntity.FullName \nFullName \nFSharpEntity.NestedEntities \nNestedEntities \nFSharpEntity.QualifiedName \nQualifiedName \nFSharpEntity.IsFSharpRecord \nIsFSharpRecord \nFSharpEntity.IsFSharpAbbreviation \nIsFSharpAbbreviation \nFSharpEntity.IsArrayType \nIsArrayType \nFSharpEntity.BaseType \nBaseType \nFSharpEntity.DeclaringEntity \nDeclaringEntity \nFSharpEntity.IsByRef \nIsByRef \nFSharpEntity.TryFullName \nTryFullName \nFSharpEntity.AllInterfaces \nAllInterfaces \nFSharpEntity.IsFSharpExceptionDeclaration \nIsFSharpExceptionDeclaration \nFSharpEntity.Namespace \nNamespace \nFSharpEntity.IsClass \nIsClass \nFSharpEntity.AccessPath \nAccessPath \nFSharpEntity.LogicalName \nLogicalName \nFSharpEntity.StaticParameters \nStaticParameters \nFSharpEntity.ArrayRank \nArrayRank \nFSharpEntity.UnionCases \nUnionCases \nFSharpEntity.GenericParameters \nGenericParameters \nFSharpEntity.DeclarationLocation \nDeclarationLocation \nFSharpEntity.IsFSharp \nIsFSharp \nFSharpEntity.HasFSharpModuleSuffix \nHasFSharpModuleSuffix \nFSharpEntity.IsFSharpUnion \nIsFSharpUnion \nFSharpEntity.IsDelegate \nIsDelegate \nFSharpEntity.IsProvidedAndErased \nIsProvidedAndErased \nFSharpEntity.BasicQualifiedName \nBasicQualifiedName \nFSharpEntity.XmlDocSig \nXmlDocSig \nFSharpEntity.IsStaticInstantiation \nIsStaticInstantiation \nFSharpEntity.AbbreviatedType \nAbbreviatedType \nFSharpEntity.IsOpaque \nIsOpaque \nFSharpEntity.HasAssemblyCodeRepresentation \nHasAssemblyCodeRepresentation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#AsType","title":"FSharpEntity.AsType","content":"FSharpEntity.AsType \nAsType \n Instantiates FSharpType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#GetPublicNestedEntities","title":"FSharpEntity.GetPublicNestedEntities","content":"FSharpEntity.GetPublicNestedEntities \nGetPublicNestedEntities \n Public nested entities (methods, functions, values, nested modules).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#TryGetFullCompiledName","title":"FSharpEntity.TryGetFullCompiledName","content":"FSharpEntity.TryGetFullCompiledName \nTryGetFullCompiledName \n Safe version of \u0060CompiledName\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#TryGetFullDisplayName","title":"FSharpEntity.TryGetFullDisplayName","content":"FSharpEntity.TryGetFullDisplayName \nTryGetFullDisplayName \n Safe version of \u0060DisplayName\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#TryGetFullName","title":"FSharpEntity.TryGetFullName","content":"FSharpEntity.TryGetFullName \nTryGetFullName \n Safe version of \u0060FullName\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#TryGetMembersFunctionsAndValues","title":"FSharpEntity.TryGetMembersFunctionsAndValues","content":"FSharpEntity.TryGetMembersFunctionsAndValues \nTryGetMembersFunctionsAndValues \n Safe version of \u0060GetMembersFunctionsAndValues\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#TryGetMetadataText","title":"FSharpEntity.TryGetMetadataText","content":"FSharpEntity.TryGetMetadataText \nTryGetMetadataText \n Get the source text of the entity\u0027s signature to be used as metadata.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#FSharpDelegateSignature","title":"FSharpEntity.FSharpDelegateSignature","content":"FSharpEntity.FSharpDelegateSignature \nFSharpDelegateSignature \n Indicates if the type is a delegate with the given Invoke signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#RepresentationAccessibility","title":"FSharpEntity.RepresentationAccessibility","content":"FSharpEntity.RepresentationAccessibility \nRepresentationAccessibility \n Get the declared accessibility of the representation, not taking signatures into account","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsInterface","title":"FSharpEntity.IsInterface","content":"FSharpEntity.IsInterface \nIsInterface \n Indicates if the entity is an interface type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#AllCompilationPaths","title":"FSharpEntity.AllCompilationPaths","content":"FSharpEntity.AllCompilationPaths \nAllCompilationPaths \n Get all compilation paths, taking \u0060Module\u0060 suffixes into account.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsFSharpModule","title":"FSharpEntity.IsFSharpModule","content":"FSharpEntity.IsFSharpModule \nIsFSharpModule \n Indicates if the entity is an F# module definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsUnresolved","title":"FSharpEntity.IsUnresolved","content":"FSharpEntity.IsUnresolved \nIsUnresolved \n Indicates if the entity is in an unresolved assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#UsesPrefixDisplay","title":"FSharpEntity.UsesPrefixDisplay","content":"FSharpEntity.UsesPrefixDisplay \nUsesPrefixDisplay \n Indicates if the type prefers the \u0022tycon\u003Ca,b\u003E\u0022 syntax for display etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsNamespace","title":"FSharpEntity.IsNamespace","content":"FSharpEntity.IsNamespace \nIsNamespace \n Indicates if the entity is a part of a namespace path","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#DeclaredInterfaces","title":"FSharpEntity.DeclaredInterfaces","content":"FSharpEntity.DeclaredInterfaces \nDeclaredInterfaces \n Get the declared interface implementations","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#DisplayName","title":"FSharpEntity.DisplayName","content":"FSharpEntity.DisplayName \nDisplayName \n Get the name of the type or module as displayed in F# code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsAttributeType","title":"FSharpEntity.IsAttributeType","content":"FSharpEntity.IsAttributeType \nIsAttributeType \n Check if the entity inherits from System.Attribute in its type hierarchy","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsProvided","title":"FSharpEntity.IsProvided","content":"FSharpEntity.IsProvided \nIsProvided \n Indicates if the entity is a provided type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsProvidedAndGenerated","title":"FSharpEntity.IsProvidedAndGenerated","content":"FSharpEntity.IsProvidedAndGenerated \nIsProvidedAndGenerated \n Indicates if the entity is a generated provided type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#XmlDoc","title":"FSharpEntity.XmlDoc","content":"FSharpEntity.XmlDoc \nXmlDoc \n Get the XML documentation for the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#MembersFunctionsAndValues","title":"FSharpEntity.MembersFunctionsAndValues","content":"FSharpEntity.MembersFunctionsAndValues \nMembersFunctionsAndValues \n Get the properties, events and methods of a type definitions, or the functions and values of a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#FSharpFields","title":"FSharpEntity.FSharpFields","content":"FSharpEntity.FSharpFields \nFSharpFields \n Get the fields of a record, class, struct or enum from the perspective of the F# language.\n This includes static fields, the \u0027val\u0027 bindings in classes and structs, and the value definitions in enums.\n For classes, the list may include compiler generated fields implied by the use of primary constructors.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsValueType","title":"FSharpEntity.IsValueType","content":"FSharpEntity.IsValueType \nIsValueType \n Indicates if the entity is a struct or enum","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#ActivePatternCases","title":"FSharpEntity.ActivePatternCases","content":"FSharpEntity.ActivePatternCases \nActivePatternCases \n Get all active pattern cases defined in all active patterns in the module.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#CompiledName","title":"FSharpEntity.CompiledName","content":"FSharpEntity.CompiledName \nCompiledName \n Get the compiled name of the type or module, possibly with \u0060n mangling. This is identical to LogicalName\n unless the CompiledName attribute is used.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsEnum","title":"FSharpEntity.IsEnum","content":"FSharpEntity.IsEnum \nIsEnum \n Indicates if the entity is an enum type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsMeasure","title":"FSharpEntity.IsMeasure","content":"FSharpEntity.IsMeasure \nIsMeasure \n Indicates if the entity is a measure definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsAbstractClass","title":"FSharpEntity.IsAbstractClass","content":"FSharpEntity.IsAbstractClass \nIsAbstractClass \n Indicates if the entity is an abstract class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#FullName","title":"FSharpEntity.FullName","content":"FSharpEntity.FullName \nFullName \n Get the full name of the type or module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#NestedEntities","title":"FSharpEntity.NestedEntities","content":"FSharpEntity.NestedEntities \nNestedEntities \n Get the modules and types defined in a module, or the nested types of a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#QualifiedName","title":"FSharpEntity.QualifiedName","content":"FSharpEntity.QualifiedName \nQualifiedName \n Get the fully qualified name of the type or module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsFSharpRecord","title":"FSharpEntity.IsFSharpRecord","content":"FSharpEntity.IsFSharpRecord \nIsFSharpRecord \n Indicates if the entity is record type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsFSharpAbbreviation","title":"FSharpEntity.IsFSharpAbbreviation","content":"FSharpEntity.IsFSharpAbbreviation \nIsFSharpAbbreviation \n Indicates if the entity is a measure, type or exception abbreviation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsArrayType","title":"FSharpEntity.IsArrayType","content":"FSharpEntity.IsArrayType \nIsArrayType \n Indicates if the entity is an array type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#BaseType","title":"FSharpEntity.BaseType","content":"FSharpEntity.BaseType \nBaseType \n Get the base type, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#DeclaringEntity","title":"FSharpEntity.DeclaringEntity","content":"FSharpEntity.DeclaringEntity \nDeclaringEntity \n Get the enclosing entity for the definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsByRef","title":"FSharpEntity.IsByRef","content":"FSharpEntity.IsByRef \nIsByRef \n Indicates if is the \u0027byref\u003C_\u003E\u0027 type definition used for byref types in F#-compiled assemblies","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#TryFullName","title":"FSharpEntity.TryFullName","content":"FSharpEntity.TryFullName \nTryFullName \n Get the full name of the type or module if it is available","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#AllInterfaces","title":"FSharpEntity.AllInterfaces","content":"FSharpEntity.AllInterfaces \nAllInterfaces \n Get all the interface implementations, by walking the type hierarchy","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsFSharpExceptionDeclaration","title":"FSharpEntity.IsFSharpExceptionDeclaration","content":"FSharpEntity.IsFSharpExceptionDeclaration \nIsFSharpExceptionDeclaration \n Indicates an F# exception declaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#Namespace","title":"FSharpEntity.Namespace","content":"FSharpEntity.Namespace \nNamespace \n Get the namespace containing the type or module, if any. Use \u0027None\u0027 for item not in a namespace.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsClass","title":"FSharpEntity.IsClass","content":"FSharpEntity.IsClass \nIsClass \n Indicates if the entity is a class type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#AccessPath","title":"FSharpEntity.AccessPath","content":"FSharpEntity.AccessPath \nAccessPath \n Get the path used to address the entity (e.g. \u0022Namespace.Module1.NestedModule2\u0022). Gives\n \u0022global\u0022 for items not in a namespace.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#LogicalName","title":"FSharpEntity.LogicalName","content":"FSharpEntity.LogicalName \nLogicalName \n Get the name of the type or module, possibly with \u0060n mangling","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#StaticParameters","title":"FSharpEntity.StaticParameters","content":"FSharpEntity.StaticParameters \nStaticParameters \n Get the static parameters for a provided type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#ArrayRank","title":"FSharpEntity.ArrayRank","content":"FSharpEntity.ArrayRank \nArrayRank \n Get the rank of an array type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#UnionCases","title":"FSharpEntity.UnionCases","content":"FSharpEntity.UnionCases \nUnionCases \n Get the cases of a union type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#GenericParameters","title":"FSharpEntity.GenericParameters","content":"FSharpEntity.GenericParameters \nGenericParameters \n Get the generic parameters, possibly including unit-of-measure parameters","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#DeclarationLocation","title":"FSharpEntity.DeclarationLocation","content":"FSharpEntity.DeclarationLocation \nDeclarationLocation \n Get the declaration location for the type constructor","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsFSharp","title":"FSharpEntity.IsFSharp","content":"FSharpEntity.IsFSharp \nIsFSharp \n Indicates if this is a reference to something in an F#-compiled assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#HasFSharpModuleSuffix","title":"FSharpEntity.HasFSharpModuleSuffix","content":"FSharpEntity.HasFSharpModuleSuffix \nHasFSharpModuleSuffix \n Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsFSharpUnion","title":"FSharpEntity.IsFSharpUnion","content":"FSharpEntity.IsFSharpUnion \nIsFSharpUnion \n Indicates if the entity is union type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsDelegate","title":"FSharpEntity.IsDelegate","content":"FSharpEntity.IsDelegate \nIsDelegate \n Indicates if the entity is a delegate type definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsProvidedAndErased","title":"FSharpEntity.IsProvidedAndErased","content":"FSharpEntity.IsProvidedAndErased \nIsProvidedAndErased \n Indicates if the entity is an erased provided type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#BasicQualifiedName","title":"FSharpEntity.BasicQualifiedName","content":"FSharpEntity.BasicQualifiedName \nBasicQualifiedName \n The fully qualified name of the type or module without strong assembly name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#XmlDocSig","title":"FSharpEntity.XmlDocSig","content":"FSharpEntity.XmlDocSig \nXmlDocSig \n Get the XML documentation signature for the entity, used for .xml file lookup for compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsStaticInstantiation","title":"FSharpEntity.IsStaticInstantiation","content":"FSharpEntity.IsStaticInstantiation \nIsStaticInstantiation \n Indicates if the entity is a \u0027fake\u0027 symbol related to a static instantiation of a type provider","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#AbbreviatedType","title":"FSharpEntity.AbbreviatedType","content":"FSharpEntity.AbbreviatedType \nAbbreviatedType \n Get the type abbreviated by an F# type abbreviation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#IsOpaque","title":"FSharpEntity.IsOpaque","content":"FSharpEntity.IsOpaque \nIsOpaque \n Indicates if the entity is a type definition for a reference type where the implementation details are hidden by a signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpentity.html#HasAssemblyCodeRepresentation","title":"FSharpEntity.HasAssemblyCodeRepresentation","content":"FSharpEntity.HasAssemblyCodeRepresentation \nHasAssemblyCodeRepresentation \n Indicates if the type is implemented through a mapping to IL assembly code. This is only\n true for types in FSharp.Core.dll","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexpr.html","title":"FSharpExpr","content":"FSharpExpr \n Represents a checked and reduced expression, as seen by the F# language. The active patterns\n in \u0027FSharp.Compiler.SourceCodeServices\u0027 can be used to analyze information about the expression.\n\n Pattern matching is reduced to decision trees and conditional tests. Some other\n constructs may be represented in reduced form. \nFSharpExpr.Range \nRange \nFSharpExpr.Type \nType \nFSharpExpr.ImmediateSubExpressions \nImmediateSubExpressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexpr.html#Range","title":"FSharpExpr.Range","content":"FSharpExpr.Range \nRange \n The range of the expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexpr.html#Type","title":"FSharpExpr.Type","content":"FSharpExpr.Type \nType \n The type of the expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpexpr.html#ImmediateSubExpressions","title":"FSharpExpr.ImmediateSubExpressions","content":"FSharpExpr.ImmediateSubExpressions \nImmediateSubExpressions \n The immediate sub-expressions of the expression.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html","title":"FSharpField","content":"FSharpField \n A subtype of FSharpSymbol that represents a record or union case field as seen by the F# language \nFSharpField.LiteralValue \nLiteralValue \nFSharpField.IsUnresolved \nIsUnresolved \nFSharpField.FieldAttributes \nFieldAttributes \nFSharpField.IsAnonRecordField \nIsAnonRecordField \nFSharpField.IsNameGenerated \nIsNameGenerated \nFSharpField.IsDefaultValue \nIsDefaultValue \nFSharpField.DeclaringEntity \nDeclaringEntity \nFSharpField.IsStatic \nIsStatic \nFSharpField.IsLiteral \nIsLiteral \nFSharpField.IsMutable \nIsMutable \nFSharpField.IsVolatile \nIsVolatile \nFSharpField.IsCompilerGenerated \nIsCompilerGenerated \nFSharpField.DeclarationLocation \nDeclarationLocation \nFSharpField.XmlDocSig \nXmlDocSig \nFSharpField.Name \nName \nFSharpField.PropertyAttributes \nPropertyAttributes \nFSharpField.IsUnionCaseField \nIsUnionCaseField \nFSharpField.DeclaringUnionCase \nDeclaringUnionCase \nFSharpField.AnonRecordFieldDetails \nAnonRecordFieldDetails \nFSharpField.XmlDoc \nXmlDoc \nFSharpField.FieldType \nFieldType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#LiteralValue","title":"FSharpField.LiteralValue","content":"FSharpField.LiteralValue \nLiteralValue \n Get the default initialization info, for static literals","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsUnresolved","title":"FSharpField.IsUnresolved","content":"FSharpField.IsUnresolved \nIsUnresolved \n Indicates if the record field is for a type in an unresolved assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#FieldAttributes","title":"FSharpField.FieldAttributes","content":"FSharpField.FieldAttributes \nFieldAttributes \n Get the attributes attached to generated field","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsAnonRecordField","title":"FSharpField.IsAnonRecordField","content":"FSharpField.IsAnonRecordField \nIsAnonRecordField \n Is this a field from an anonymous record type?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsNameGenerated","title":"FSharpField.IsNameGenerated","content":"FSharpField.IsNameGenerated \nIsNameGenerated \n Indicates if the field name was generated by compiler (e.g. ItemN names in union cases and DataN in exceptions).\n This API returns true for source defined symbols only.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsDefaultValue","title":"FSharpField.IsDefaultValue","content":"FSharpField.IsDefaultValue \nIsDefaultValue \n Indicates if the field declared is declared \u0027DefaultValue\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#DeclaringEntity","title":"FSharpField.DeclaringEntity","content":"FSharpField.DeclaringEntity \nDeclaringEntity \n Get the declaring entity of this field, if any. Fields from anonymous types do not have a declaring entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsStatic","title":"FSharpField.IsStatic","content":"FSharpField.IsStatic \nIsStatic \n Indicates a static field","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsLiteral","title":"FSharpField.IsLiteral","content":"FSharpField.IsLiteral \nIsLiteral \n Indicates if the field has a literal value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsMutable","title":"FSharpField.IsMutable","content":"FSharpField.IsMutable \nIsMutable \n Indicates if the field is declared \u0027static\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsVolatile","title":"FSharpField.IsVolatile","content":"FSharpField.IsVolatile \nIsVolatile \n Indicates if the field is declared volatile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsCompilerGenerated","title":"FSharpField.IsCompilerGenerated","content":"FSharpField.IsCompilerGenerated \nIsCompilerGenerated \n Indicates a compiler generated field, not visible to Intellisense or name resolution","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#DeclarationLocation","title":"FSharpField.DeclarationLocation","content":"FSharpField.DeclarationLocation \nDeclarationLocation \n Get the declaration location of the field","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#XmlDocSig","title":"FSharpField.XmlDocSig","content":"FSharpField.XmlDocSig \nXmlDocSig \n Get the XML documentation signature for .xml file lookup for the field, used for .xml file lookup for compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#Name","title":"FSharpField.Name","content":"FSharpField.Name \nName \n Get the name of the field","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#PropertyAttributes","title":"FSharpField.PropertyAttributes","content":"FSharpField.PropertyAttributes \nPropertyAttributes \n Get the attributes attached to generated property","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#IsUnionCaseField","title":"FSharpField.IsUnionCaseField","content":"FSharpField.IsUnionCaseField \nIsUnionCaseField \n Indicates if the field is declared in a union case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#DeclaringUnionCase","title":"FSharpField.DeclaringUnionCase","content":"FSharpField.DeclaringUnionCase \nDeclaringUnionCase \n Returns the declaring union case symbol","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#AnonRecordFieldDetails","title":"FSharpField.AnonRecordFieldDetails","content":"FSharpField.AnonRecordFieldDetails \nAnonRecordFieldDetails \n If the field is from an anonymous record type then get the details of the field including the index in the sorted array of fields","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#XmlDoc","title":"FSharpField.XmlDoc","content":"FSharpField.XmlDoc \nXmlDoc \n Get the XML documentation for the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpfield.html#FieldType","title":"FSharpField.FieldType","content":"FSharpField.FieldType \nFieldType \n Get the type of the field, w.r.t. the generic parameters of the enclosing type constructor","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html","title":"FSharpGenericParameter","content":"FSharpGenericParameter \n A subtype of FSharpSymbol that represents a generic parameter for an FSharpSymbol \nFSharpGenericParameter.IsMeasure \nIsMeasure \nFSharpGenericParameter.IsCompilerGenerated \nIsCompilerGenerated \nFSharpGenericParameter.Constraints \nConstraints \nFSharpGenericParameter.DeclarationLocation \nDeclarationLocation \nFSharpGenericParameter.Name \nName \nFSharpGenericParameter.IsSolveAtCompileTime \nIsSolveAtCompileTime \nFSharpGenericParameter.XmlDoc \nXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#IsMeasure","title":"FSharpGenericParameter.IsMeasure","content":"FSharpGenericParameter.IsMeasure \nIsMeasure \n Indicates if this is a measure variable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#IsCompilerGenerated","title":"FSharpGenericParameter.IsCompilerGenerated","content":"FSharpGenericParameter.IsCompilerGenerated \nIsCompilerGenerated \n Indicates if this is a compiler generated type parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#Constraints","title":"FSharpGenericParameter.Constraints","content":"FSharpGenericParameter.Constraints \nConstraints \n Get the declared or inferred constraints for the type parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#DeclarationLocation","title":"FSharpGenericParameter.DeclarationLocation","content":"FSharpGenericParameter.DeclarationLocation \nDeclarationLocation \n Get the range of the generic parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#Name","title":"FSharpGenericParameter.Name","content":"FSharpGenericParameter.Name \nName \n Get the name of the generic parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#IsSolveAtCompileTime","title":"FSharpGenericParameter.IsSolveAtCompileTime","content":"FSharpGenericParameter.IsSolveAtCompileTime \nIsSolveAtCompileTime \n Indicates if this is a statically resolved type variable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameter.html#XmlDoc","title":"FSharpGenericParameter.XmlDoc","content":"FSharpGenericParameter.XmlDoc \nXmlDoc \n Get the XML documentation for the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html","title":"FSharpGenericParameterConstraint","content":"FSharpGenericParameterConstraint \n Represents a constraint on a generic type parameter \nFSharpGenericParameterConstraint.IsRequiresDefaultConstructorConstraint \nIsRequiresDefaultConstructorConstraint \nFSharpGenericParameterConstraint.SimpleChoices \nSimpleChoices \nFSharpGenericParameterConstraint.EnumConstraintTarget \nEnumConstraintTarget \nFSharpGenericParameterConstraint.IsDefaultsToConstraint \nIsDefaultsToConstraint \nFSharpGenericParameterConstraint.DelegateConstraintData \nDelegateConstraintData \nFSharpGenericParameterConstraint.IsComparisonConstraint \nIsComparisonConstraint \nFSharpGenericParameterConstraint.MemberConstraintData \nMemberConstraintData \nFSharpGenericParameterConstraint.CoercesToTarget \nCoercesToTarget \nFSharpGenericParameterConstraint.IsNonNullableValueTypeConstraint \nIsNonNullableValueTypeConstraint \nFSharpGenericParameterConstraint.IsDelegateConstraint \nIsDelegateConstraint \nFSharpGenericParameterConstraint.IsSimpleChoiceConstraint \nIsSimpleChoiceConstraint \nFSharpGenericParameterConstraint.IsEnumConstraint \nIsEnumConstraint \nFSharpGenericParameterConstraint.IsUnmanagedConstraint \nIsUnmanagedConstraint \nFSharpGenericParameterConstraint.IsReferenceTypeConstraint \nIsReferenceTypeConstraint \nFSharpGenericParameterConstraint.IsEqualityConstraint \nIsEqualityConstraint \nFSharpGenericParameterConstraint.IsCoercesToConstraint \nIsCoercesToConstraint \nFSharpGenericParameterConstraint.IsMemberConstraint \nIsMemberConstraint \nFSharpGenericParameterConstraint.DefaultsToConstraintData \nDefaultsToConstraintData \nFSharpGenericParameterConstraint.IsSupportsNullConstraint \nIsSupportsNullConstraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsRequiresDefaultConstructorConstraint","title":"FSharpGenericParameterConstraint.IsRequiresDefaultConstructorConstraint","content":"FSharpGenericParameterConstraint.IsRequiresDefaultConstructorConstraint \nIsRequiresDefaultConstructorConstraint \n Indicates a constraint that a type has a parameterless constructor","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#SimpleChoices","title":"FSharpGenericParameterConstraint.SimpleChoices","content":"FSharpGenericParameterConstraint.SimpleChoices \nSimpleChoices \n Gets further information about a choice constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#EnumConstraintTarget","title":"FSharpGenericParameterConstraint.EnumConstraintTarget","content":"FSharpGenericParameterConstraint.EnumConstraintTarget \nEnumConstraintTarget \n Gets further information about an enumeration constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsDefaultsToConstraint","title":"FSharpGenericParameterConstraint.IsDefaultsToConstraint","content":"FSharpGenericParameterConstraint.IsDefaultsToConstraint \nIsDefaultsToConstraint \n Indicates a default value for an inference type variable should it be neither generalized nor solved","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#DelegateConstraintData","title":"FSharpGenericParameterConstraint.DelegateConstraintData","content":"FSharpGenericParameterConstraint.DelegateConstraintData \nDelegateConstraintData \n Gets further information about a delegate constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsComparisonConstraint","title":"FSharpGenericParameterConstraint.IsComparisonConstraint","content":"FSharpGenericParameterConstraint.IsComparisonConstraint \nIsComparisonConstraint \n Indicates a constraint that a type supports F# generic comparison","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#MemberConstraintData","title":"FSharpGenericParameterConstraint.MemberConstraintData","content":"FSharpGenericParameterConstraint.MemberConstraintData \nMemberConstraintData \n Gets further information about a member constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#CoercesToTarget","title":"FSharpGenericParameterConstraint.CoercesToTarget","content":"FSharpGenericParameterConstraint.CoercesToTarget \nCoercesToTarget \n Gets further information about a coerces-to constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsNonNullableValueTypeConstraint","title":"FSharpGenericParameterConstraint.IsNonNullableValueTypeConstraint","content":"FSharpGenericParameterConstraint.IsNonNullableValueTypeConstraint \nIsNonNullableValueTypeConstraint \n Indicates a constraint that a type is a non-Nullable value type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsDelegateConstraint","title":"FSharpGenericParameterConstraint.IsDelegateConstraint","content":"FSharpGenericParameterConstraint.IsDelegateConstraint \nIsDelegateConstraint \n Indicates a constraint that a type is a delegate from the given tuple of args to the given return type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsSimpleChoiceConstraint","title":"FSharpGenericParameterConstraint.IsSimpleChoiceConstraint","content":"FSharpGenericParameterConstraint.IsSimpleChoiceConstraint \nIsSimpleChoiceConstraint \n Indicates a constraint that is a type is a simple choice between one of the given ground types. Used by printf format strings.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsEnumConstraint","title":"FSharpGenericParameterConstraint.IsEnumConstraint","content":"FSharpGenericParameterConstraint.IsEnumConstraint \nIsEnumConstraint \n Indicates a constraint that a type is an enum with the given underlying","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsUnmanagedConstraint","title":"FSharpGenericParameterConstraint.IsUnmanagedConstraint","content":"FSharpGenericParameterConstraint.IsUnmanagedConstraint \nIsUnmanagedConstraint \n Indicates a constraint that a type is an unmanaged type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsReferenceTypeConstraint","title":"FSharpGenericParameterConstraint.IsReferenceTypeConstraint","content":"FSharpGenericParameterConstraint.IsReferenceTypeConstraint \nIsReferenceTypeConstraint \n Indicates a constraint that a type is a reference type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsEqualityConstraint","title":"FSharpGenericParameterConstraint.IsEqualityConstraint","content":"FSharpGenericParameterConstraint.IsEqualityConstraint \nIsEqualityConstraint \n Indicates a constraint that a type supports F# generic equality","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsCoercesToConstraint","title":"FSharpGenericParameterConstraint.IsCoercesToConstraint","content":"FSharpGenericParameterConstraint.IsCoercesToConstraint \nIsCoercesToConstraint \n Indicates a constraint that a type is a subtype of the given type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsMemberConstraint","title":"FSharpGenericParameterConstraint.IsMemberConstraint","content":"FSharpGenericParameterConstraint.IsMemberConstraint \nIsMemberConstraint \n Indicates a constraint that a type has a member with the given signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#DefaultsToConstraintData","title":"FSharpGenericParameterConstraint.DefaultsToConstraintData","content":"FSharpGenericParameterConstraint.DefaultsToConstraintData \nDefaultsToConstraintData \n Gets further information about a defaults-to constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html#IsSupportsNullConstraint","title":"FSharpGenericParameterConstraint.IsSupportsNullConstraint","content":"FSharpGenericParameterConstraint.IsSupportsNullConstraint \nIsSupportsNullConstraint \n Indicates a constraint that a type has a \u0027null\u0027 value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterdefaultstoconstraint.html","title":"FSharpGenericParameterDefaultsToConstraint","content":"FSharpGenericParameterDefaultsToConstraint \n Represents further information about a \u0027defaults to\u0027 constraint on a generic type parameter \nFSharpGenericParameterDefaultsToConstraint.DefaultsToPriority \nDefaultsToPriority \nFSharpGenericParameterDefaultsToConstraint.DefaultsToTarget \nDefaultsToTarget","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterdefaultstoconstraint.html#DefaultsToPriority","title":"FSharpGenericParameterDefaultsToConstraint.DefaultsToPriority","content":"FSharpGenericParameterDefaultsToConstraint.DefaultsToPriority \nDefaultsToPriority \n Get the priority off the \u0027defaults to\u0027 constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterdefaultstoconstraint.html#DefaultsToTarget","title":"FSharpGenericParameterDefaultsToConstraint.DefaultsToTarget","content":"FSharpGenericParameterDefaultsToConstraint.DefaultsToTarget \nDefaultsToTarget \n Get the default type associated with the \u0027defaults to\u0027 constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterdelegateconstraint.html","title":"FSharpGenericParameterDelegateConstraint","content":"FSharpGenericParameterDelegateConstraint \n Represents further information about a delegate constraint on a generic type parameter \nFSharpGenericParameterDelegateConstraint.DelegateReturnType \nDelegateReturnType \nFSharpGenericParameterDelegateConstraint.DelegateTupledArgumentType \nDelegateTupledArgumentType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterdelegateconstraint.html#DelegateReturnType","title":"FSharpGenericParameterDelegateConstraint.DelegateReturnType","content":"FSharpGenericParameterDelegateConstraint.DelegateReturnType \nDelegateReturnType \n Get the return type required by the constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparameterdelegateconstraint.html#DelegateTupledArgumentType","title":"FSharpGenericParameterDelegateConstraint.DelegateTupledArgumentType","content":"FSharpGenericParameterDelegateConstraint.DelegateTupledArgumentType \nDelegateTupledArgumentType \n Get the tupled argument type required by the constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html","title":"FSharpGenericParameterMemberConstraint","content":"FSharpGenericParameterMemberConstraint \n Represents further information about a member constraint on a generic type parameter \nFSharpGenericParameterMemberConstraint.MemberName \nMemberName \nFSharpGenericParameterMemberConstraint.MemberSources \nMemberSources \nFSharpGenericParameterMemberConstraint.MemberReturnType \nMemberReturnType \nFSharpGenericParameterMemberConstraint.MemberArgumentTypes \nMemberArgumentTypes \nFSharpGenericParameterMemberConstraint.MemberIsStatic \nMemberIsStatic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html#MemberName","title":"FSharpGenericParameterMemberConstraint.MemberName","content":"FSharpGenericParameterMemberConstraint.MemberName \nMemberName \n Get the name of the method required by the constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html#MemberSources","title":"FSharpGenericParameterMemberConstraint.MemberSources","content":"FSharpGenericParameterMemberConstraint.MemberSources \nMemberSources \n Get the types that may be used to satisfy the constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html#MemberReturnType","title":"FSharpGenericParameterMemberConstraint.MemberReturnType","content":"FSharpGenericParameterMemberConstraint.MemberReturnType \nMemberReturnType \n Get the return type of the method required by the constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html#MemberArgumentTypes","title":"FSharpGenericParameterMemberConstraint.MemberArgumentTypes","content":"FSharpGenericParameterMemberConstraint.MemberArgumentTypes \nMemberArgumentTypes \n Get the argument types of the method required by the constraint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html#MemberIsStatic","title":"FSharpGenericParameterMemberConstraint.MemberIsStatic","content":"FSharpGenericParameterMemberConstraint.MemberIsStatic \nMemberIsStatic \n Indicates if the the method required by the constraint must be static","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html","title":"FSharpImplementationFileContents","content":"FSharpImplementationFileContents \n Represents the definitional contents of a single file or fragment in an assembly, as seen by the F# language \nFSharpImplementationFileContents.FileName \nFileName \nFSharpImplementationFileContents.IsScript \nIsScript \nFSharpImplementationFileContents.Declarations \nDeclarations \nFSharpImplementationFileContents.QualifiedName \nQualifiedName \nFSharpImplementationFileContents.HasExplicitEntryPoint \nHasExplicitEntryPoint","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html#FileName","title":"FSharpImplementationFileContents.FileName","content":"FSharpImplementationFileContents.FileName \nFileName \n Get the system path of the implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html#IsScript","title":"FSharpImplementationFileContents.IsScript","content":"FSharpImplementationFileContents.IsScript \nIsScript \n Indicates if the implementation file is a script","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html#Declarations","title":"FSharpImplementationFileContents.Declarations","content":"FSharpImplementationFileContents.Declarations \nDeclarations \n Get the declarations that make up this implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html#QualifiedName","title":"FSharpImplementationFileContents.QualifiedName","content":"FSharpImplementationFileContents.QualifiedName \nQualifiedName \n The qualified name acts to fully-qualify module specifications and implementations","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html#HasExplicitEntryPoint","title":"FSharpImplementationFileContents.HasExplicitEntryPoint","content":"FSharpImplementationFileContents.HasExplicitEntryPoint \nHasExplicitEntryPoint \n Indicates if the implementation file has an explicit entry point","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html","title":"FSharpImplementationFileDeclaration","content":"FSharpImplementationFileDeclaration \n Represents a declaration in an implementation file, as seen by the F# language \nFSharpImplementationFileDeclaration.Entity \nEntity \nFSharpImplementationFileDeclaration.MemberOrFunctionOrValue \nMemberOrFunctionOrValue \nFSharpImplementationFileDeclaration.InitAction \nInitAction","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html#Entity","title":"FSharpImplementationFileDeclaration.Entity","content":"FSharpImplementationFileDeclaration.Entity \nEntity \n Represents the declaration of a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html#MemberOrFunctionOrValue","title":"FSharpImplementationFileDeclaration.MemberOrFunctionOrValue","content":"FSharpImplementationFileDeclaration.MemberOrFunctionOrValue \nMemberOrFunctionOrValue \n Represents the declaration of a member, function or value, including the parameters and body of the member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html#InitAction","title":"FSharpImplementationFileDeclaration.InitAction","content":"FSharpImplementationFileDeclaration.InitAction \nInitAction \n Represents the declaration of a static initialization action","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpinlineannotation.html","title":"FSharpInlineAnnotation","content":"FSharpInlineAnnotation \n \nFSharpInlineAnnotation.AlwaysInline \nAlwaysInline \nFSharpInlineAnnotation.OptionalInline \nOptionalInline \nFSharpInlineAnnotation.NeverInline \nNeverInline \nFSharpInlineAnnotation.AggressiveInline \nAggressiveInline","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpinlineannotation.html#AlwaysInline","title":"FSharpInlineAnnotation.AlwaysInline","content":"FSharpInlineAnnotation.AlwaysInline \nAlwaysInline \n Indicates the value is always inlined in statically compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpinlineannotation.html#OptionalInline","title":"FSharpInlineAnnotation.OptionalInline","content":"FSharpInlineAnnotation.OptionalInline \nOptionalInline \n Indicates the value is optionally inlined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpinlineannotation.html#NeverInline","title":"FSharpInlineAnnotation.NeverInline","content":"FSharpInlineAnnotation.NeverInline \nNeverInline \n Indicates the value is never inlined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpinlineannotation.html#AggressiveInline","title":"FSharpInlineAnnotation.AggressiveInline","content":"FSharpInlineAnnotation.AggressiveInline \nAggressiveInline \n Indicates the value is aggressively inlined by the .NET runtime","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html","title":"FSharpMemberOrFunctionOrValue","content":"FSharpMemberOrFunctionOrValue \n A subtype of F# symbol that represents an F# method, property, event, function or value, including extension members. \nFSharpMemberOrFunctionOrValue.FormatLayout \nFormatLayout \nFSharpMemberOrFunctionOrValue.GetOverloads \nGetOverloads \nFSharpMemberOrFunctionOrValue.GetReturnTypeLayout \nGetReturnTypeLayout \nFSharpMemberOrFunctionOrValue.GetValSignatureText \nGetValSignatureText \nFSharpMemberOrFunctionOrValue.GetWitnessPassingInfo \nGetWitnessPassingInfo \nFSharpMemberOrFunctionOrValue.TryGetFullCompiledOperatorNameIdents \nTryGetFullCompiledOperatorNameIdents \nFSharpMemberOrFunctionOrValue.TryGetFullDisplayName \nTryGetFullDisplayName \nFSharpMemberOrFunctionOrValue.IsFunction \nIsFunction \nFSharpMemberOrFunctionOrValue.InlineAnnotation \nInlineAnnotation \nFSharpMemberOrFunctionOrValue.EventIsStandard \nEventIsStandard \nFSharpMemberOrFunctionOrValue.CurriedParameterGroups \nCurriedParameterGroups \nFSharpMemberOrFunctionOrValue.CompiledName \nCompiledName \nFSharpMemberOrFunctionOrValue.IsActivePattern \nIsActivePattern \nFSharpMemberOrFunctionOrValue.IsUnionCaseTester \nIsUnionCaseTester \nFSharpMemberOrFunctionOrValue.IsMember \nIsMember \nFSharpMemberOrFunctionOrValue.IsValCompiledAsMethod \nIsValCompiledAsMethod \nFSharpMemberOrFunctionOrValue.HasSetterMethod \nHasSetterMethod \nFSharpMemberOrFunctionOrValue.DeclaringEntity \nDeclaringEntity \nFSharpMemberOrFunctionOrValue.EventDelegateType \nEventDelegateType \nFSharpMemberOrFunctionOrValue.IsReferencedValue \nIsReferencedValue \nFSharpMemberOrFunctionOrValue.IsOverrideOrExplicitInterfaceImplementation \nIsOverrideOrExplicitInterfaceImplementation \nFSharpMemberOrFunctionOrValue.IsPropertyGetterMethod \nIsPropertyGetterMethod \nFSharpMemberOrFunctionOrValue.IsPropertySetterMethod \nIsPropertySetterMethod \nFSharpMemberOrFunctionOrValue.FullTypeSafe \nFullTypeSafe \nFSharpMemberOrFunctionOrValue.IsValue \nIsValue \nFSharpMemberOrFunctionOrValue.LiteralValue \nLiteralValue \nFSharpMemberOrFunctionOrValue.GenericParameters \nGenericParameters \nFSharpMemberOrFunctionOrValue.IsInstanceMember \nIsInstanceMember \nFSharpMemberOrFunctionOrValue.IsConstructorThisValue \nIsConstructorThisValue \nFSharpMemberOrFunctionOrValue.ImplementedAbstractSignatures \nImplementedAbstractSignatures \nFSharpMemberOrFunctionOrValue.IsConstructor \nIsConstructor \nFSharpMemberOrFunctionOrValue.IsCompilerGenerated \nIsCompilerGenerated \nFSharpMemberOrFunctionOrValue.XmlDoc \nXmlDoc \nFSharpMemberOrFunctionOrValue.IsModuleValueOrMember \nIsModuleValueOrMember \nFSharpMemberOrFunctionOrValue.IsImplicitConstructor \nIsImplicitConstructor \nFSharpMemberOrFunctionOrValue.IsBaseValue \nIsBaseValue \nFSharpMemberOrFunctionOrValue.SetterMethod \nSetterMethod \nFSharpMemberOrFunctionOrValue.IsEventAddMethod \nIsEventAddMethod \nFSharpMemberOrFunctionOrValue.IsEventRemoveMethod \nIsEventRemoveMethod \nFSharpMemberOrFunctionOrValue.IsMethod \nIsMethod \nFSharpMemberOrFunctionOrValue.XmlDocSig \nXmlDocSig \nFSharpMemberOrFunctionOrValue.IsMutable \nIsMutable \nFSharpMemberOrFunctionOrValue.IsUnresolved \nIsUnresolved \nFSharpMemberOrFunctionOrValue.FullType \nFullType \nFSharpMemberOrFunctionOrValue.EventRemoveMethod \nEventRemoveMethod \nFSharpMemberOrFunctionOrValue.IsProperty \nIsProperty \nFSharpMemberOrFunctionOrValue.IsDispatchSlot \nIsDispatchSlot \nFSharpMemberOrFunctionOrValue.IsTypeFunction \nIsTypeFunction \nFSharpMemberOrFunctionOrValue.IsInstanceMemberInCompiledCode \nIsInstanceMemberInCompiledCode \nFSharpMemberOrFunctionOrValue.ReturnParameter \nReturnParameter \nFSharpMemberOrFunctionOrValue.IsMemberThisValue \nIsMemberThisValue \nFSharpMemberOrFunctionOrValue.IsRefCell \nIsRefCell \nFSharpMemberOrFunctionOrValue.LogicalName \nLogicalName \nFSharpMemberOrFunctionOrValue.HasGetterMethod \nHasGetterMethod \nFSharpMemberOrFunctionOrValue.IsExplicitInterfaceImplementation \nIsExplicitInterfaceImplementation \nFSharpMemberOrFunctionOrValue.IsEvent \nIsEvent \nFSharpMemberOrFunctionOrValue.IsExtensionMember \nIsExtensionMember \nFSharpMemberOrFunctionOrValue.ApparentEnclosingEntity \nApparentEnclosingEntity \nFSharpMemberOrFunctionOrValue.EventAddMethod \nEventAddMethod \nFSharpMemberOrFunctionOrValue.GetterMethod \nGetterMethod \nFSharpMemberOrFunctionOrValue.EventForFSharpProperty \nEventForFSharpProperty \nFSharpMemberOrFunctionOrValue.DisplayName \nDisplayName \nFSharpMemberOrFunctionOrValue.DeclarationLocation \nDeclarationLocation \nFSharpMemberOrFunctionOrValue.HasSignatureFile \nHasSignatureFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#FormatLayout","title":"FSharpMemberOrFunctionOrValue.FormatLayout","content":"FSharpMemberOrFunctionOrValue.FormatLayout \nFormatLayout \n Format the type using the rules of the given display context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#GetOverloads","title":"FSharpMemberOrFunctionOrValue.GetOverloads","content":"FSharpMemberOrFunctionOrValue.GetOverloads \nGetOverloads \nGets the overloads for the current method.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#GetReturnTypeLayout","title":"FSharpMemberOrFunctionOrValue.GetReturnTypeLayout","content":"FSharpMemberOrFunctionOrValue.GetReturnTypeLayout \nGetReturnTypeLayout \n Format the type using the rules of the given display context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#GetValSignatureText","title":"FSharpMemberOrFunctionOrValue.GetValSignatureText","content":"FSharpMemberOrFunctionOrValue.GetValSignatureText \nGetValSignatureText \n Get the signature text to include this Symbol into an existing signature file.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#GetWitnessPassingInfo","title":"FSharpMemberOrFunctionOrValue.GetWitnessPassingInfo","content":"FSharpMemberOrFunctionOrValue.GetWitnessPassingInfo \nGetWitnessPassingInfo \n Check if this method has an entrpoint that accepts witness arguments and if so return\n the name of that entrypoint and information about the additional witness arguments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#TryGetFullCompiledOperatorNameIdents","title":"FSharpMemberOrFunctionOrValue.TryGetFullCompiledOperatorNameIdents","content":"FSharpMemberOrFunctionOrValue.TryGetFullCompiledOperatorNameIdents \nTryGetFullCompiledOperatorNameIdents \n Full operator compiled name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#TryGetFullDisplayName","title":"FSharpMemberOrFunctionOrValue.TryGetFullDisplayName","content":"FSharpMemberOrFunctionOrValue.TryGetFullDisplayName \nTryGetFullDisplayName \n Full name with last part replaced with display name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsFunction","title":"FSharpMemberOrFunctionOrValue.IsFunction","content":"FSharpMemberOrFunctionOrValue.IsFunction \nIsFunction \n Indicated if this is a function","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#InlineAnnotation","title":"FSharpMemberOrFunctionOrValue.InlineAnnotation","content":"FSharpMemberOrFunctionOrValue.InlineAnnotation \nInlineAnnotation \n Get a result indicating if this is a must-inline value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#EventIsStandard","title":"FSharpMemberOrFunctionOrValue.EventIsStandard","content":"FSharpMemberOrFunctionOrValue.EventIsStandard \nEventIsStandard \n Indicate if an event can be considered to be a property for the F# type system of type IEvent or IDelegateEvent.\n In this case ReturnParameter will have a type corresponding to the property type. For\n non-standard events, ReturnParameter will have a type corresponding to the delegate type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#CurriedParameterGroups","title":"FSharpMemberOrFunctionOrValue.CurriedParameterGroups","content":"FSharpMemberOrFunctionOrValue.CurriedParameterGroups \nCurriedParameterGroups \nList of list of parameters, where each nested item represents a defined parameter \n\n Typically, there is only one nested list.\n However, code such as \u0027f (a, b) (c, d)\u0027 contains two groups, each with two parameters.\n In that example, there is a list made up of two lists, each with a parameter.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#CompiledName","title":"FSharpMemberOrFunctionOrValue.CompiledName","content":"FSharpMemberOrFunctionOrValue.CompiledName \nCompiledName \n Get the member name in compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsActivePattern","title":"FSharpMemberOrFunctionOrValue.IsActivePattern","content":"FSharpMemberOrFunctionOrValue.IsActivePattern \nIsActivePattern \n Indicates if this value or member is an F# active pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsUnionCaseTester","title":"FSharpMemberOrFunctionOrValue.IsUnionCaseTester","content":"FSharpMemberOrFunctionOrValue.IsUnionCaseTester \nIsUnionCaseTester \n Indicates if the property or getter method is part of a IsABC union case tester implied by a union case definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsMember","title":"FSharpMemberOrFunctionOrValue.IsMember","content":"FSharpMemberOrFunctionOrValue.IsMember \nIsMember \n Indicates if this is a member, including extension members?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsValCompiledAsMethod","title":"FSharpMemberOrFunctionOrValue.IsValCompiledAsMethod","content":"FSharpMemberOrFunctionOrValue.IsValCompiledAsMethod \nIsValCompiledAsMethod \n Indicated if this is a value compiled to a method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#HasSetterMethod","title":"FSharpMemberOrFunctionOrValue.HasSetterMethod","content":"FSharpMemberOrFunctionOrValue.HasSetterMethod \nHasSetterMethod \n Indicates if this is a property and there exists an associated setter method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#DeclaringEntity","title":"FSharpMemberOrFunctionOrValue.DeclaringEntity","content":"FSharpMemberOrFunctionOrValue.DeclaringEntity \nDeclaringEntity \n Get the enclosing entity for the definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#EventDelegateType","title":"FSharpMemberOrFunctionOrValue.EventDelegateType","content":"FSharpMemberOrFunctionOrValue.EventDelegateType \nEventDelegateType \n Get an associated delegate type of an event","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsReferencedValue","title":"FSharpMemberOrFunctionOrValue.IsReferencedValue","content":"FSharpMemberOrFunctionOrValue.IsReferencedValue \nIsReferencedValue \n Indicates if this is a value that has been referenced","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsOverrideOrExplicitInterfaceImplementation","title":"FSharpMemberOrFunctionOrValue.IsOverrideOrExplicitInterfaceImplementation","content":"FSharpMemberOrFunctionOrValue.IsOverrideOrExplicitInterfaceImplementation \nIsOverrideOrExplicitInterfaceImplementation \n Indicates if this is an \u0027override\u0027, \u0027default\u0027 or an explicit implementation of an interface member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsPropertyGetterMethod","title":"FSharpMemberOrFunctionOrValue.IsPropertyGetterMethod","content":"FSharpMemberOrFunctionOrValue.IsPropertyGetterMethod \nIsPropertyGetterMethod \n Indicates if this is a getter method for a property, or a use of a property in getter mode","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsPropertySetterMethod","title":"FSharpMemberOrFunctionOrValue.IsPropertySetterMethod","content":"FSharpMemberOrFunctionOrValue.IsPropertySetterMethod \nIsPropertySetterMethod \n Indicates if this is a setter method for a property, or a use of a property in setter mode","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#FullTypeSafe","title":"FSharpMemberOrFunctionOrValue.FullTypeSafe","content":"FSharpMemberOrFunctionOrValue.FullTypeSafe \nFullTypeSafe \n Safe version of \u0060FullType\u0060.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsValue","title":"FSharpMemberOrFunctionOrValue.IsValue","content":"FSharpMemberOrFunctionOrValue.IsValue \nIsValue \n Indicated if this is a value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#LiteralValue","title":"FSharpMemberOrFunctionOrValue.LiteralValue","content":"FSharpMemberOrFunctionOrValue.LiteralValue \nLiteralValue \n Indicates if this is a [\u003CLiteral\u003E] value, and if so what value? (may be null)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#GenericParameters","title":"FSharpMemberOrFunctionOrValue.GenericParameters","content":"FSharpMemberOrFunctionOrValue.GenericParameters \nGenericParameters \n Get the typars of the member, function or value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsInstanceMember","title":"FSharpMemberOrFunctionOrValue.IsInstanceMember","content":"FSharpMemberOrFunctionOrValue.IsInstanceMember \nIsInstanceMember \n Indicates if this is an instance member, when seen from F#?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsConstructorThisValue","title":"FSharpMemberOrFunctionOrValue.IsConstructorThisValue","content":"FSharpMemberOrFunctionOrValue.IsConstructorThisValue \nIsConstructorThisValue \n Indicates if this is the \u0022x\u0022 in \u0022type C() as x = ...\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#ImplementedAbstractSignatures","title":"FSharpMemberOrFunctionOrValue.ImplementedAbstractSignatures","content":"FSharpMemberOrFunctionOrValue.ImplementedAbstractSignatures \nImplementedAbstractSignatures \n Gets the list of the abstract slot signatures implemented by the member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsConstructor","title":"FSharpMemberOrFunctionOrValue.IsConstructor","content":"FSharpMemberOrFunctionOrValue.IsConstructor \nIsConstructor \n Indicates if this is a constructor.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsCompilerGenerated","title":"FSharpMemberOrFunctionOrValue.IsCompilerGenerated","content":"FSharpMemberOrFunctionOrValue.IsCompilerGenerated \nIsCompilerGenerated \n Indicates if this is a compiler generated value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#XmlDoc","title":"FSharpMemberOrFunctionOrValue.XmlDoc","content":"FSharpMemberOrFunctionOrValue.XmlDoc \nXmlDoc \n Get the XML documentation for the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsModuleValueOrMember","title":"FSharpMemberOrFunctionOrValue.IsModuleValueOrMember","content":"FSharpMemberOrFunctionOrValue.IsModuleValueOrMember \nIsModuleValueOrMember \n Indicates if this is a module or member value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsImplicitConstructor","title":"FSharpMemberOrFunctionOrValue.IsImplicitConstructor","content":"FSharpMemberOrFunctionOrValue.IsImplicitConstructor \nIsImplicitConstructor \n Indicates if this is an implicit constructor?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsBaseValue","title":"FSharpMemberOrFunctionOrValue.IsBaseValue","content":"FSharpMemberOrFunctionOrValue.IsBaseValue \nIsBaseValue \n Indicates if this is \u0022base\u0022 in \u0022base.M(...)\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#SetterMethod","title":"FSharpMemberOrFunctionOrValue.SetterMethod","content":"FSharpMemberOrFunctionOrValue.SetterMethod \nSetterMethod \n Get an associated setter method of the property","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsEventAddMethod","title":"FSharpMemberOrFunctionOrValue.IsEventAddMethod","content":"FSharpMemberOrFunctionOrValue.IsEventAddMethod \nIsEventAddMethod \n Indicates if this is an add method for an event","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsEventRemoveMethod","title":"FSharpMemberOrFunctionOrValue.IsEventRemoveMethod","content":"FSharpMemberOrFunctionOrValue.IsEventRemoveMethod \nIsEventRemoveMethod \n Indicates if this is a remove method for an event","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsMethod","title":"FSharpMemberOrFunctionOrValue.IsMethod","content":"FSharpMemberOrFunctionOrValue.IsMethod \nIsMethod \n Indicates if this is a method member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#XmlDocSig","title":"FSharpMemberOrFunctionOrValue.XmlDocSig","content":"FSharpMemberOrFunctionOrValue.XmlDocSig \nXmlDocSig \n XML documentation signature for the value, used for .xml file lookup for compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsMutable","title":"FSharpMemberOrFunctionOrValue.IsMutable","content":"FSharpMemberOrFunctionOrValue.IsMutable \nIsMutable \n Indicates if this is a mutable value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsUnresolved","title":"FSharpMemberOrFunctionOrValue.IsUnresolved","content":"FSharpMemberOrFunctionOrValue.IsUnresolved \nIsUnresolved \n Indicates if the member, function or value is in an unresolved assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#FullType","title":"FSharpMemberOrFunctionOrValue.FullType","content":"FSharpMemberOrFunctionOrValue.FullType \nFullType \n Get the full type of the member, function or value when used as a first class value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#EventRemoveMethod","title":"FSharpMemberOrFunctionOrValue.EventRemoveMethod","content":"FSharpMemberOrFunctionOrValue.EventRemoveMethod \nEventRemoveMethod \n Get an associated remove method of an event","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsProperty","title":"FSharpMemberOrFunctionOrValue.IsProperty","content":"FSharpMemberOrFunctionOrValue.IsProperty \nIsProperty \n Indicates if this is a property member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsDispatchSlot","title":"FSharpMemberOrFunctionOrValue.IsDispatchSlot","content":"FSharpMemberOrFunctionOrValue.IsDispatchSlot \nIsDispatchSlot \n Indicates if this is an abstract member?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsTypeFunction","title":"FSharpMemberOrFunctionOrValue.IsTypeFunction","content":"FSharpMemberOrFunctionOrValue.IsTypeFunction \nIsTypeFunction \n Indicates if this is an F# type function","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsInstanceMemberInCompiledCode","title":"FSharpMemberOrFunctionOrValue.IsInstanceMemberInCompiledCode","content":"FSharpMemberOrFunctionOrValue.IsInstanceMemberInCompiledCode \nIsInstanceMemberInCompiledCode \n Indicates if this is an instance member in compiled code.\n\n Explanatory note: some members such as IsNone and IsSome on types with UseNullAsTrueValue appear\n as instance members in F# code but are compiled as static members.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#ReturnParameter","title":"FSharpMemberOrFunctionOrValue.ReturnParameter","content":"FSharpMemberOrFunctionOrValue.ReturnParameter \nReturnParameter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsMemberThisValue","title":"FSharpMemberOrFunctionOrValue.IsMemberThisValue","content":"FSharpMemberOrFunctionOrValue.IsMemberThisValue \nIsMemberThisValue \n Indicates if this is the \u0022x\u0022 in \u0022member x.M = ...\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsRefCell","title":"FSharpMemberOrFunctionOrValue.IsRefCell","content":"FSharpMemberOrFunctionOrValue.IsRefCell \nIsRefCell \n Indicates if this is a ref cell","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#LogicalName","title":"FSharpMemberOrFunctionOrValue.LogicalName","content":"FSharpMemberOrFunctionOrValue.LogicalName \nLogicalName \n Get the logical name of the member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#HasGetterMethod","title":"FSharpMemberOrFunctionOrValue.HasGetterMethod","content":"FSharpMemberOrFunctionOrValue.HasGetterMethod \nHasGetterMethod \n Indicates if this is a property and there exists an associated getter method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsExplicitInterfaceImplementation","title":"FSharpMemberOrFunctionOrValue.IsExplicitInterfaceImplementation","content":"FSharpMemberOrFunctionOrValue.IsExplicitInterfaceImplementation \nIsExplicitInterfaceImplementation \n Indicates if this is an explicit implementation of an interface member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsEvent","title":"FSharpMemberOrFunctionOrValue.IsEvent","content":"FSharpMemberOrFunctionOrValue.IsEvent \nIsEvent \n Indicates if this is an event member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#IsExtensionMember","title":"FSharpMemberOrFunctionOrValue.IsExtensionMember","content":"FSharpMemberOrFunctionOrValue.IsExtensionMember \nIsExtensionMember \n Indicates if this is an extension member?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#ApparentEnclosingEntity","title":"FSharpMemberOrFunctionOrValue.ApparentEnclosingEntity","content":"FSharpMemberOrFunctionOrValue.ApparentEnclosingEntity \nApparentEnclosingEntity \n Get the logical enclosing entity, which for an extension member is type being extended","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#EventAddMethod","title":"FSharpMemberOrFunctionOrValue.EventAddMethod","content":"FSharpMemberOrFunctionOrValue.EventAddMethod \nEventAddMethod \n Get an associated add method of an event","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#GetterMethod","title":"FSharpMemberOrFunctionOrValue.GetterMethod","content":"FSharpMemberOrFunctionOrValue.GetterMethod \nGetterMethod \n Get an associated getter method of the property","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#EventForFSharpProperty","title":"FSharpMemberOrFunctionOrValue.EventForFSharpProperty","content":"FSharpMemberOrFunctionOrValue.EventForFSharpProperty \nEventForFSharpProperty \n Gets the event symbol implied by the use of a property,\n for the case where the property is actually an F#-declared CLIEvent.\n\n Uses of F#-declared events are considered to be properties as far as the language specification\n and this API are concerned.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#DisplayName","title":"FSharpMemberOrFunctionOrValue.DisplayName","content":"FSharpMemberOrFunctionOrValue.DisplayName \nDisplayName \n Get the name as presented in F# error messages and documentation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#DeclarationLocation","title":"FSharpMemberOrFunctionOrValue.DeclarationLocation","content":"FSharpMemberOrFunctionOrValue.DeclarationLocation \nDeclarationLocation \n Get the declaration location of the member, function or value","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html#HasSignatureFile","title":"FSharpMemberOrFunctionOrValue.HasSignatureFile","content":"FSharpMemberOrFunctionOrValue.HasSignatureFile \nHasSignatureFile \n Indicates if the value has a signature file counterpart","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html","title":"FSharpObjectExprOverride","content":"FSharpObjectExprOverride \n Represents a checked method in an object expression, as seen by the F# language. \nFSharpObjectExprOverride.GenericParameters \nGenericParameters \nFSharpObjectExprOverride.Body \nBody \nFSharpObjectExprOverride.Signature \nSignature \nFSharpObjectExprOverride.CurriedParameterGroups \nCurriedParameterGroups","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html#GenericParameters","title":"FSharpObjectExprOverride.GenericParameters","content":"FSharpObjectExprOverride.GenericParameters \nGenericParameters \n The generic parameters of the method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html#Body","title":"FSharpObjectExprOverride.Body","content":"FSharpObjectExprOverride.Body \nBody \n The expression that forms the body of the method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html#Signature","title":"FSharpObjectExprOverride.Signature","content":"FSharpObjectExprOverride.Signature \nSignature \n The signature of the implemented abstract slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html#CurriedParameterGroups","title":"FSharpObjectExprOverride.CurriedParameterGroups","content":"FSharpObjectExprOverride.CurriedParameterGroups \nCurriedParameterGroups \n The parameters of the method","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html","title":"FSharpOpenDeclaration","content":"FSharpOpenDeclaration \n Represents open declaration in F# code. \nFSharpOpenDeclaration.AppliedScope \nAppliedScope \nFSharpOpenDeclaration.Range \nRange \nFSharpOpenDeclaration.LongId \nLongId \nFSharpOpenDeclaration.Types \nTypes \nFSharpOpenDeclaration.IsOwnNamespace \nIsOwnNamespace \nFSharpOpenDeclaration.Modules \nModules \nFSharpOpenDeclaration.Target \nTarget","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#AppliedScope","title":"FSharpOpenDeclaration.AppliedScope","content":"FSharpOpenDeclaration.AppliedScope \nAppliedScope \n Scope in which open declaration is visible.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#Range","title":"FSharpOpenDeclaration.Range","content":"FSharpOpenDeclaration.Range \nRange \n Range of the open declaration.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#LongId","title":"FSharpOpenDeclaration.LongId","content":"FSharpOpenDeclaration.LongId \nLongId \n The syntactic target of the declaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#Types","title":"FSharpOpenDeclaration.Types","content":"FSharpOpenDeclaration.Types \nTypes \n Types whose static members and nested types is opened with this declaration.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#IsOwnNamespace","title":"FSharpOpenDeclaration.IsOwnNamespace","content":"FSharpOpenDeclaration.IsOwnNamespace \nIsOwnNamespace \n If it\u0027s \u0060namespace Xxx.Yyy\u0060 declaration.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#Modules","title":"FSharpOpenDeclaration.Modules","content":"FSharpOpenDeclaration.Modules \nModules \n Modules or namespaces which is opened with this declaration.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpopendeclaration.html#Target","title":"FSharpOpenDeclaration.Target","content":"FSharpOpenDeclaration.Target \nTarget \n The syntactic target of the declaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html","title":"FSharpParameter","content":"FSharpParameter \n A subtype of FSharpSymbol that represents a parameter \nFSharpParameter.IsInArg \nIsInArg \nFSharpParameter.IsOptionalArg \nIsOptionalArg \nFSharpParameter.IsOutArg \nIsOutArg \nFSharpParameter.Type \nType \nFSharpParameter.DeclarationLocation \nDeclarationLocation \nFSharpParameter.IsParamArrayArg \nIsParamArrayArg \nFSharpParameter.Name \nName","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#IsInArg","title":"FSharpParameter.IsInArg","content":"FSharpParameter.IsInArg \nIsInArg \n Indicate this is an in argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#IsOptionalArg","title":"FSharpParameter.IsOptionalArg","content":"FSharpParameter.IsOptionalArg \nIsOptionalArg \n Indicate this is an optional argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#IsOutArg","title":"FSharpParameter.IsOutArg","content":"FSharpParameter.IsOutArg \nIsOutArg \n Indicate this is an out argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#Type","title":"FSharpParameter.Type","content":"FSharpParameter.Type \nType \n The declared or inferred type of the parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#DeclarationLocation","title":"FSharpParameter.DeclarationLocation","content":"FSharpParameter.DeclarationLocation \nDeclarationLocation \n The declaration location of the parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#IsParamArrayArg","title":"FSharpParameter.IsParamArrayArg","content":"FSharpParameter.IsParamArrayArg \nIsParamArrayArg \n Indicate this is a param array argument","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpparameter.html#Name","title":"FSharpParameter.Name","content":"FSharpParameter.Name \nName \n The optional name of the parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html","title":"FSharpStaticParameter","content":"FSharpStaticParameter \n A subtype of FSharpSymbol that represents a static parameter to an F# type provider \nFSharpStaticParameter.Range \nRange \nFSharpStaticParameter.IsOptional \nIsOptional \nFSharpStaticParameter.DeclarationLocation \nDeclarationLocation \nFSharpStaticParameter.Name \nName \nFSharpStaticParameter.Kind \nKind \nFSharpStaticParameter.HasDefaultValue \nHasDefaultValue \nFSharpStaticParameter.DefaultValue \nDefaultValue","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#Range","title":"FSharpStaticParameter.Range","content":"FSharpStaticParameter.Range \nRange \n Get the range of the construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#IsOptional","title":"FSharpStaticParameter.IsOptional","content":"FSharpStaticParameter.IsOptional \nIsOptional \n Indicates if the static parameter is optional","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#DeclarationLocation","title":"FSharpStaticParameter.DeclarationLocation","content":"FSharpStaticParameter.DeclarationLocation \nDeclarationLocation \n Get the declaration location of the static parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#Name","title":"FSharpStaticParameter.Name","content":"FSharpStaticParameter.Name \nName \n Get the name of the static parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#Kind","title":"FSharpStaticParameter.Kind","content":"FSharpStaticParameter.Kind \nKind \n Get the kind of the static parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#HasDefaultValue","title":"FSharpStaticParameter.HasDefaultValue","content":"FSharpStaticParameter.HasDefaultValue \nHasDefaultValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpstaticparameter.html#DefaultValue","title":"FSharpStaticParameter.DefaultValue","content":"FSharpStaticParameter.DefaultValue \nDefaultValue \n Get the default value for the static parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html","title":"FSharpSymbol","content":"FSharpSymbol \n Represents a symbol in checked F# source code or a compiled .NET component.\n\n The subtype of the symbol may reveal further information and can be one of FSharpEntity, FSharpUnionCase\n FSharpField, FSharpGenericParameter, FSharpStaticParameter, FSharpMemberOrFunctionOrValue, FSharpParameter,\n or FSharpActivePatternCase. \nFSharpSymbol.GetEffectivelySameAsHash \nGetEffectivelySameAsHash \nFSharpSymbol.HasAttribute \nHasAttribute \nFSharpSymbol.IsAccessible \nIsAccessible \nFSharpSymbol.IsEffectivelySameAs \nIsEffectivelySameAs \nFSharpSymbol.TryGetAttribute \nTryGetAttribute \nFSharpSymbol.Accessibility \nAccessibility \nFSharpSymbol.Attributes \nAttributes \nFSharpSymbol.SignatureLocation \nSignatureLocation \nFSharpSymbol.FullName \nFullName \nFSharpSymbol.ImplementationLocation \nImplementationLocation \nFSharpSymbol.IsExplicitlySuppressed \nIsExplicitlySuppressed \nFSharpSymbol.DeclarationLocation \nDeclarationLocation \nFSharpSymbol.Assembly \nAssembly \nFSharpSymbol.DisplayName \nDisplayName \nFSharpSymbol.DisplayNameCore \nDisplayNameCore","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#GetEffectivelySameAsHash","title":"FSharpSymbol.GetEffectivelySameAsHash","content":"FSharpSymbol.GetEffectivelySameAsHash \nGetEffectivelySameAsHash \n A hash compatible with the IsEffectivelySameAs relation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#HasAttribute","title":"FSharpSymbol.HasAttribute","content":"FSharpSymbol.HasAttribute \nHasAttribute \n Indicates if this symbol has an attribute matching the full name of the given type parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#IsAccessible","title":"FSharpSymbol.IsAccessible","content":"FSharpSymbol.IsAccessible \nIsAccessible \n Computes if the symbol is accessible for the given accessibility rights","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#IsEffectivelySameAs","title":"FSharpSymbol.IsEffectivelySameAs","content":"FSharpSymbol.IsEffectivelySameAs \nIsEffectivelySameAs \n Return true if two symbols are effectively the same when referred to in F# source code text.\n This sees through signatures (a symbol in a signature will be considered effectively the same as\n the matching symbol in an implementation). In addition, other equivalences are applied\n when the same F# source text implies the same declaration name - for example, constructors\n are considered to be effectively the same symbol as the corresponding type definition.\n\n This is the relation used by GetUsesOfSymbol and GetUsesOfSymbolInFile.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#TryGetAttribute","title":"FSharpSymbol.TryGetAttribute","content":"FSharpSymbol.TryGetAttribute \nTryGetAttribute \n Try to get an attribute matching the full name of the given type parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#Accessibility","title":"FSharpSymbol.Accessibility","content":"FSharpSymbol.Accessibility \nAccessibility \n Get the declared accessibility of the symbol, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#Attributes","title":"FSharpSymbol.Attributes","content":"FSharpSymbol.Attributes \nAttributes \n Get the attributes for the symbol, if any","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#SignatureLocation","title":"FSharpSymbol.SignatureLocation","content":"FSharpSymbol.SignatureLocation \nSignatureLocation \n Get the signature location for the symbol if it was declared in an implementation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#FullName","title":"FSharpSymbol.FullName","content":"FSharpSymbol.FullName \nFullName \n Get a textual representation of the full name of the symbol. The text returned for some symbols\n may not be a valid identifier path in F# code, but rather a human-readable representation of the symbol.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#ImplementationLocation","title":"FSharpSymbol.ImplementationLocation","content":"FSharpSymbol.ImplementationLocation \nImplementationLocation \n Get the implementation location for the symbol if it was declared in a signature that has an implementation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#IsExplicitlySuppressed","title":"FSharpSymbol.IsExplicitlySuppressed","content":"FSharpSymbol.IsExplicitlySuppressed \nIsExplicitlySuppressed \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#DeclarationLocation","title":"FSharpSymbol.DeclarationLocation","content":"FSharpSymbol.DeclarationLocation \nDeclarationLocation \n Get the declaration location for the symbol","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#Assembly","title":"FSharpSymbol.Assembly","content":"FSharpSymbol.Assembly \nAssembly \n Get the assembly declaring this symbol","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#DisplayName","title":"FSharpSymbol.DisplayName","content":"FSharpSymbol.DisplayName \nDisplayName \n Gets the display name for the symbol. Double backticks are added if the name is not a valid identifier.\n\n For FSharpParameter symbols without a name for the paramater, this returns \u0022\u0060\u0060\u0060\u0060\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpsymbol.html#DisplayNameCore","title":"FSharpSymbol.DisplayNameCore","content":"FSharpSymbol.DisplayNameCore \nDisplayNameCore \n Gets the display name for the symbol where double backticks are not added for non-identifiers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html","title":"FSharpType","content":"FSharpType \n \nFSharpType.Format \nFormat \nFSharpType.FormatLayout \nFormatLayout \nFSharpType.FormatLayoutWithConstraints \nFormatLayoutWithConstraints \nFSharpType.FormatWithConstraints \nFormatWithConstraints \nFSharpType.Instantiate \nInstantiate \nFSharpType.StripAbbreviations \nStripAbbreviations \nFSharpType.BasicQualifiedName \nBasicQualifiedName \nFSharpType.BaseType \nBaseType \nFSharpType.IsGenericParameter \nIsGenericParameter \nFSharpType.IsMeasureType \nIsMeasureType \nFSharpType.AnonRecordTypeDetails \nAnonRecordTypeDetails \nFSharpType.AbbreviatedType \nAbbreviatedType \nFSharpType.IsFunctionType \nIsFunctionType \nFSharpType.AllInterfaces \nAllInterfaces \nFSharpType.TypeDefinition \nTypeDefinition \nFSharpType.IsAbbreviation \nIsAbbreviation \nFSharpType.GenericParameter \nGenericParameter \nFSharpType.IsUnresolved \nIsUnresolved \nFSharpType.GenericArguments \nGenericArguments \nFSharpType.HasTypeDefinition \nHasTypeDefinition \nFSharpType.ErasedType \nErasedType \nFSharpType.IsStructTupleType \nIsStructTupleType \nFSharpType.IsTupleType \nIsTupleType \nFSharpType.IsAnonRecordType \nIsAnonRecordType \nFSharpType.Prettify \nPrettify \nFSharpType.Prettify \nPrettify \nFSharpType.Prettify \nPrettify \nFSharpType.Prettify \nPrettify \nFSharpType.Prettify \nPrettify \nFSharpType.Prettify \nPrettify","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Format","title":"FSharpType.Format","content":"FSharpType.Format \nFormat \n Format the type using the rules of the given display context, skipping type constraints","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#FormatLayout","title":"FSharpType.FormatLayout","content":"FSharpType.FormatLayout \nFormatLayout \n Format the type using the rules of the given display context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#FormatLayoutWithConstraints","title":"FSharpType.FormatLayoutWithConstraints","content":"FSharpType.FormatLayoutWithConstraints \nFormatLayoutWithConstraints \n Format the type - with constraints - using the rules of the given display context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#FormatWithConstraints","title":"FSharpType.FormatWithConstraints","content":"FSharpType.FormatWithConstraints \nFormatWithConstraints \n Format the type using the rules of the given display context","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Instantiate","title":"FSharpType.Instantiate","content":"FSharpType.Instantiate \nInstantiate \n Instantiate generic type parameters in a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#StripAbbreviations","title":"FSharpType.StripAbbreviations","content":"FSharpType.StripAbbreviations \nStripAbbreviations \n Strip any outer abbreviations from the type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#BasicQualifiedName","title":"FSharpType.BasicQualifiedName","content":"FSharpType.BasicQualifiedName \nBasicQualifiedName \n The fully qualified name of the type or module without strong assembly name.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#BaseType","title":"FSharpType.BaseType","content":"FSharpType.BaseType \nBaseType \n Get the base type, if any, taking into account the instantiation of this type\n if it is an instantiation of a generic type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsGenericParameter","title":"FSharpType.IsGenericParameter","content":"FSharpType.IsGenericParameter \nIsGenericParameter \n Indicates if the type is a variable type, whether declared, generalized or an inference type parameter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsMeasureType","title":"FSharpType.IsMeasureType","content":"FSharpType.IsMeasureType \nIsMeasureType \n Indicates if the type is a measure type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#AnonRecordTypeDetails","title":"FSharpType.AnonRecordTypeDetails","content":"FSharpType.AnonRecordTypeDetails \nAnonRecordTypeDetails \n Get the details of the anonymous record type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#AbbreviatedType","title":"FSharpType.AbbreviatedType","content":"FSharpType.AbbreviatedType \nAbbreviatedType \n Get the type for which this is an abbreviation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsFunctionType","title":"FSharpType.IsFunctionType","content":"FSharpType.IsFunctionType \nIsFunctionType \n Indicates if the type is a function type. The GenericArguments property returns the domain and range of the function type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#AllInterfaces","title":"FSharpType.AllInterfaces","content":"FSharpType.AllInterfaces \nAllInterfaces \n Get all the interface implementations, by walking the type hierarchy, taking into account the instantiation of this type\n if it is an instantiation of a generic type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#TypeDefinition","title":"FSharpType.TypeDefinition","content":"FSharpType.TypeDefinition \nTypeDefinition \n Get the type definition for a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsAbbreviation","title":"FSharpType.IsAbbreviation","content":"FSharpType.IsAbbreviation \nIsAbbreviation \n Indicates this is an abbreviation for another type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#GenericParameter","title":"FSharpType.GenericParameter","content":"FSharpType.GenericParameter \nGenericParameter \n Get the generic parameter data for a generic parameter type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsUnresolved","title":"FSharpType.IsUnresolved","content":"FSharpType.IsUnresolved \nIsUnresolved \n Indicates this is a named type in an unresolved assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#GenericArguments","title":"FSharpType.GenericArguments","content":"FSharpType.GenericArguments \nGenericArguments \n Get the generic arguments for a tuple type, a function type or a type constructed using a named entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#HasTypeDefinition","title":"FSharpType.HasTypeDefinition","content":"FSharpType.HasTypeDefinition \nHasTypeDefinition \n Indicates if the type is constructed using a named entity, including array and byref types","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#ErasedType","title":"FSharpType.ErasedType","content":"FSharpType.ErasedType \nErasedType \n Canonical form of the type with abbreviations, measures, and F# tuples and functions erased.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsStructTupleType","title":"FSharpType.IsStructTupleType","content":"FSharpType.IsStructTupleType \nIsStructTupleType \n Indicates if the type is a struct tuple type. The GenericArguments property returns the elements of the tuple type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsTupleType","title":"FSharpType.IsTupleType","content":"FSharpType.IsTupleType \nIsTupleType \n Indicates if the type is a tuple type (reference or struct). The GenericArguments property returns the elements of the tuple type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#IsAnonRecordType","title":"FSharpType.IsAnonRecordType","content":"FSharpType.IsAnonRecordType \nIsAnonRecordType \n Indicates if the type is an anonymous record type. The GenericArguments property returns the type instantiation of the anonymous record type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Prettify","title":"FSharpType.Prettify","content":"FSharpType.Prettify \nPrettify \n Adjust the types in a group of curried parameters and return type by removing any occurrences of type inference variables, replacing them\n systematically with lower-case type inference variables such as \u003Cc\u003E\u0027a\u003C/c\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Prettify","title":"FSharpType.Prettify","content":"FSharpType.Prettify \nPrettify \n Adjust the types in a group of curried parameters by removing any occurrences of type inference variables, replacing them\n systematically with lower-case type inference variables such as \u003Cc\u003E\u0027a\u003C/c\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Prettify","title":"FSharpType.Prettify","content":"FSharpType.Prettify \nPrettify \n Adjust the types in a group of parameters by removing any occurrences of type inference variables, replacing them\n systematically with lower-case type inference variables such as \u003Cc\u003E\u0027a\u003C/c\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Prettify","title":"FSharpType.Prettify","content":"FSharpType.Prettify \nPrettify \n Adjust the type in a single parameter by removing any occurrences of type inference variables, replacing them\n systematically with lower-case type inference variables such as \u003Cc\u003E\u0027a\u003C/c\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Prettify","title":"FSharpType.Prettify","content":"FSharpType.Prettify \nPrettify \n Adjust a group of types by removing any occurrences of type inference variables, replacing them\n systematically with lower-case type inference variables such as \u003Cc\u003E\u0027a\u003C/c\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharptype.html#Prettify","title":"FSharpType.Prettify","content":"FSharpType.Prettify \nPrettify \n Adjust the type by removing any occurrences of type inference variables, replacing them\n systematically with lower-case type inference variables such as \u003Cc\u003E\u0027a\u003C/c\u003E.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html","title":"FSharpUnionCase","content":"FSharpUnionCase \n A subtype of FSharpSymbol that represents a union case as seen by the F# language \nFSharpUnionCase.Fields \nFields \nFSharpUnionCase.HasFields \nHasFields \nFSharpUnionCase.ReturnType \nReturnType \nFSharpUnionCase.IsUnresolved \nIsUnresolved \nFSharpUnionCase.DeclaringEntity \nDeclaringEntity \nFSharpUnionCase.DeclarationLocation \nDeclarationLocation \nFSharpUnionCase.XmlDocSig \nXmlDocSig \nFSharpUnionCase.Name \nName \nFSharpUnionCase.CompiledName \nCompiledName \nFSharpUnionCase.XmlDoc \nXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#Fields","title":"FSharpUnionCase.Fields","content":"FSharpUnionCase.Fields \nFields \n Get the data carried by the case.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#HasFields","title":"FSharpUnionCase.HasFields","content":"FSharpUnionCase.HasFields \nHasFields \n Indicates if the union case has field definitions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#ReturnType","title":"FSharpUnionCase.ReturnType","content":"FSharpUnionCase.ReturnType \nReturnType \n Get the type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#IsUnresolved","title":"FSharpUnionCase.IsUnresolved","content":"FSharpUnionCase.IsUnresolved \nIsUnresolved \n Indicates if the union case is for a type in an unresolved assembly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#DeclaringEntity","title":"FSharpUnionCase.DeclaringEntity","content":"FSharpUnionCase.DeclaringEntity \nDeclaringEntity \n Get the declaring entity of the case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#DeclarationLocation","title":"FSharpUnionCase.DeclarationLocation","content":"FSharpUnionCase.DeclarationLocation \nDeclarationLocation \n Get the range of the name of the case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#XmlDocSig","title":"FSharpUnionCase.XmlDocSig","content":"FSharpUnionCase.XmlDocSig \nXmlDocSig \n Get the XML documentation signature for .xml file lookup for the union case, used for .xml file lookup for compiled code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#Name","title":"FSharpUnionCase.Name","content":"FSharpUnionCase.Name \nName \n Get the name of the union case","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#CompiledName","title":"FSharpUnionCase.CompiledName","content":"FSharpUnionCase.CompiledName \nCompiledName \n Get the name of the case in generated IL code","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpunioncase.html#XmlDoc","title":"FSharpUnionCase.XmlDoc","content":"FSharpUnionCase.XmlDoc \nXmlDoc \n Get the XML documentation for the entity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpxmldoc.html","title":"FSharpXmlDoc","content":"FSharpXmlDoc \n Describe a comment as either a block of text or a file\u002Bsignature reference into an intellidoc file. \nFSharpXmlDoc.None \nNone \nFSharpXmlDoc.FromXmlText \nFromXmlText \nFSharpXmlDoc.FromXmlFile \nFromXmlFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpxmldoc.html#None","title":"FSharpXmlDoc.None","content":"FSharpXmlDoc.None \nNone \n No documentation is available","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpxmldoc.html#FromXmlText","title":"FSharpXmlDoc.FromXmlText","content":"FSharpXmlDoc.FromXmlText \nFromXmlText \n The text for documentation for in-memory references.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-symbols-fsharpxmldoc.html#FromXmlFile","title":"FSharpXmlDoc.FromXmlFile","content":"FSharpXmlDoc.FromXmlFile \nFromXmlFile \n Indicates that the XML for the documentation can be found in a .xml documentation file for the given DLL, using the given signature key","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html","title":"PrettyNaming","content":"PrettyNaming \n Some general F# utilities for mangling / unmangling / manipulating names.\n Anything to do with special names of identifiers and other lexical rules \nPrettyNaming.IsOperatorDisplayName \nIsOperatorDisplayName \nPrettyNaming.IsIdentifierName \nIsIdentifierName \nPrettyNaming.IsActivePatternName \nIsActivePatternName \nPrettyNaming.NormalizeIdentifierBackticks \nNormalizeIdentifierBackticks \nPrettyNaming.IsLogicalOpName \nIsLogicalOpName \nPrettyNaming.CompileOpName \nCompileOpName \nPrettyNaming.ConvertValLogicalNameToDisplayNameCore \nConvertValLogicalNameToDisplayNameCore \nPrettyNaming.IsIdentifierFirstCharacter \nIsIdentifierFirstCharacter \nPrettyNaming.IsIdentifierPartCharacter \nIsIdentifierPartCharacter \nPrettyNaming.IsLongIdentifierPartCharacter \nIsLongIdentifierPartCharacter \nPrettyNaming.IsLogicalPrefixOperator \nIsLogicalPrefixOperator \nPrettyNaming.IsLogicalInfixOpName \nIsLogicalInfixOpName \nPrettyNaming.IsLogicalTernaryOperator \nIsLogicalTernaryOperator \nPrettyNaming.IsPunctuation \nIsPunctuation \nPrettyNaming.IsCompilerGeneratedName \nIsCompilerGeneratedName \nPrettyNaming.TryChopPropertyName \nTryChopPropertyName \nPrettyNaming.FsiDynamicModulePrefix \nFsiDynamicModulePrefix \nPrettyNaming.GetLongNameFromString \nGetLongNameFromString \nPrettyNaming.FormatAndOtherOverloadsString \nFormatAndOtherOverloadsString \nPrettyNaming.FSharpSignatureDataResourceName2 \nFSharpSignatureDataResourceName2","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsOperatorDisplayName","title":"PrettyNaming.IsOperatorDisplayName","content":"PrettyNaming.IsOperatorDisplayName \nIsOperatorDisplayName \n\u003Cpre\u003E Returns \u0060true\u0060 if given string is an operator display name, e.g.\n ( |\u003E\u003E )\n |\u003E\u003E\n ..\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsIdentifierName","title":"PrettyNaming.IsIdentifierName","content":"PrettyNaming.IsIdentifierName \nIsIdentifierName \n\u003Cpre\u003E Is the name a valid F# identifier, primarily used internally in PrettyNaming.fs for determining if an\n identifier needs backticks.\n\n In general do not use this routine. It is only used in one quick fix, for determining if it is valid\n to add \u0022_\u0022 in front of an identifier.\n\n A --\u003E true\n A\u0027 --\u003E true\n _A --\u003E true\n A0 --\u003E true\n |A|B| --\u003E false\n op_Addition --\u003E true\n \u002B --\u003E false\n let --\u003E false\n base --\u003E false\n\n TBD: needs unit testing\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsActivePatternName","title":"PrettyNaming.IsActivePatternName","content":"PrettyNaming.IsActivePatternName \nIsActivePatternName \n\u003Cpre\u003E Determines if the specified name is a valid name for an active pattern.\n |A|_| --\u003E true\n |A|B| --\u003E true\n |A| --\u003E true\n | --\u003E false\n || --\u003E false\n op_Addition --\u003E false\n\n TBD: needs unit testing\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#NormalizeIdentifierBackticks","title":"PrettyNaming.NormalizeIdentifierBackticks","content":"PrettyNaming.NormalizeIdentifierBackticks \nNormalizeIdentifierBackticks \n\u003Cpre\u003E Adds double backticks if necessary to make a valid identifier, e.g.\n op_Addition --\u003E op_Addition\n \u002B --\u003E \u0060\u0060\u002B\u0060\u0060 (this is not op_Addition)\n |\u003E\u003E --\u003E \u0060\u0060|\u003E\u003E\u0060\u0060 (this is not an op_)\n A-B --\u003E \u0060\u0060A-B\u0060\u0060\n AB --\u003E AB\n |A|_| --\u003E |A|_| this is an active pattern name, needs parens not backticks\n Removes double backticks if not necessary to make a valid identifier, e.g.\n \u0060\u0060A\u0060\u0060 --\u003E A\n \u0060\u0060A-B\u0060\u0060 --\u003E \u0060\u0060A-B\u0060\u0060\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsLogicalOpName","title":"PrettyNaming.IsLogicalOpName","content":"PrettyNaming.IsLogicalOpName \nIsLogicalOpName \n\u003Cpre\u003E Is the name a logical operator name, including unary, binary and ternary operators\n op_UnaryPlus - yes\n op_Addition - yes\n op_Range - yes (?)\n op_RangeStep - yes (?)\n op_DynamicAssignment - yes\n op_Quack - no\n \u002B - no\n ABC - no\n ABC DEF - no\n base - no\n |A|_| - no\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#CompileOpName","title":"PrettyNaming.CompileOpName","content":"PrettyNaming.CompileOpName \nCompileOpName \n\u003Cpre\u003E Converts the core of an operator name into a logical name. For example,\n \u002B --\u003E op_Addition\n !% --\u003E op_DereferencePercent\n Only used on actual operator names\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#ConvertValLogicalNameToDisplayNameCore","title":"PrettyNaming.ConvertValLogicalNameToDisplayNameCore","content":"PrettyNaming.ConvertValLogicalNameToDisplayNameCore \nConvertValLogicalNameToDisplayNameCore \n\u003Cpre\u003E Converts the logical name for and operator back into the core of a display name. For example:\n Foo --\u003E Foo\n \u002B --\u003E \u002B\n op_Addition --\u003E \u002B\n op_DereferencePercent --\u003E !%\n A-B --\u003E A-B\n |A|_| --\u003E |A|_|\n base --\u003E base regardless of IsBaseVal\n Used on names of all kinds\n\n TODO: We should assess uses of this function.\n\n In any cases it is used it probably indicates that text is being\n generated which:\n 1. does not contain double-backticks for non-identifiers\n 2. does not put parentheses arounf operators or active pattern names\n\n If the text is immediately in quotes, this is generally ok, e.g.\n\n error FS0038: \u0027\u002B\u0027 is bound twice in this pattern\n error FS0038: \u0027|A|_|\u0027 is bound twice in this pattern\n error FS0038: \u0027a a\u0027 is bound twice in this pattern\n\n If not, the it is likely this should be replaced by ConvertValLogicalNameToDisplayName.\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsIdentifierFirstCharacter","title":"PrettyNaming.IsIdentifierFirstCharacter","content":"PrettyNaming.IsIdentifierFirstCharacter \nIsIdentifierFirstCharacter \n The characters that are allowed to be the first character of an identifier.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsIdentifierPartCharacter","title":"PrettyNaming.IsIdentifierPartCharacter","content":"PrettyNaming.IsIdentifierPartCharacter \nIsIdentifierPartCharacter \n The characters that are allowed to be in an identifier.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsLongIdentifierPartCharacter","title":"PrettyNaming.IsLongIdentifierPartCharacter","content":"PrettyNaming.IsLongIdentifierPartCharacter \nIsLongIdentifierPartCharacter \n Is this character a part of a long identifier?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsLogicalPrefixOperator","title":"PrettyNaming.IsLogicalPrefixOperator","content":"PrettyNaming.IsLogicalPrefixOperator \nIsLogicalPrefixOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsLogicalInfixOpName","title":"PrettyNaming.IsLogicalInfixOpName","content":"PrettyNaming.IsLogicalInfixOpName \nIsLogicalInfixOpName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsLogicalTernaryOperator","title":"PrettyNaming.IsLogicalTernaryOperator","content":"PrettyNaming.IsLogicalTernaryOperator \nIsLogicalTernaryOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsPunctuation","title":"PrettyNaming.IsPunctuation","content":"PrettyNaming.IsPunctuation \nIsPunctuation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#IsCompilerGeneratedName","title":"PrettyNaming.IsCompilerGeneratedName","content":"PrettyNaming.IsCompilerGeneratedName \nIsCompilerGeneratedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#TryChopPropertyName","title":"PrettyNaming.TryChopPropertyName","content":"PrettyNaming.TryChopPropertyName \nTryChopPropertyName \n Try to chop \u0022get_\u0022 or \u0022set_\u0022 from a string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#FsiDynamicModulePrefix","title":"PrettyNaming.FsiDynamicModulePrefix","content":"PrettyNaming.FsiDynamicModulePrefix \nFsiDynamicModulePrefix \n The prefix of the names used for the fake namespace path added to all dynamic code entries in FSI.EXE","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#GetLongNameFromString","title":"PrettyNaming.GetLongNameFromString","content":"PrettyNaming.GetLongNameFromString \nGetLongNameFromString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#FormatAndOtherOverloadsString","title":"PrettyNaming.FormatAndOtherOverloadsString","content":"PrettyNaming.FormatAndOtherOverloadsString \nFormatAndOtherOverloadsString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-prettynaming.html#FSharpSignatureDataResourceName2","title":"PrettyNaming.FSharpSignatureDataResourceName2","content":"PrettyNaming.FSharpSignatureDataResourceName2 \nFSharpSignatureDataResourceName2 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongidenthelpers.html","title":"SynLongIdentHelpers","content":"SynLongIdentHelpers \n \nSynLongIdentHelpers.LongIdentWithDots \nLongIdentWithDots \nSynLongIdentHelpers.(|LongIdentWithDots|) \n(|LongIdentWithDots|)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongidenthelpers.html#LongIdentWithDots","title":"SynLongIdentHelpers.LongIdentWithDots","content":"SynLongIdentHelpers.LongIdentWithDots \nLongIdentWithDots \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongidenthelpers.html#(|LongIdentWithDots|)","title":"SynLongIdentHelpers.(|LongIdentWithDots|)","content":"SynLongIdentHelpers.(|LongIdentWithDots|) \n(|LongIdentWithDots|) \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxtraversal.html","title":"SyntaxTraversal","content":"SyntaxTraversal \n \nSyntaxTraversal.Traverse \nTraverse","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxtraversal.html#Traverse","title":"SyntaxTraversal.Traverse","content":"SyntaxTraversal.Traverse \nTraverse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html","title":"DebugPointAtBinding","content":"DebugPointAtBinding \n Represents whether a debug point should be present for a \u0027let\u0027 binding,\n that is whether the construct corresponds to a debug point in the original source. \nDebugPointAtBinding.Combine \nCombine \nDebugPointAtBinding.Yes \nYes \nDebugPointAtBinding.NoneAtDo \nNoneAtDo \nDebugPointAtBinding.NoneAtLet \nNoneAtLet \nDebugPointAtBinding.NoneAtSticky \nNoneAtSticky \nDebugPointAtBinding.NoneAtInvisible \nNoneAtInvisible","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html#Combine","title":"DebugPointAtBinding.Combine","content":"DebugPointAtBinding.Combine \nCombine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html#Yes","title":"DebugPointAtBinding.Yes","content":"DebugPointAtBinding.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html#NoneAtDo","title":"DebugPointAtBinding.NoneAtDo","content":"DebugPointAtBinding.NoneAtDo \nNoneAtDo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html#NoneAtLet","title":"DebugPointAtBinding.NoneAtLet","content":"DebugPointAtBinding.NoneAtLet \nNoneAtLet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html#NoneAtSticky","title":"DebugPointAtBinding.NoneAtSticky","content":"DebugPointAtBinding.NoneAtSticky \nNoneAtSticky \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatbinding.html#NoneAtInvisible","title":"DebugPointAtBinding.NoneAtInvisible","content":"DebugPointAtBinding.NoneAtInvisible \nNoneAtInvisible \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatfinally.html","title":"DebugPointAtFinally","content":"DebugPointAtFinally \n Represents whether a debug point should be present for the \u0027finally\u0027 in a \u0027try .. finally\u0027,\n that is whether the construct corresponds to a debug point in the original source. \nDebugPointAtFinally.Yes \nYes \nDebugPointAtFinally.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatfinally.html#Yes","title":"DebugPointAtFinally.Yes","content":"DebugPointAtFinally.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatfinally.html#No","title":"DebugPointAtFinally.No","content":"DebugPointAtFinally.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatfor.html","title":"DebugPointAtFor","content":"DebugPointAtFor \n Represents whether a debug point should be present for the \u0027for\u0027 in a \u0027for...\u0027 loop,\n that is whether the construct corresponds to a debug point in the original source. \nDebugPointAtFor.Yes \nYes \nDebugPointAtFor.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatfor.html#Yes","title":"DebugPointAtFor.Yes","content":"DebugPointAtFor.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatfor.html#No","title":"DebugPointAtFor.No","content":"DebugPointAtFor.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatinorto.html","title":"DebugPointAtInOrTo","content":"DebugPointAtInOrTo \n Represents whether a debug point should be present for the \u0027in\u0027 or \u0027to\u0027 of a \u0027for...\u0027 loop,\n that is whether the construct corresponds to a debug point in the original source. \nDebugPointAtInOrTo.Yes \nYes \nDebugPointAtInOrTo.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatinorto.html#Yes","title":"DebugPointAtInOrTo.Yes","content":"DebugPointAtInOrTo.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatinorto.html#No","title":"DebugPointAtInOrTo.No","content":"DebugPointAtInOrTo.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatleafexpr.html","title":"DebugPointAtLeafExpr","content":"DebugPointAtLeafExpr \n Represents a debug point at a leaf expression (e.g. an application or constant). \nDebugPointAtLeafExpr.Yes \nYes","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatleafexpr.html#Yes","title":"DebugPointAtLeafExpr.Yes","content":"DebugPointAtLeafExpr.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatsequential.html","title":"DebugPointAtSequential","content":"DebugPointAtSequential \n Represents whether a debug point should be suppressed for either the\n first or second part of a sequential execution, that is whether the\n construct corresponds to a debug point in the original source. \nDebugPointAtSequential.SuppressNeither \nSuppressNeither \nDebugPointAtSequential.SuppressStmt \nSuppressStmt \nDebugPointAtSequential.SuppressBoth \nSuppressBoth \nDebugPointAtSequential.SuppressExpr \nSuppressExpr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatsequential.html#SuppressNeither","title":"DebugPointAtSequential.SuppressNeither","content":"DebugPointAtSequential.SuppressNeither \nSuppressNeither \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatsequential.html#SuppressStmt","title":"DebugPointAtSequential.SuppressStmt","content":"DebugPointAtSequential.SuppressStmt \nSuppressStmt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatsequential.html#SuppressBoth","title":"DebugPointAtSequential.SuppressBoth","content":"DebugPointAtSequential.SuppressBoth \nSuppressBoth \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatsequential.html#SuppressExpr","title":"DebugPointAtSequential.SuppressExpr","content":"DebugPointAtSequential.SuppressExpr \nSuppressExpr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointattarget.html","title":"DebugPointAtTarget","content":"DebugPointAtTarget \n Represents whether a debug point should be present for the target\n of a decision tree, that is whether the construct corresponds to a debug\n point in the original source. \nDebugPointAtTarget.Yes \nYes \nDebugPointAtTarget.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointattarget.html#Yes","title":"DebugPointAtTarget.Yes","content":"DebugPointAtTarget.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointattarget.html#No","title":"DebugPointAtTarget.No","content":"DebugPointAtTarget.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointattry.html","title":"DebugPointAtTry","content":"DebugPointAtTry \n Represents whether a debug point should be present for a \u0027try\u0027, that is whether\n the construct corresponds to a debug point in the original source. \nDebugPointAtTry.Yes \nYes \nDebugPointAtTry.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointattry.html#Yes","title":"DebugPointAtTry.Yes","content":"DebugPointAtTry.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointattry.html#No","title":"DebugPointAtTry.No","content":"DebugPointAtTry.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatwhile.html","title":"DebugPointAtWhile","content":"DebugPointAtWhile \n Represents whether a debug point should be present for the \u0027while\u0027 in a \u0027while...\u0027 loop,\n that is whether the construct corresponds to a debug point in the original source. \nDebugPointAtWhile.Yes \nYes \nDebugPointAtWhile.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatwhile.html#Yes","title":"DebugPointAtWhile.Yes","content":"DebugPointAtWhile.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatwhile.html#No","title":"DebugPointAtWhile.No","content":"DebugPointAtWhile.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatwith.html","title":"DebugPointAtWith","content":"DebugPointAtWith \n Represents whether a debug point should be present for the \u0027with\u0027 in a \u0027try .. with\u0027,\n that is whether the construct corresponds to a debug point in the original source. \nDebugPointAtWith.Yes \nYes \nDebugPointAtWith.No \nNo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatwith.html#Yes","title":"DebugPointAtWith.Yes","content":"DebugPointAtWith.Yes \nYes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-debugpointatwith.html#No","title":"DebugPointAtWith.No","content":"DebugPointAtWith.No \nNo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-expratomicflag.html","title":"ExprAtomicFlag","content":"ExprAtomicFlag \n Indicates if an expression is an atomic expression.\n\n An atomic expression has no whitespace unless enclosed in parentheses, e.g.\n 1, \u00223\u0022, ident, ident.[expr] and (expr). If an atomic expression has type T,\n then the largest expression ending at the same range as the atomic expression\n also has type T. \nExprAtomicFlag.Atomic \nAtomic \nExprAtomicFlag.NonAtomic \nNonAtomic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-expratomicflag.html#Atomic","title":"ExprAtomicFlag.Atomic","content":"ExprAtomicFlag.Atomic \nAtomic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-expratomicflag.html#NonAtomic","title":"ExprAtomicFlag.NonAtomic","content":"ExprAtomicFlag.NonAtomic \nNonAtomic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-ident.html","title":"Ident","content":"Ident \n Represents an identifier in F# code \nIdent.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nIdent.idRange \nidRange \nIdent.idText \nidText","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-ident.html#\u0060\u0060.ctor\u0060\u0060","title":"Ident.\u0060\u0060.ctor\u0060\u0060","content":"Ident.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-ident.html#idRange","title":"Ident.idRange","content":"Ident.idRange \nidRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-ident.html#idText","title":"Ident.idText","content":"Ident.idText \nidText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedhashdirective.html","title":"ParsedHashDirective","content":"ParsedHashDirective \n Represents a parsed hash directive \nParsedHashDirective.ParsedHashDirective \nParsedHashDirective","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedhashdirective.html#ParsedHashDirective","title":"ParsedHashDirective.ParsedHashDirective","content":"ParsedHashDirective.ParsedHashDirective \nParsedHashDirective \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html","title":"ParsedHashDirectiveArgument","content":"ParsedHashDirectiveArgument \n Represents a parsed hash directive argument \nParsedHashDirectiveArgument.Range \nRange \nParsedHashDirectiveArgument.String \nString \nParsedHashDirectiveArgument.SourceIdentifier \nSourceIdentifier","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html#Range","title":"ParsedHashDirectiveArgument.Range","content":"ParsedHashDirectiveArgument.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html#String","title":"ParsedHashDirectiveArgument.String","content":"ParsedHashDirectiveArgument.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html#SourceIdentifier","title":"ParsedHashDirectiveArgument.SourceIdentifier","content":"ParsedHashDirectiveArgument.SourceIdentifier \nSourceIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfile.html","title":"ParsedImplFile","content":"ParsedImplFile \n Represents a parsed implementation file made up of fragments \nParsedImplFile.ParsedImplFile \nParsedImplFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfile.html#ParsedImplFile","title":"ParsedImplFile.ParsedImplFile","content":"ParsedImplFile.ParsedImplFile \nParsedImplFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfilefragment.html","title":"ParsedImplFileFragment","content":"ParsedImplFileFragment \n Represents the syntax tree for the contents of a parsed implementation file \nParsedImplFileFragment.AnonModule \nAnonModule \nParsedImplFileFragment.NamedModule \nNamedModule \nParsedImplFileFragment.NamespaceFragment \nNamespaceFragment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfilefragment.html#AnonModule","title":"ParsedImplFileFragment.AnonModule","content":"ParsedImplFileFragment.AnonModule \nAnonModule \n An implementation file which is an anonymous module definition, e.g. a script","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfilefragment.html#NamedModule","title":"ParsedImplFileFragment.NamedModule","content":"ParsedImplFileFragment.NamedModule \nNamedModule \n An implementation file is a named module definition, \u0027module N\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfilefragment.html#NamespaceFragment","title":"ParsedImplFileFragment.NamespaceFragment","content":"ParsedImplFileFragment.NamespaceFragment \nNamespaceFragment \n An implementation file fragment which declares a namespace fragment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html","title":"ParsedImplFileInput","content":"ParsedImplFileInput \n Represents the full syntax tree, file name and other parsing information for an implementation file \nParsedImplFileInput.FileName \nFileName \nParsedImplFileInput.IsScript \nIsScript \nParsedImplFileInput.QualifiedName \nQualifiedName \nParsedImplFileInput.IsExe \nIsExe \nParsedImplFileInput.ScopedPragmas \nScopedPragmas \nParsedImplFileInput.Trivia \nTrivia \nParsedImplFileInput.IsLastCompiland \nIsLastCompiland \nParsedImplFileInput.Contents \nContents \nParsedImplFileInput.HashDirectives \nHashDirectives \nParsedImplFileInput.ParsedImplFileInput \nParsedImplFileInput","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#FileName","title":"ParsedImplFileInput.FileName","content":"ParsedImplFileInput.FileName \nFileName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#IsScript","title":"ParsedImplFileInput.IsScript","content":"ParsedImplFileInput.IsScript \nIsScript \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#QualifiedName","title":"ParsedImplFileInput.QualifiedName","content":"ParsedImplFileInput.QualifiedName \nQualifiedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#IsExe","title":"ParsedImplFileInput.IsExe","content":"ParsedImplFileInput.IsExe \nIsExe \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#ScopedPragmas","title":"ParsedImplFileInput.ScopedPragmas","content":"ParsedImplFileInput.ScopedPragmas \nScopedPragmas \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#Trivia","title":"ParsedImplFileInput.Trivia","content":"ParsedImplFileInput.Trivia \nTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#IsLastCompiland","title":"ParsedImplFileInput.IsLastCompiland","content":"ParsedImplFileInput.IsLastCompiland \nIsLastCompiland \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#Contents","title":"ParsedImplFileInput.Contents","content":"ParsedImplFileInput.Contents \nContents \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#HashDirectives","title":"ParsedImplFileInput.HashDirectives","content":"ParsedImplFileInput.HashDirectives \nHashDirectives \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedimplfileinput.html#ParsedImplFileInput","title":"ParsedImplFileInput.ParsedImplFileInput","content":"ParsedImplFileInput.ParsedImplFileInput \nParsedImplFileInput \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html","title":"ParsedInput","content":"ParsedInput \n Represents the syntax tree for a parsed implementation or signature file \nParsedInput.FileName \nFileName \nParsedInput.Range \nRange \nParsedInput.QualifiedName \nQualifiedName \nParsedInput.ScopedPragmas \nScopedPragmas \nParsedInput.Identifiers \nIdentifiers \nParsedInput.ImplFile \nImplFile \nParsedInput.SigFile \nSigFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#FileName","title":"ParsedInput.FileName","content":"ParsedInput.FileName \nFileName \n Gets the file name for the parsed input","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#Range","title":"ParsedInput.Range","content":"ParsedInput.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#QualifiedName","title":"ParsedInput.QualifiedName","content":"ParsedInput.QualifiedName \nQualifiedName \n Gets the qualified name used to help match signature and implementation files","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#ScopedPragmas","title":"ParsedInput.ScopedPragmas","content":"ParsedInput.ScopedPragmas \nScopedPragmas \n Gets the #nowarn and other scoped pragmas","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#Identifiers","title":"ParsedInput.Identifiers","content":"ParsedInput.Identifiers \nIdentifiers \n Gets a set of all identifiers used in this parsed input. Only populated if captureIdentifiersWhenParsing option was used.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#ImplFile","title":"ParsedInput.ImplFile","content":"ParsedInput.ImplFile \nImplFile \n A parsed implementation file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedinput.html#SigFile","title":"ParsedInput.SigFile","content":"ParsedInput.SigFile \nSigFile \n A parsed signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedscriptinteraction.html","title":"ParsedScriptInteraction","content":"ParsedScriptInteraction \n Represents a parsed syntax tree for an F# Interactive interaction \nParsedScriptInteraction.Definitions \nDefinitions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedscriptinteraction.html#Definitions","title":"ParsedScriptInteraction.Definitions","content":"ParsedScriptInteraction.Definitions \nDefinitions \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfile.html","title":"ParsedSigFile","content":"ParsedSigFile \n Represents a parsed signature file made up of fragments \nParsedSigFile.ParsedSigFile \nParsedSigFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfile.html#ParsedSigFile","title":"ParsedSigFile.ParsedSigFile","content":"ParsedSigFile.ParsedSigFile \nParsedSigFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfilefragment.html","title":"ParsedSigFileFragment","content":"ParsedSigFileFragment \n Represents the syntax tree for the contents of a parsed signature file \nParsedSigFileFragment.AnonModule \nAnonModule \nParsedSigFileFragment.NamedModule \nNamedModule \nParsedSigFileFragment.NamespaceFragment \nNamespaceFragment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfilefragment.html#AnonModule","title":"ParsedSigFileFragment.AnonModule","content":"ParsedSigFileFragment.AnonModule \nAnonModule \n A signature file which is an anonymous module, e.g. the signature file for the final file in an application","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfilefragment.html#NamedModule","title":"ParsedSigFileFragment.NamedModule","content":"ParsedSigFileFragment.NamedModule \nNamedModule \n A signature file which is a module, \u0027module N\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfilefragment.html#NamespaceFragment","title":"ParsedSigFileFragment.NamespaceFragment","content":"ParsedSigFileFragment.NamespaceFragment \nNamespaceFragment \n A signature file namespace fragment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html","title":"ParsedSigFileInput","content":"ParsedSigFileInput \n Represents the full syntax tree, file name and other parsing information for a signature file \nParsedSigFileInput.FileName \nFileName \nParsedSigFileInput.QualifiedName \nQualifiedName \nParsedSigFileInput.ScopedPragmas \nScopedPragmas \nParsedSigFileInput.Trivia \nTrivia \nParsedSigFileInput.Contents \nContents \nParsedSigFileInput.HashDirectives \nHashDirectives \nParsedSigFileInput.ParsedSigFileInput \nParsedSigFileInput","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#FileName","title":"ParsedSigFileInput.FileName","content":"ParsedSigFileInput.FileName \nFileName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#QualifiedName","title":"ParsedSigFileInput.QualifiedName","content":"ParsedSigFileInput.QualifiedName \nQualifiedName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#ScopedPragmas","title":"ParsedSigFileInput.ScopedPragmas","content":"ParsedSigFileInput.ScopedPragmas \nScopedPragmas \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#Trivia","title":"ParsedSigFileInput.Trivia","content":"ParsedSigFileInput.Trivia \nTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#Contents","title":"ParsedSigFileInput.Contents","content":"ParsedSigFileInput.Contents \nContents \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#HashDirectives","title":"ParsedSigFileInput.HashDirectives","content":"ParsedSigFileInput.HashDirectives \nHashDirectives \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parsedsigfileinput.html#ParsedSigFileInput","title":"ParsedSigFileInput.ParsedSigFileInput","content":"ParsedSigFileInput.ParsedSigFileInput \nParsedSigFileInput \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parserdetail.html","title":"ParserDetail","content":"ParserDetail \n Indicates if the construct arises from error recovery \nParserDetail.Ok \nOk \nParserDetail.ErrorRecovery \nErrorRecovery","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parserdetail.html#Ok","title":"ParserDetail.Ok","content":"ParserDetail.Ok \nOk \n The construct arises normally","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-parserdetail.html#ErrorRecovery","title":"ParserDetail.ErrorRecovery","content":"ParserDetail.ErrorRecovery \nErrorRecovery \n The construct arises from error recovery","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-qualifiednameoffile.html","title":"QualifiedNameOfFile","content":"QualifiedNameOfFile \n Represents a qualifying name for anonymous module specifications and implementations, \nQualifiedNameOfFile.Range \nRange \nQualifiedNameOfFile.Text \nText \nQualifiedNameOfFile.Id \nId \nQualifiedNameOfFile.QualifiedNameOfFile \nQualifiedNameOfFile","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-qualifiednameoffile.html#Range","title":"QualifiedNameOfFile.Range","content":"QualifiedNameOfFile.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-qualifiednameoffile.html#Text","title":"QualifiedNameOfFile.Text","content":"QualifiedNameOfFile.Text \nText \n The name of the file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-qualifiednameoffile.html#Id","title":"QualifiedNameOfFile.Id","content":"QualifiedNameOfFile.Id \nId \n The identifier for the name of the file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-qualifiednameoffile.html#QualifiedNameOfFile","title":"QualifiedNameOfFile.QualifiedNameOfFile","content":"QualifiedNameOfFile.QualifiedNameOfFile \nQualifiedNameOfFile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-scopedpragma.html","title":"ScopedPragma","content":"ScopedPragma \n Represents a scoped pragma \nScopedPragma.WarningOff \nWarningOff","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-scopedpragma.html#WarningOff","title":"ScopedPragma.WarningOff","content":"ScopedPragma.WarningOff \nWarningOff \n A pragma to turn a warning off","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-seqexpronly.html","title":"SeqExprOnly","content":"SeqExprOnly \n Indicates if a for loop is \u0027for x in e1 -\u003E e2\u0027, only valid in sequence expressions \nSeqExprOnly.SeqExprOnly \nSeqExprOnly","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-seqexpronly.html#SeqExprOnly","title":"SeqExprOnly.SeqExprOnly","content":"SeqExprOnly.SeqExprOnly \nSeqExprOnly \n Indicates if a for loop is \u0027for x in e1 -\u003E e2\u0027, only valid in sequence expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synaccess.html","title":"SynAccess","content":"SynAccess \n Represents an accessibility modifier in F# syntax \nSynAccess.Range \nRange \nSynAccess.Public \nPublic \nSynAccess.Internal \nInternal \nSynAccess.Private \nPrivate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synaccess.html#Range","title":"SynAccess.Range","content":"SynAccess.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synaccess.html#Public","title":"SynAccess.Public","content":"SynAccess.Public \nPublic \n A construct marked or assumed \u0027public\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synaccess.html#Internal","title":"SynAccess.Internal","content":"SynAccess.Internal \nInternal \n A construct marked or assumed \u0027internal\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synaccess.html#Private","title":"SynAccess.Private","content":"SynAccess.Private \nPrivate \n A construct marked or assumed \u0027private\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synarginfo.html","title":"SynArgInfo","content":"SynArgInfo \n Represents the argument names and other metadata for a parameter for a member or function \nSynArgInfo.Attributes \nAttributes \nSynArgInfo.Ident \nIdent \nSynArgInfo.SynArgInfo \nSynArgInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synarginfo.html#Attributes","title":"SynArgInfo.Attributes","content":"SynArgInfo.Attributes \nAttributes \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synarginfo.html#Ident","title":"SynArgInfo.Ident","content":"SynArgInfo.Ident \nIdent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synarginfo.html#SynArgInfo","title":"SynArgInfo.SynArgInfo","content":"SynArgInfo.SynArgInfo \nSynArgInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synargpats.html","title":"SynArgPats","content":"SynArgPats \n Represents a syntax tree for arguments patterns \nSynArgPats.Patterns \nPatterns \nSynArgPats.Pats \nPats \nSynArgPats.NamePatPairs \nNamePatPairs","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synargpats.html#Patterns","title":"SynArgPats.Patterns","content":"SynArgPats.Patterns \nPatterns \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synargpats.html#Pats","title":"SynArgPats.Pats","content":"SynArgPats.Pats \nPats \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synargpats.html#NamePatPairs","title":"SynArgPats.NamePatPairs","content":"SynArgPats.NamePatPairs \nNamePatPairs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattribute.html","title":"SynAttribute","content":"SynAttribute \n Represents an attribute \nSynAttribute.TypeName \nTypeName \nSynAttribute.ArgExpr \nArgExpr \nSynAttribute.Target \nTarget \nSynAttribute.AppliesToGetterAndSetter \nAppliesToGetterAndSetter \nSynAttribute.Range \nRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattribute.html#TypeName","title":"SynAttribute.TypeName","content":"SynAttribute.TypeName \nTypeName \n The name of the type for the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattribute.html#ArgExpr","title":"SynAttribute.ArgExpr","content":"SynAttribute.ArgExpr \nArgExpr \n The argument of the attribute, perhaps a tuple","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattribute.html#Target","title":"SynAttribute.Target","content":"SynAttribute.Target \nTarget \n Target specifier, e.g. \u0022assembly\u0022, \u0022module\u0022, etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattribute.html#AppliesToGetterAndSetter","title":"SynAttribute.AppliesToGetterAndSetter","content":"SynAttribute.AppliesToGetterAndSetter \nAppliesToGetterAndSetter \n Is this attribute being applied to a property getter or setter?","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattribute.html#Range","title":"SynAttribute.Range","content":"SynAttribute.Range \nRange \n The syntax range of the attribute","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattributelist.html","title":"SynAttributeList","content":"SynAttributeList \n List of attributes enclosed in [\u003C ... \u003E]. \nSynAttributeList.Attributes \nAttributes \nSynAttributeList.Range \nRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattributelist.html#Attributes","title":"SynAttributeList.Attributes","content":"SynAttributeList.Attributes \nAttributes \n The list of attributes","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synattributelist.html#Range","title":"SynAttributeList.Range","content":"SynAttributeList.Range \nRange \n The syntax range of the list of attributes","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbinding.html","title":"SynBinding","content":"SynBinding \n Represents a binding for a \u0027let\u0027 or \u0027member\u0027 declaration \nSynBinding.RangeOfBindingWithoutRhs \nRangeOfBindingWithoutRhs \nSynBinding.RangeOfBindingWithRhs \nRangeOfBindingWithRhs \nSynBinding.RangeOfHeadPattern \nRangeOfHeadPattern \nSynBinding.SynBinding \nSynBinding","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbinding.html#RangeOfBindingWithoutRhs","title":"SynBinding.RangeOfBindingWithoutRhs","content":"SynBinding.RangeOfBindingWithoutRhs \nRangeOfBindingWithoutRhs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbinding.html#RangeOfBindingWithRhs","title":"SynBinding.RangeOfBindingWithRhs","content":"SynBinding.RangeOfBindingWithRhs \nRangeOfBindingWithRhs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbinding.html#RangeOfHeadPattern","title":"SynBinding.RangeOfHeadPattern","content":"SynBinding.RangeOfHeadPattern \nRangeOfHeadPattern \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbinding.html#SynBinding","title":"SynBinding.SynBinding","content":"SynBinding.SynBinding \nSynBinding \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbindingkind.html","title":"SynBindingKind","content":"SynBindingKind \n The kind associated with a binding - \u0022let\u0022, \u0022do\u0022 or a standalone expression \nSynBindingKind.StandaloneExpression \nStandaloneExpression \nSynBindingKind.Normal \nNormal \nSynBindingKind.Do \nDo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbindingkind.html#StandaloneExpression","title":"SynBindingKind.StandaloneExpression","content":"SynBindingKind.StandaloneExpression \nStandaloneExpression \n A standalone expression in a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbindingkind.html#Normal","title":"SynBindingKind.Normal","content":"SynBindingKind.Normal \nNormal \n A normal \u0027let\u0027 binding in a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbindingkind.html#Do","title":"SynBindingKind.Do","content":"SynBindingKind.Do \nDo \n A \u0027do\u0027 binding in a module. Must have type \u0027unit\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbindingreturninfo.html","title":"SynBindingReturnInfo","content":"SynBindingReturnInfo \n Represents the return information in a binding for a \u0027let\u0027 or \u0027member\u0027 declaration \nSynBindingReturnInfo.SynBindingReturnInfo \nSynBindingReturnInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbindingreturninfo.html#SynBindingReturnInfo","title":"SynBindingReturnInfo.SynBindingReturnInfo","content":"SynBindingReturnInfo.SynBindingReturnInfo \nSynBindingReturnInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbytestringkind.html","title":"SynByteStringKind","content":"SynByteStringKind \n Indicate if the byte string had a special format \nSynByteStringKind.Regular \nRegular \nSynByteStringKind.Verbatim \nVerbatim","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbytestringkind.html#Regular","title":"SynByteStringKind.Regular","content":"SynByteStringKind.Regular \nRegular \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synbytestringkind.html#Verbatim","title":"SynByteStringKind.Verbatim","content":"SynByteStringKind.Verbatim \nVerbatim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syncomponentinfo.html","title":"SynComponentInfo","content":"SynComponentInfo \n Represents the syntax tree associated with the name of a type definition or module\n in signature or implementation.\n\n This includes the name, attributes, type parameters, constraints, documentation and accessibility\n for a type definition or module. For modules, entries such as the type parameters are\n always empty. \nSynComponentInfo.Range \nRange \nSynComponentInfo.SynComponentInfo \nSynComponentInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syncomponentinfo.html#Range","title":"SynComponentInfo.Range","content":"SynComponentInfo.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syncomponentinfo.html#SynComponentInfo","title":"SynComponentInfo.SynComponentInfo","content":"SynComponentInfo.SynComponentInfo \nSynComponentInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html","title":"SynConst","content":"SynConst \n The unchecked abstract syntax tree of constants in F# types and expressions. \nSynConst.Range \nRange \nSynConst.Unit \nUnit \nSynConst.Bool \nBool \nSynConst.SByte \nSByte \nSynConst.Byte \nByte \nSynConst.Int16 \nInt16 \nSynConst.UInt16 \nUInt16 \nSynConst.Int32 \nInt32 \nSynConst.UInt32 \nUInt32 \nSynConst.Int64 \nInt64 \nSynConst.UInt64 \nUInt64 \nSynConst.IntPtr \nIntPtr \nSynConst.UIntPtr \nUIntPtr \nSynConst.Single \nSingle \nSynConst.Double \nDouble \nSynConst.Char \nChar \nSynConst.Decimal \nDecimal \nSynConst.UserNum \nUserNum \nSynConst.String \nString \nSynConst.Bytes \nBytes \nSynConst.UInt16s \nUInt16s \nSynConst.Measure \nMeasure \nSynConst.SourceIdentifier \nSourceIdentifier","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Range","title":"SynConst.Range","content":"SynConst.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Unit","title":"SynConst.Unit","content":"SynConst.Unit \nUnit \n F# syntax: ()","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Bool","title":"SynConst.Bool","content":"SynConst.Bool \nBool \n F# syntax: true, false","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#SByte","title":"SynConst.SByte","content":"SynConst.SByte \nSByte \n F# syntax: 13y, 0xFFy, 0o077y, 0b0111101y","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Byte","title":"SynConst.Byte","content":"SynConst.Byte \nByte \n F# syntax: 13uy, 0x40uy, 0oFFuy, 0b0111101uy","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Int16","title":"SynConst.Int16","content":"SynConst.Int16 \nInt16 \n F# syntax: 13s, 0x4000s, 0o0777s, 0b0111101s","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#UInt16","title":"SynConst.UInt16","content":"SynConst.UInt16 \nUInt16 \n F# syntax: 13us, 0x4000us, 0o0777us, 0b0111101us","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Int32","title":"SynConst.Int32","content":"SynConst.Int32 \nInt32 \n F# syntax: 13, 0x4000, 0o0777","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#UInt32","title":"SynConst.UInt32","content":"SynConst.UInt32 \nUInt32 \n F# syntax: 13u, 0x4000u, 0o0777u","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Int64","title":"SynConst.Int64","content":"SynConst.Int64 \nInt64 \n F# syntax: 13L","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#UInt64","title":"SynConst.UInt64","content":"SynConst.UInt64 \nUInt64 \n F# syntax: 13UL","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#IntPtr","title":"SynConst.IntPtr","content":"SynConst.IntPtr \nIntPtr \n F# syntax: 13n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#UIntPtr","title":"SynConst.UIntPtr","content":"SynConst.UIntPtr \nUIntPtr \n F# syntax: 13un","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Single","title":"SynConst.Single","content":"SynConst.Single \nSingle \n F# syntax: 1.30f, 1.40e10f etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Double","title":"SynConst.Double","content":"SynConst.Double \nDouble \n F# syntax: 1.30, 1.40e10 etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Char","title":"SynConst.Char","content":"SynConst.Char \nChar \n F# syntax: \u0027a\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Decimal","title":"SynConst.Decimal","content":"SynConst.Decimal \nDecimal \n F# syntax: 23.4M","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#UserNum","title":"SynConst.UserNum","content":"SynConst.UserNum \nUserNum \n UserNum(value, suffix)\n\n F# syntax: 1Q, 1Z, 1R, 1N, 1G","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#String","title":"SynConst.String","content":"SynConst.String \nString \n F# syntax: verbatim or regular string, e.g. \u0022abc\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Bytes","title":"SynConst.Bytes","content":"SynConst.Bytes \nBytes \n F# syntax: verbatim or regular byte string, e.g. \u0022abc\u0022B.\n\n Also used internally in the typechecker once an array of unit16 constants\n is detected, to allow more efficient processing of large arrays of uint16 constants.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#UInt16s","title":"SynConst.UInt16s","content":"SynConst.UInt16s \nUInt16s \n Used internally in the typechecker once an array of unit16 constants\n is detected, to allow more efficient processing of large arrays of uint16 constants.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#Measure","title":"SynConst.Measure","content":"SynConst.Measure \nMeasure \n Old comment: \u0022we never iterate, so the const here is not another SynConst.Measure\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synconst.html#SourceIdentifier","title":"SynConst.SourceIdentifier","content":"SynConst.SourceIdentifier \nSourceIdentifier \n Source Line, File, and Path Identifiers\n Containing both the original value as the evaluated value.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synenumcase.html","title":"SynEnumCase","content":"SynEnumCase \n Represents the syntax tree for one case in an enum definition. \nSynEnumCase.Range \nRange \nSynEnumCase.SynEnumCase \nSynEnumCase","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synenumcase.html#Range","title":"SynEnumCase.Range","content":"SynEnumCase.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synenumcase.html#SynEnumCase","title":"SynEnumCase.SynEnumCase","content":"SynEnumCase.SynEnumCase \nSynEnumCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptiondefn.html","title":"SynExceptionDefn","content":"SynExceptionDefn \n Represents the right hand side of an exception declaration \u0027exception E = ... \u0027 plus\n any member definitions for the exception \nSynExceptionDefn.Range \nRange \nSynExceptionDefn.SynExceptionDefn \nSynExceptionDefn","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptiondefn.html#Range","title":"SynExceptionDefn.Range","content":"SynExceptionDefn.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptiondefn.html#SynExceptionDefn","title":"SynExceptionDefn.SynExceptionDefn","content":"SynExceptionDefn.SynExceptionDefn \nSynExceptionDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptiondefnrepr.html","title":"SynExceptionDefnRepr","content":"SynExceptionDefnRepr \n Represents the right hand side of an exception declaration \u0027exception E = ... \u0027 \nSynExceptionDefnRepr.Range \nRange \nSynExceptionDefnRepr.SynExceptionDefnRepr \nSynExceptionDefnRepr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptiondefnrepr.html#Range","title":"SynExceptionDefnRepr.Range","content":"SynExceptionDefnRepr.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptiondefnrepr.html#SynExceptionDefnRepr","title":"SynExceptionDefnRepr.SynExceptionDefnRepr","content":"SynExceptionDefnRepr.SynExceptionDefnRepr \nSynExceptionDefnRepr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptionsig.html","title":"SynExceptionSig","content":"SynExceptionSig \n Represents the right hand side of an exception definition in a signature file \nSynExceptionSig.SynExceptionSig \nSynExceptionSig","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexceptionsig.html#SynExceptionSig","title":"SynExceptionSig.SynExceptionSig","content":"SynExceptionSig.SynExceptionSig \nSynExceptionSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html","title":"SynExpr","content":"SynExpr \n Represents a syntax tree for F# expressions \nSynExpr.Range \nRange \nSynExpr.RangeWithoutAnyExtraDot \nRangeWithoutAnyExtraDot \nSynExpr.RangeOfFirstPortion \nRangeOfFirstPortion \nSynExpr.IsArbExprAndThusAlreadyReportedError \nIsArbExprAndThusAlreadyReportedError \nSynExpr.Paren \nParen \nSynExpr.Quote \nQuote \nSynExpr.Const \nConst \nSynExpr.Typed \nTyped \nSynExpr.Tuple \nTuple \nSynExpr.AnonRecd \nAnonRecd \nSynExpr.ArrayOrList \nArrayOrList \nSynExpr.Record \nRecord \nSynExpr.New \nNew \nSynExpr.ObjExpr \nObjExpr \nSynExpr.While \nWhile \nSynExpr.For \nFor \nSynExpr.ForEach \nForEach \nSynExpr.ArrayOrListComputed \nArrayOrListComputed \nSynExpr.IndexRange \nIndexRange \nSynExpr.IndexFromEnd \nIndexFromEnd \nSynExpr.ComputationExpr \nComputationExpr \nSynExpr.Lambda \nLambda \nSynExpr.MatchLambda \nMatchLambda \nSynExpr.Match \nMatch \nSynExpr.Do \nDo \nSynExpr.Assert \nAssert \nSynExpr.App \nApp \nSynExpr.TypeApp \nTypeApp \nSynExpr.LetOrUse \nLetOrUse \nSynExpr.TryWith \nTryWith \nSynExpr.TryFinally \nTryFinally \nSynExpr.Lazy \nLazy \nSynExpr.Sequential \nSequential \nSynExpr.IfThenElse \nIfThenElse \nSynExpr.Typar \nTypar \nSynExpr.Ident \nIdent \nSynExpr.LongIdent \nLongIdent \nSynExpr.LongIdentSet \nLongIdentSet \nSynExpr.DotGet \nDotGet \nSynExpr.DotLambda \nDotLambda \nSynExpr.DotSet \nDotSet \nSynExpr.Set \nSet \nSynExpr.DotIndexedGet \nDotIndexedGet \nSynExpr.DotIndexedSet \nDotIndexedSet \nSynExpr.NamedIndexedPropertySet \nNamedIndexedPropertySet \nSynExpr.DotNamedIndexedPropertySet \nDotNamedIndexedPropertySet \nSynExpr.TypeTest \nTypeTest \nSynExpr.Upcast \nUpcast \nSynExpr.Downcast \nDowncast \nSynExpr.InferredUpcast \nInferredUpcast \nSynExpr.InferredDowncast \nInferredDowncast \nSynExpr.Null \nNull \nSynExpr.AddressOf \nAddressOf \nSynExpr.TraitCall \nTraitCall \nSynExpr.JoinIn \nJoinIn \nSynExpr.ImplicitZero \nImplicitZero \nSynExpr.SequentialOrImplicitYield \nSequentialOrImplicitYield \nSynExpr.YieldOrReturn \nYieldOrReturn \nSynExpr.YieldOrReturnFrom \nYieldOrReturnFrom \nSynExpr.LetOrUseBang \nLetOrUseBang \nSynExpr.MatchBang \nMatchBang \nSynExpr.DoBang \nDoBang \nSynExpr.WhileBang \nWhileBang \nSynExpr.LibraryOnlyILAssembly \nLibraryOnlyILAssembly \nSynExpr.LibraryOnlyStaticOptimization \nLibraryOnlyStaticOptimization \nSynExpr.LibraryOnlyUnionCaseFieldGet \nLibraryOnlyUnionCaseFieldGet \nSynExpr.LibraryOnlyUnionCaseFieldSet \nLibraryOnlyUnionCaseFieldSet \nSynExpr.ArbitraryAfterError \nArbitraryAfterError \nSynExpr.FromParseError \nFromParseError \nSynExpr.DiscardAfterMissingQualificationAfterDot \nDiscardAfterMissingQualificationAfterDot \nSynExpr.Fixed \nFixed \nSynExpr.InterpolatedString \nInterpolatedString \nSynExpr.DebugPoint \nDebugPoint \nSynExpr.Dynamic \nDynamic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Range","title":"SynExpr.Range","content":"SynExpr.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#RangeWithoutAnyExtraDot","title":"SynExpr.RangeWithoutAnyExtraDot","content":"SynExpr.RangeWithoutAnyExtraDot \nRangeWithoutAnyExtraDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#RangeOfFirstPortion","title":"SynExpr.RangeOfFirstPortion","content":"SynExpr.RangeOfFirstPortion \nRangeOfFirstPortion \n Attempt to get the range of the first token or initial portion only - this\n is ad-hoc, just a cheap way to improve a certain \u0027query custom operation\u0027 error range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#IsArbExprAndThusAlreadyReportedError","title":"SynExpr.IsArbExprAndThusAlreadyReportedError","content":"SynExpr.IsArbExprAndThusAlreadyReportedError \nIsArbExprAndThusAlreadyReportedError \n Indicates if this expression arises from error recovery","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Paren","title":"SynExpr.Paren","content":"SynExpr.Paren \nParen \n F# syntax: (expr)\n\n Parenthesized expressions. Kept in AST to distinguish A.M((x, y))\n from A.M(x, y), among other things.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Quote","title":"SynExpr.Quote","content":"SynExpr.Quote \nQuote \n F# syntax: \u003C@ expr @\u003E, \u003C@@ expr @@\u003E\n\n Quote(operator, isRaw, quotedSynExpr, isFromQueryExpression, m)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Const","title":"SynExpr.Const","content":"SynExpr.Const \nConst \n F# syntax: 1, 1.3, () etc.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Typed","title":"SynExpr.Typed","content":"SynExpr.Typed \nTyped \n F# syntax: expr: type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Tuple","title":"SynExpr.Tuple","content":"SynExpr.Tuple \nTuple \n F# syntax: e1, ..., eN","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#AnonRecd","title":"SynExpr.AnonRecd","content":"SynExpr.AnonRecd \nAnonRecd \n F# syntax: {| id1=e1; ...; idN=eN |}\n F# syntax: struct {| id1=e1; ...; idN=eN |}","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ArrayOrList","title":"SynExpr.ArrayOrList","content":"SynExpr.ArrayOrList \nArrayOrList \n F# syntax: [ e1; ...; en ], [| e1; ...; en |]","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Record","title":"SynExpr.Record","content":"SynExpr.Record \nRecord \n F# syntax: { f1=e1; ...; fn=en }\n inherit includes location of separator (for tooling)\n copyOpt contains range of the following WITH part (for tooling)\n every field includes range of separator after the field (for tooling)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#New","title":"SynExpr.New","content":"SynExpr.New \nNew \n F# syntax: new C(...)\n The flag is true if known to be \u0027family\u0027 (\u0027protected\u0027) scope","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ObjExpr","title":"SynExpr.ObjExpr","content":"SynExpr.ObjExpr \nObjExpr \n F# syntax: { new ... with ... }","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#While","title":"SynExpr.While","content":"SynExpr.While \nWhile \n F# syntax: \u0027while ... do ...\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#For","title":"SynExpr.For","content":"SynExpr.For \nFor \n F# syntax: \u0027for i = ... to ... do ...\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ForEach","title":"SynExpr.ForEach","content":"SynExpr.ForEach \nForEach \n F# syntax: \u0027for ... in ... do ...\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ArrayOrListComputed","title":"SynExpr.ArrayOrListComputed","content":"SynExpr.ArrayOrListComputed \nArrayOrListComputed \n F# syntax: [ expr ], [| expr |]","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#IndexRange","title":"SynExpr.IndexRange","content":"SynExpr.IndexRange \nIndexRange \n F# syntax: expr..\n F# syntax: ..expr\n F# syntax: expr..expr\n F# syntax: *\n A two-element range indexer argument a..b, a.., ..b. Also used to represent\n a range in a list, array or sequence expression.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#IndexFromEnd","title":"SynExpr.IndexFromEnd","content":"SynExpr.IndexFromEnd \nIndexFromEnd \n F# syntax: ^expr, used for from-end-of-collection indexing and ^T.Operation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ComputationExpr","title":"SynExpr.ComputationExpr","content":"SynExpr.ComputationExpr \nComputationExpr \n F# syntax: { expr }","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Lambda","title":"SynExpr.Lambda","content":"SynExpr.Lambda \nLambda \n First bool indicates if lambda originates from a method. Patterns here are always \u0022simple\u0022\n Second bool indicates if this is a \u0022later\u0022 part of an iterated sequence of lambdas\n parsedData keeps original parsed patterns and expression,\n prior to transforming to \u0022simple\u0022 patterns and iterated lambdas\n\n F# syntax: fun pat -\u003E expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#MatchLambda","title":"SynExpr.MatchLambda","content":"SynExpr.MatchLambda \nMatchLambda \n F# syntax: function pat1 -\u003E expr | ... | patN -\u003E exprN","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Match","title":"SynExpr.Match","content":"SynExpr.Match \nMatch \n F# syntax: match expr with pat1 -\u003E expr | ... | patN -\u003E exprN","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Do","title":"SynExpr.Do","content":"SynExpr.Do \nDo \n F# syntax: do expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Assert","title":"SynExpr.Assert","content":"SynExpr.Assert \nAssert \n F# syntax: assert expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#App","title":"SynExpr.App","content":"SynExpr.App \nApp \n F# syntax: f x\n\n flag: indicates if the application is syntactically atomic, e.g. f.[1] is atomic, but \u0027f x\u0027 is not\n isInfix is true for the first app of an infix operator, e.g. 1\u002B2\n becomes App(App(\u002B, 1), 2), where the inner node is marked isInfix","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#TypeApp","title":"SynExpr.TypeApp","content":"SynExpr.TypeApp \nTypeApp \n F# syntax: expr\u003Ctype1, ..., typeN\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LetOrUse","title":"SynExpr.LetOrUse","content":"SynExpr.LetOrUse \nLetOrUse \n F# syntax: let pat = expr in expr\n F# syntax: let f pat1 .. patN = expr in expr\n F# syntax: let rec f pat1 .. patN = expr in expr\n F# syntax: use pat = expr in expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#TryWith","title":"SynExpr.TryWith","content":"SynExpr.TryWith \nTryWith \n F# syntax: try expr with pat -\u003E expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#TryFinally","title":"SynExpr.TryFinally","content":"SynExpr.TryFinally \nTryFinally \n F# syntax: try expr finally expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Lazy","title":"SynExpr.Lazy","content":"SynExpr.Lazy \nLazy \n F# syntax: lazy expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Sequential","title":"SynExpr.Sequential","content":"SynExpr.Sequential \nSequential \n\u003Cpre\u003E F# syntax: expr; expr\n\n isTrueSeq: false indicates \u0022let v = a in b; v\u0022\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#IfThenElse","title":"SynExpr.IfThenElse","content":"SynExpr.IfThenElse \nIfThenElse \n F# syntax: if expr then expr\n F# syntax: if expr then expr else expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Typar","title":"SynExpr.Typar","content":"SynExpr.Typar \nTypar \n F# syntax: \u0027T (for \u0027T.ident).","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Ident","title":"SynExpr.Ident","content":"SynExpr.Ident \nIdent \n F# syntax: ident\n Optimized representation for SynExpr.LongIdent (false, [id], id.idRange)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LongIdent","title":"SynExpr.LongIdent","content":"SynExpr.LongIdent \nLongIdent \n F# syntax: ident.ident...ident\n\n isOptional: true if preceded by a \u0027?\u0027 for an optional named parameter\n altNameRefCell: Normally \u0027None\u0027 except for some compiler-generated\n variables in desugaring pattern matching. See SynSimplePat.Id","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LongIdentSet","title":"SynExpr.LongIdentSet","content":"SynExpr.LongIdentSet \nLongIdentSet \n F# syntax: ident.ident...ident \u003C- expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DotGet","title":"SynExpr.DotGet","content":"SynExpr.DotGet \nDotGet \n F# syntax: expr.ident.ident","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DotLambda","title":"SynExpr.DotLambda","content":"SynExpr.DotLambda \nDotLambda \n F# syntax: _.ident.ident","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DotSet","title":"SynExpr.DotSet","content":"SynExpr.DotSet \nDotSet \n F# syntax: expr.ident...ident \u003C- expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Set","title":"SynExpr.Set","content":"SynExpr.Set \nSet \n F# syntax: expr \u003C- expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DotIndexedGet","title":"SynExpr.DotIndexedGet","content":"SynExpr.DotIndexedGet \nDotIndexedGet \n F# syntax: expr.[expr, ..., expr]","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DotIndexedSet","title":"SynExpr.DotIndexedSet","content":"SynExpr.DotIndexedSet \nDotIndexedSet \n F# syntax: expr.[expr, ..., expr] \u003C- expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#NamedIndexedPropertySet","title":"SynExpr.NamedIndexedPropertySet","content":"SynExpr.NamedIndexedPropertySet \nNamedIndexedPropertySet \n F# syntax: Type.Items(e1) \u003C- e2, rarely used named-property-setter notation, e.g. Foo.Bar.Chars(3) \u003C- \u0027a\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DotNamedIndexedPropertySet","title":"SynExpr.DotNamedIndexedPropertySet","content":"SynExpr.DotNamedIndexedPropertySet \nDotNamedIndexedPropertySet \n F# syntax: expr.Items (e1) \u003C- e2, rarely used named-property-setter notation, e.g. (stringExpr).Chars(3) \u003C- \u0027a\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#TypeTest","title":"SynExpr.TypeTest","content":"SynExpr.TypeTest \nTypeTest \n F# syntax: expr :? type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Upcast","title":"SynExpr.Upcast","content":"SynExpr.Upcast \nUpcast \n F# syntax: expr :\u003E type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Downcast","title":"SynExpr.Downcast","content":"SynExpr.Downcast \nDowncast \n F# syntax: expr :?\u003E type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#InferredUpcast","title":"SynExpr.InferredUpcast","content":"SynExpr.InferredUpcast \nInferredUpcast \n F# syntax: upcast expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#InferredDowncast","title":"SynExpr.InferredDowncast","content":"SynExpr.InferredDowncast \nInferredDowncast \n F# syntax: downcast expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Null","title":"SynExpr.Null","content":"SynExpr.Null \nNull \n F# syntax: null","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#AddressOf","title":"SynExpr.AddressOf","content":"SynExpr.AddressOf \nAddressOf \n F# syntax: \u0026expr, \u0026\u0026expr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#TraitCall","title":"SynExpr.TraitCall","content":"SynExpr.TraitCall \nTraitCall \n F# syntax: ((type1 or ... or typeN): (member-dig) expr)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#JoinIn","title":"SynExpr.JoinIn","content":"SynExpr.JoinIn \nJoinIn \n F# syntax: ... in ...\n Computation expressions only, based on JOIN_IN token from lex filter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ImplicitZero","title":"SynExpr.ImplicitZero","content":"SynExpr.ImplicitZero \nImplicitZero \n Used in parser error recovery and internally during type checking for translating computation expressions.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#SequentialOrImplicitYield","title":"SynExpr.SequentialOrImplicitYield","content":"SynExpr.SequentialOrImplicitYield \nSequentialOrImplicitYield \n Used internally during type checking for translating computation expressions.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#YieldOrReturn","title":"SynExpr.YieldOrReturn","content":"SynExpr.YieldOrReturn \nYieldOrReturn \n F# syntax: yield expr\n F# syntax: return expr\n Computation expressions only","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#YieldOrReturnFrom","title":"SynExpr.YieldOrReturnFrom","content":"SynExpr.YieldOrReturnFrom \nYieldOrReturnFrom \n F# syntax: yield! expr\n F# syntax: return! expr\n Computation expressions only","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LetOrUseBang","title":"SynExpr.LetOrUseBang","content":"SynExpr.LetOrUseBang \nLetOrUseBang \n F# syntax: let! pat = expr in expr\n F# syntax: use! pat = expr in expr\n F# syntax: let! pat = expr and! ... and! ... and! pat = expr in expr\n Computation expressions only","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#MatchBang","title":"SynExpr.MatchBang","content":"SynExpr.MatchBang \nMatchBang \n F# syntax: match! expr with pat1 -\u003E expr | ... | patN -\u003E exprN","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DoBang","title":"SynExpr.DoBang","content":"SynExpr.DoBang \nDoBang \n F# syntax: do! expr\n Computation expressions only","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#WhileBang","title":"SynExpr.WhileBang","content":"SynExpr.WhileBang \nWhileBang \n F# syntax: \u0027while! ... do ...\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LibraryOnlyILAssembly","title":"SynExpr.LibraryOnlyILAssembly","content":"SynExpr.LibraryOnlyILAssembly \nLibraryOnlyILAssembly \n Only used in FSharp.Core","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LibraryOnlyStaticOptimization","title":"SynExpr.LibraryOnlyStaticOptimization","content":"SynExpr.LibraryOnlyStaticOptimization \nLibraryOnlyStaticOptimization \n Only used in FSharp.Core","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LibraryOnlyUnionCaseFieldGet","title":"SynExpr.LibraryOnlyUnionCaseFieldGet","content":"SynExpr.LibraryOnlyUnionCaseFieldGet \nLibraryOnlyUnionCaseFieldGet \n Only used in FSharp.Core","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#LibraryOnlyUnionCaseFieldSet","title":"SynExpr.LibraryOnlyUnionCaseFieldSet","content":"SynExpr.LibraryOnlyUnionCaseFieldSet \nLibraryOnlyUnionCaseFieldSet \n Only used in FSharp.Core","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#ArbitraryAfterError","title":"SynExpr.ArbitraryAfterError","content":"SynExpr.ArbitraryAfterError \nArbitraryAfterError \n Inserted for error recovery","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#FromParseError","title":"SynExpr.FromParseError","content":"SynExpr.FromParseError \nFromParseError \n Inserted for error recovery","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DiscardAfterMissingQualificationAfterDot","title":"SynExpr.DiscardAfterMissingQualificationAfterDot","content":"SynExpr.DiscardAfterMissingQualificationAfterDot \nDiscardAfterMissingQualificationAfterDot \n Inserted for error recovery when there is \u0022expr.\u0022 and missing tokens or error recovery after the dot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Fixed","title":"SynExpr.Fixed","content":"SynExpr.Fixed \nFixed \n \u0027use x = fixed expr\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#InterpolatedString","title":"SynExpr.InterpolatedString","content":"SynExpr.InterpolatedString \nInterpolatedString \n F# syntax: interpolated string, e.g. \u0022abc{x}\u0022 or \u0022abc{x,3}\u0022 or \u0022abc{x:N4}\u0022\n Note the string ranges include the quotes, verbatim markers, dollar sign and braces","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#DebugPoint","title":"SynExpr.DebugPoint","content":"SynExpr.DebugPoint \nDebugPoint \n Debug points arising from computation expressions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexpr.html#Dynamic","title":"SynExpr.Dynamic","content":"SynExpr.Dynamic \nDynamic \n F# syntax: f?x","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexprandbang.html","title":"SynExprAndBang","content":"SynExprAndBang \n \nSynExprAndBang.SynExprAndBang \nSynExprAndBang","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexprandbang.html#SynExprAndBang","title":"SynExprAndBang.SynExprAndBang","content":"SynExprAndBang.SynExprAndBang \nSynExprAndBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexprrecordfield.html","title":"SynExprRecordField","content":"SynExprRecordField \n \nSynExprRecordField.SynExprRecordField \nSynExprRecordField","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synexprrecordfield.html#SynExprRecordField","title":"SynExprRecordField.SynExprRecordField","content":"SynExprRecordField.SynExprRecordField \nSynExprRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synfield.html","title":"SynField","content":"SynField \n Represents the syntax tree for a field declaration in a record or class \nSynField.Range \nRange \nSynField.SynField \nSynField","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synfield.html#Range","title":"SynField.Range","content":"SynField.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synfield.html#SynField","title":"SynField.SynField","content":"SynField.SynField \nSynField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synident.html","title":"SynIdent","content":"SynIdent \n Represents an identifier with potentially additional trivia information. \nSynIdent.SynIdent \nSynIdent","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synident.html#SynIdent","title":"SynIdent.SynIdent","content":"SynIdent.SynIdent \nSynIdent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syninterfaceimpl.html","title":"SynInterfaceImpl","content":"SynInterfaceImpl \n Represents a set of bindings that implement an interface \nSynInterfaceImpl.SynInterfaceImpl \nSynInterfaceImpl","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syninterfaceimpl.html#SynInterfaceImpl","title":"SynInterfaceImpl.SynInterfaceImpl","content":"SynInterfaceImpl.SynInterfaceImpl \nSynInterfaceImpl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syninterpolatedstringpart.html","title":"SynInterpolatedStringPart","content":"SynInterpolatedStringPart \n \nSynInterpolatedStringPart.String \nString \nSynInterpolatedStringPart.FillExpr \nFillExpr","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syninterpolatedstringpart.html#String","title":"SynInterpolatedStringPart.String","content":"SynInterpolatedStringPart.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syninterpolatedstringpart.html#FillExpr","title":"SynInterpolatedStringPart.FillExpr","content":"SynInterpolatedStringPart.FillExpr \nFillExpr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html","title":"SynLongIdent","content":"SynLongIdent \n Represents a long identifier with possible \u0027.\u0027 at end.\n\n Typically dotRanges.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. \u0022Foo.Bar.\u0022\n The dots mostly matter for parsing, and are typically ignored by the typechecker, but\n if dotRanges.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed\n more freedom about typechecking these expressions.\n LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit) \nSynLongIdent.Dots \nDots \nSynLongIdent.Range \nRange \nSynLongIdent.RangeWithoutAnyExtraDot \nRangeWithoutAnyExtraDot \nSynLongIdent.Trivia \nTrivia \nSynLongIdent.IdentsWithTrivia \nIdentsWithTrivia \nSynLongIdent.ThereIsAnExtraDotAtTheEnd \nThereIsAnExtraDotAtTheEnd \nSynLongIdent.LongIdent \nLongIdent \nSynLongIdent.SynLongIdent \nSynLongIdent","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#Dots","title":"SynLongIdent.Dots","content":"SynLongIdent.Dots \nDots \n Get the dot ranges","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#Range","title":"SynLongIdent.Range","content":"SynLongIdent.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#RangeWithoutAnyExtraDot","title":"SynLongIdent.RangeWithoutAnyExtraDot","content":"SynLongIdent.RangeWithoutAnyExtraDot \nRangeWithoutAnyExtraDot \n Gets the syntax range for part of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#Trivia","title":"SynLongIdent.Trivia","content":"SynLongIdent.Trivia \nTrivia \n Get the trivia of the idents","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#IdentsWithTrivia","title":"SynLongIdent.IdentsWithTrivia","content":"SynLongIdent.IdentsWithTrivia \nIdentsWithTrivia \n Get the idents with potential trivia attached","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#ThereIsAnExtraDotAtTheEnd","title":"SynLongIdent.ThereIsAnExtraDotAtTheEnd","content":"SynLongIdent.ThereIsAnExtraDotAtTheEnd \nThereIsAnExtraDotAtTheEnd \n Indicates if the construct ends in \u0027.\u0027 due to error recovery","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#LongIdent","title":"SynLongIdent.LongIdent","content":"SynLongIdent.LongIdent \nLongIdent \n Get the long ident for this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synlongident.html#SynLongIdent","title":"SynLongIdent.SynLongIdent","content":"SynLongIdent.SynLongIdent \nSynLongIdent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmatchclause.html","title":"SynMatchClause","content":"SynMatchClause \n Represents a clause in a \u0027match\u0027 expression \nSynMatchClause.Range \nRange \nSynMatchClause.RangeOfGuardAndRhs \nRangeOfGuardAndRhs \nSynMatchClause.SynMatchClause \nSynMatchClause","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmatchclause.html#Range","title":"SynMatchClause.Range","content":"SynMatchClause.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmatchclause.html#RangeOfGuardAndRhs","title":"SynMatchClause.RangeOfGuardAndRhs","content":"SynMatchClause.RangeOfGuardAndRhs \nRangeOfGuardAndRhs \n Gets the syntax range of part of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmatchclause.html#SynMatchClause","title":"SynMatchClause.SynMatchClause","content":"SynMatchClause.SynMatchClause \nSynMatchClause \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html","title":"SynMeasure","content":"SynMeasure \n Represents an unchecked syntax tree of F# unit of measure annotations. \nSynMeasure.Named \nNamed \nSynMeasure.Product \nProduct \nSynMeasure.Seq \nSeq \nSynMeasure.Divide \nDivide \nSynMeasure.Power \nPower \nSynMeasure.One \nOne \nSynMeasure.Anon \nAnon \nSynMeasure.Var \nVar \nSynMeasure.Paren \nParen","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Named","title":"SynMeasure.Named","content":"SynMeasure.Named \nNamed \n A named unit of measure","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Product","title":"SynMeasure.Product","content":"SynMeasure.Product \nProduct \n A product of two units of measure, e.g. \u0027kg * m\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Seq","title":"SynMeasure.Seq","content":"SynMeasure.Seq \nSeq \n A sequence of several units of measure, e.g. \u0027kg m m\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Divide","title":"SynMeasure.Divide","content":"SynMeasure.Divide \nDivide \n A division of two units of measure, e.g. \u0027kg / m\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Power","title":"SynMeasure.Power","content":"SynMeasure.Power \nPower \n A power of a unit of measure, e.g. \u0027kg ^ 2\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#One","title":"SynMeasure.One","content":"SynMeasure.One \nOne \n The \u00271\u0027 unit of measure","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Anon","title":"SynMeasure.Anon","content":"SynMeasure.Anon \nAnon \n An anonymous (inferred) unit of measure","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Var","title":"SynMeasure.Var","content":"SynMeasure.Var \nVar \n A variable unit of measure","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmeasure.html#Paren","title":"SynMeasure.Paren","content":"SynMeasure.Paren \nParen \n A parenthesized measure","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html","title":"SynMemberDefn","content":"SynMemberDefn \n Represents a definition element within a type definition, e.g. \u0027member ... \u0027 \nSynMemberDefn.Range \nRange \nSynMemberDefn.Open \nOpen \nSynMemberDefn.Member \nMember \nSynMemberDefn.GetSetMember \nGetSetMember \nSynMemberDefn.ImplicitCtor \nImplicitCtor \nSynMemberDefn.ImplicitInherit \nImplicitInherit \nSynMemberDefn.LetBindings \nLetBindings \nSynMemberDefn.AbstractSlot \nAbstractSlot \nSynMemberDefn.Interface \nInterface \nSynMemberDefn.Inherit \nInherit \nSynMemberDefn.ValField \nValField \nSynMemberDefn.NestedType \nNestedType \nSynMemberDefn.AutoProperty \nAutoProperty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#Range","title":"SynMemberDefn.Range","content":"SynMemberDefn.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#Open","title":"SynMemberDefn.Open","content":"SynMemberDefn.Open \nOpen \n An \u0027open\u0027 definition within a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#Member","title":"SynMemberDefn.Member","content":"SynMemberDefn.Member \nMember \n A \u0027member\u0027 definition within a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#GetSetMember","title":"SynMemberDefn.GetSetMember","content":"SynMemberDefn.GetSetMember \nGetSetMember \n A \u0027member\u0027 definition with get/set accessors within a type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#ImplicitCtor","title":"SynMemberDefn.ImplicitCtor","content":"SynMemberDefn.ImplicitCtor \nImplicitCtor \n An implicit constructor definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#ImplicitInherit","title":"SynMemberDefn.ImplicitInherit","content":"SynMemberDefn.ImplicitInherit \nImplicitInherit \n An implicit inherit definition, \u0027inherit \u003Ctyp\u003E(args...) as base\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#LetBindings","title":"SynMemberDefn.LetBindings","content":"SynMemberDefn.LetBindings \nLetBindings \n A \u0027let\u0027 definition within a class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#AbstractSlot","title":"SynMemberDefn.AbstractSlot","content":"SynMemberDefn.AbstractSlot \nAbstractSlot \n An abstract slot definition within a class or interface","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#Interface","title":"SynMemberDefn.Interface","content":"SynMemberDefn.Interface \nInterface \n An interface implementation definition within a class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#Inherit","title":"SynMemberDefn.Inherit","content":"SynMemberDefn.Inherit \nInherit \n An \u0027inherit\u0027 definition within a class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#ValField","title":"SynMemberDefn.ValField","content":"SynMemberDefn.ValField \nValField \n A \u0027val\u0027 definition within a class","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#NestedType","title":"SynMemberDefn.NestedType","content":"SynMemberDefn.NestedType \nNestedType \n A nested type definition, a feature that is not implemented","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberdefn.html#AutoProperty","title":"SynMemberDefn.AutoProperty","content":"SynMemberDefn.AutoProperty \nAutoProperty \n An auto-property definition, F# syntax: \u0027member val X = expr\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html","title":"SynMemberFlags","content":"SynMemberFlags \n Represents the flags for a \u0027member\u0027 declaration \nSynMemberFlags.IsInstance \nIsInstance \nSynMemberFlags.IsDispatchSlot \nIsDispatchSlot \nSynMemberFlags.IsOverrideOrExplicitImpl \nIsOverrideOrExplicitImpl \nSynMemberFlags.IsFinal \nIsFinal \nSynMemberFlags.GetterOrSetterIsCompilerGenerated \nGetterOrSetterIsCompilerGenerated \nSynMemberFlags.MemberKind \nMemberKind","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html#IsInstance","title":"SynMemberFlags.IsInstance","content":"SynMemberFlags.IsInstance \nIsInstance \n The member is an instance member (non-static)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html#IsDispatchSlot","title":"SynMemberFlags.IsDispatchSlot","content":"SynMemberFlags.IsDispatchSlot \nIsDispatchSlot \n The member is a dispatch slot","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html#IsOverrideOrExplicitImpl","title":"SynMemberFlags.IsOverrideOrExplicitImpl","content":"SynMemberFlags.IsOverrideOrExplicitImpl \nIsOverrideOrExplicitImpl \n The member is an \u0027override\u0027 or explicit interface implementation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html#IsFinal","title":"SynMemberFlags.IsFinal","content":"SynMemberFlags.IsFinal \nIsFinal \n The member is \u0027final\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html#GetterOrSetterIsCompilerGenerated","title":"SynMemberFlags.GetterOrSetterIsCompilerGenerated","content":"SynMemberFlags.GetterOrSetterIsCompilerGenerated \nGetterOrSetterIsCompilerGenerated \n The member was generated by the compiler","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberflags.html#MemberKind","title":"SynMemberFlags.MemberKind","content":"SynMemberFlags.MemberKind \nMemberKind \n The kind of the member","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html","title":"SynMemberKind","content":"SynMemberKind \n Note the member kind is actually computed partially by a syntax tree transformation in tc.fs \nSynMemberKind.ClassConstructor \nClassConstructor \nSynMemberKind.Constructor \nConstructor \nSynMemberKind.Member \nMember \nSynMemberKind.PropertyGet \nPropertyGet \nSynMemberKind.PropertySet \nPropertySet \nSynMemberKind.PropertyGetSet \nPropertyGetSet","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html#ClassConstructor","title":"SynMemberKind.ClassConstructor","content":"SynMemberKind.ClassConstructor \nClassConstructor \n The member is a class initializer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html#Constructor","title":"SynMemberKind.Constructor","content":"SynMemberKind.Constructor \nConstructor \n The member is a object model constructor","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html#Member","title":"SynMemberKind.Member","content":"SynMemberKind.Member \nMember \n The member kind is not yet determined","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html#PropertyGet","title":"SynMemberKind.PropertyGet","content":"SynMemberKind.PropertyGet \nPropertyGet \n The member kind is property getter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html#PropertySet","title":"SynMemberKind.PropertySet","content":"SynMemberKind.PropertySet \nPropertySet \n The member kind is property setter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmemberkind.html#PropertyGetSet","title":"SynMemberKind.PropertyGetSet","content":"SynMemberKind.PropertyGetSet \nPropertyGetSet \n An artificial member kind used prior to the point where a\n get/set property is split into two distinct members.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html","title":"SynMemberSig","content":"SynMemberSig \n Represents the syntax tree for a member signature (used in signature files, abstract member declarations\n and member constraints) \nSynMemberSig.Range \nRange \nSynMemberSig.Member \nMember \nSynMemberSig.Interface \nInterface \nSynMemberSig.Inherit \nInherit \nSynMemberSig.ValField \nValField \nSynMemberSig.NestedType \nNestedType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html#Range","title":"SynMemberSig.Range","content":"SynMemberSig.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html#Member","title":"SynMemberSig.Member","content":"SynMemberSig.Member \nMember \n A member definition in a type in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html#Interface","title":"SynMemberSig.Interface","content":"SynMemberSig.Interface \nInterface \n An interface definition in a type in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html#Inherit","title":"SynMemberSig.Inherit","content":"SynMemberSig.Inherit \nInherit \n An \u0027inherit\u0027 definition in a type in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html#ValField","title":"SynMemberSig.ValField","content":"SynMemberSig.ValField \nValField \n A \u0027val\u0027 definition in a type in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmembersig.html#NestedType","title":"SynMemberSig.NestedType","content":"SynMemberSig.NestedType \nNestedType \n A nested type definition in a signature file (an unimplemented feature)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html","title":"SynModuleDecl","content":"SynModuleDecl \n Represents a definition within a module \nSynModuleDecl.Range \nRange \nSynModuleDecl.ModuleAbbrev \nModuleAbbrev \nSynModuleDecl.NestedModule \nNestedModule \nSynModuleDecl.Let \nLet \nSynModuleDecl.Expr \nExpr \nSynModuleDecl.Types \nTypes \nSynModuleDecl.Exception \nException \nSynModuleDecl.Open \nOpen \nSynModuleDecl.Attributes \nAttributes \nSynModuleDecl.HashDirective \nHashDirective \nSynModuleDecl.NamespaceFragment \nNamespaceFragment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Range","title":"SynModuleDecl.Range","content":"SynModuleDecl.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#ModuleAbbrev","title":"SynModuleDecl.ModuleAbbrev","content":"SynModuleDecl.ModuleAbbrev \nModuleAbbrev \n A module abbreviation definition \u0027module X = A.B.C\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#NestedModule","title":"SynModuleDecl.NestedModule","content":"SynModuleDecl.NestedModule \nNestedModule \n A nested module definition \u0027module X = ...\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Let","title":"SynModuleDecl.Let","content":"SynModuleDecl.Let \nLet \n A \u0027let\u0027 definition within a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Expr","title":"SynModuleDecl.Expr","content":"SynModuleDecl.Expr \nExpr \n An \u0027expr\u0027 within a module.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Types","title":"SynModuleDecl.Types","content":"SynModuleDecl.Types \nTypes \n One or more \u0027type\u0027 definitions within a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Exception","title":"SynModuleDecl.Exception","content":"SynModuleDecl.Exception \nException \n An \u0027exception\u0027 definition within a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Open","title":"SynModuleDecl.Open","content":"SynModuleDecl.Open \nOpen \n An \u0027open\u0027 definition within a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#Attributes","title":"SynModuleDecl.Attributes","content":"SynModuleDecl.Attributes \nAttributes \n An attribute definition within a module, for assembly and .NET module attributes","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#HashDirective","title":"SynModuleDecl.HashDirective","content":"SynModuleDecl.HashDirective \nHashDirective \n A hash directive within a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduledecl.html#NamespaceFragment","title":"SynModuleDecl.NamespaceFragment","content":"SynModuleDecl.NamespaceFragment \nNamespaceFragment \n A namespace fragment within a module","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespace.html","title":"SynModuleOrNamespace","content":"SynModuleOrNamespace \n Represents the definition of a module or namespace \nSynModuleOrNamespace.Range \nRange \nSynModuleOrNamespace.SynModuleOrNamespace \nSynModuleOrNamespace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespace.html#Range","title":"SynModuleOrNamespace.Range","content":"SynModuleOrNamespace.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespace.html#SynModuleOrNamespace","title":"SynModuleOrNamespace.SynModuleOrNamespace","content":"SynModuleOrNamespace.SynModuleOrNamespace \nSynModuleOrNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html","title":"SynModuleOrNamespaceKind","content":"SynModuleOrNamespaceKind \n Represents the kind of a module or namespace definition \nSynModuleOrNamespaceKind.IsModule \nIsModule \nSynModuleOrNamespaceKind.NamedModule \nNamedModule \nSynModuleOrNamespaceKind.AnonModule \nAnonModule \nSynModuleOrNamespaceKind.DeclaredNamespace \nDeclaredNamespace \nSynModuleOrNamespaceKind.GlobalNamespace \nGlobalNamespace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html#IsModule","title":"SynModuleOrNamespaceKind.IsModule","content":"SynModuleOrNamespaceKind.IsModule \nIsModule \n Indicates if this is a module definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html#NamedModule","title":"SynModuleOrNamespaceKind.NamedModule","content":"SynModuleOrNamespaceKind.NamedModule \nNamedModule \n A module is explicitly named \u0027module N\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html#AnonModule","title":"SynModuleOrNamespaceKind.AnonModule","content":"SynModuleOrNamespaceKind.AnonModule \nAnonModule \n A module is anonymously named, e.g. a script","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html#DeclaredNamespace","title":"SynModuleOrNamespaceKind.DeclaredNamespace","content":"SynModuleOrNamespaceKind.DeclaredNamespace \nDeclaredNamespace \n A namespace is explicitly declared","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html#GlobalNamespace","title":"SynModuleOrNamespaceKind.GlobalNamespace","content":"SynModuleOrNamespaceKind.GlobalNamespace \nGlobalNamespace \n A namespace is declared \u0027global\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacesig.html","title":"SynModuleOrNamespaceSig","content":"SynModuleOrNamespaceSig \n Represents the definition of a module or namespace in a signature file \nSynModuleOrNamespaceSig.Range \nRange \nSynModuleOrNamespaceSig.SynModuleOrNamespaceSig \nSynModuleOrNamespaceSig","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacesig.html#Range","title":"SynModuleOrNamespaceSig.Range","content":"SynModuleOrNamespaceSig.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmoduleornamespacesig.html#SynModuleOrNamespaceSig","title":"SynModuleOrNamespaceSig.SynModuleOrNamespaceSig","content":"SynModuleOrNamespaceSig.SynModuleOrNamespaceSig \nSynModuleOrNamespaceSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html","title":"SynModuleSigDecl","content":"SynModuleSigDecl \n Represents a definition within a module or namespace in a signature file \nSynModuleSigDecl.Range \nRange \nSynModuleSigDecl.ModuleAbbrev \nModuleAbbrev \nSynModuleSigDecl.NestedModule \nNestedModule \nSynModuleSigDecl.Val \nVal \nSynModuleSigDecl.Types \nTypes \nSynModuleSigDecl.Exception \nException \nSynModuleSigDecl.Open \nOpen \nSynModuleSigDecl.HashDirective \nHashDirective \nSynModuleSigDecl.NamespaceFragment \nNamespaceFragment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#Range","title":"SynModuleSigDecl.Range","content":"SynModuleSigDecl.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#ModuleAbbrev","title":"SynModuleSigDecl.ModuleAbbrev","content":"SynModuleSigDecl.ModuleAbbrev \nModuleAbbrev \n A module abbreviation definition within a module or namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#NestedModule","title":"SynModuleSigDecl.NestedModule","content":"SynModuleSigDecl.NestedModule \nNestedModule \n A nested module definition within a module or namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#Val","title":"SynModuleSigDecl.Val","content":"SynModuleSigDecl.Val \nVal \n A \u0027val\u0027 definition within a module or namespace in a signature file, corresponding\n to a \u0027let\u0027 definition in the implementation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#Types","title":"SynModuleSigDecl.Types","content":"SynModuleSigDecl.Types \nTypes \n A set of one or more type definitions within a module or namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#Exception","title":"SynModuleSigDecl.Exception","content":"SynModuleSigDecl.Exception \nException \n An exception definition within a module or namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#Open","title":"SynModuleSigDecl.Open","content":"SynModuleSigDecl.Open \nOpen \n An \u0027open\u0027 definition within a module or namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#HashDirective","title":"SynModuleSigDecl.HashDirective","content":"SynModuleSigDecl.HashDirective \nHashDirective \n A hash directive within a module or namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synmodulesigdecl.html#NamespaceFragment","title":"SynModuleSigDecl.NamespaceFragment","content":"SynModuleSigDecl.NamespaceFragment \nNamespaceFragment \n A namespace fragment within a namespace in a signature file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synopendecltarget.html","title":"SynOpenDeclTarget","content":"SynOpenDeclTarget \n Represents the target of the open declaration \nSynOpenDeclTarget.Range \nRange \nSynOpenDeclTarget.ModuleOrNamespace \nModuleOrNamespace \nSynOpenDeclTarget.Type \nType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synopendecltarget.html#Range","title":"SynOpenDeclTarget.Range","content":"SynOpenDeclTarget.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synopendecltarget.html#ModuleOrNamespace","title":"SynOpenDeclTarget.ModuleOrNamespace","content":"SynOpenDeclTarget.ModuleOrNamespace \nModuleOrNamespace \n A \u0027open\u0027 declaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synopendecltarget.html#Type","title":"SynOpenDeclTarget.Type","content":"SynOpenDeclTarget.Type \nType \n A \u0027open type\u0027 declaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html","title":"SynPat","content":"SynPat \n Represents a syntax tree for an F# pattern \nSynPat.Range \nRange \nSynPat.Const \nConst \nSynPat.Wild \nWild \nSynPat.Named \nNamed \nSynPat.Typed \nTyped \nSynPat.Attrib \nAttrib \nSynPat.Or \nOr \nSynPat.ListCons \nListCons \nSynPat.Ands \nAnds \nSynPat.As \nAs \nSynPat.LongIdent \nLongIdent \nSynPat.Tuple \nTuple \nSynPat.Paren \nParen \nSynPat.ArrayOrList \nArrayOrList \nSynPat.Record \nRecord \nSynPat.Null \nNull \nSynPat.OptionalVal \nOptionalVal \nSynPat.IsInst \nIsInst \nSynPat.QuoteExpr \nQuoteExpr \nSynPat.InstanceMember \nInstanceMember \nSynPat.FromParseError \nFromParseError","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Range","title":"SynPat.Range","content":"SynPat.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Const","title":"SynPat.Const","content":"SynPat.Const \nConst \n A constant in a pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Wild","title":"SynPat.Wild","content":"SynPat.Wild \nWild \n A wildcard \u0027_\u0027 in a pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Named","title":"SynPat.Named","content":"SynPat.Named \nNamed \n A name pattern \u0027ident\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Typed","title":"SynPat.Typed","content":"SynPat.Typed \nTyped \n A typed pattern \u0027pat : type\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Attrib","title":"SynPat.Attrib","content":"SynPat.Attrib \nAttrib \n An attributed pattern, used in argument or declaration position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Or","title":"SynPat.Or","content":"SynPat.Or \nOr \n A disjunctive pattern \u0027pat1 | pat2\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#ListCons","title":"SynPat.ListCons","content":"SynPat.ListCons \nListCons \n A conjunctive pattern \u0027pat1 :: pat2\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Ands","title":"SynPat.Ands","content":"SynPat.Ands \nAnds \n A conjunctive pattern \u0027pat1 \u0026 pat2\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#As","title":"SynPat.As","content":"SynPat.As \nAs \n A conjunctive pattern \u0027pat1 as pat2\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#LongIdent","title":"SynPat.LongIdent","content":"SynPat.LongIdent \nLongIdent \n A long identifier pattern possibly with argument patterns","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Tuple","title":"SynPat.Tuple","content":"SynPat.Tuple \nTuple \n A tuple pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Paren","title":"SynPat.Paren","content":"SynPat.Paren \nParen \n A parenthesized pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#ArrayOrList","title":"SynPat.ArrayOrList","content":"SynPat.ArrayOrList \nArrayOrList \n An array or a list as a pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Record","title":"SynPat.Record","content":"SynPat.Record \nRecord \n A record pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#Null","title":"SynPat.Null","content":"SynPat.Null \nNull \n The \u0027null\u0027 pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#OptionalVal","title":"SynPat.OptionalVal","content":"SynPat.OptionalVal \nOptionalVal \n \u0027?id\u0027 -- for optional argument names","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#IsInst","title":"SynPat.IsInst","content":"SynPat.IsInst \nIsInst \n A type test pattern \u0027:? type \u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#QuoteExpr","title":"SynPat.QuoteExpr","content":"SynPat.QuoteExpr \nQuoteExpr \n \u0026lt;@ expr @\u0026gt;, used for active pattern arguments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#InstanceMember","title":"SynPat.InstanceMember","content":"SynPat.InstanceMember \nInstanceMember \n Used internally in the type checker","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synpat.html#FromParseError","title":"SynPat.FromParseError","content":"SynPat.FromParseError \nFromParseError \n A pattern arising from a parse error","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synrationalconst.html","title":"SynRationalConst","content":"SynRationalConst \n Represents an unchecked syntax tree of F# unit of measure exponents. \nSynRationalConst.Integer \nInteger \nSynRationalConst.Rational \nRational \nSynRationalConst.Negate \nNegate \nSynRationalConst.Paren \nParen","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synrationalconst.html#Integer","title":"SynRationalConst.Integer","content":"SynRationalConst.Integer \nInteger \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synrationalconst.html#Rational","title":"SynRationalConst.Rational","content":"SynRationalConst.Rational \nRational \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synrationalconst.html#Negate","title":"SynRationalConst.Negate","content":"SynRationalConst.Negate \nNegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synrationalconst.html#Paren","title":"SynRationalConst.Paren","content":"SynRationalConst.Paren \nParen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synreturninfo.html","title":"SynReturnInfo","content":"SynReturnInfo \n Represents the syntactic elements associated with the \u0022return\u0022 of a function or method. \nSynReturnInfo.Range \nRange \nSynReturnInfo.SynReturnInfo \nSynReturnInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synreturninfo.html#Range","title":"SynReturnInfo.Range","content":"SynReturnInfo.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synreturninfo.html#SynReturnInfo","title":"SynReturnInfo.SynReturnInfo","content":"SynReturnInfo.SynReturnInfo \nSynReturnInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepat.html","title":"SynSimplePat","content":"SynSimplePat \n Represents a syntax tree for simple F# patterns \nSynSimplePat.Range \nRange \nSynSimplePat.Id \nId \nSynSimplePat.Typed \nTyped \nSynSimplePat.Attrib \nAttrib","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepat.html#Range","title":"SynSimplePat.Range","content":"SynSimplePat.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepat.html#Id","title":"SynSimplePat.Id","content":"SynSimplePat.Id \nId \n\u003Cpre\u003E Indicates a simple pattern variable.\n\n altNameRefCell:\n Normally \u0027None\u0027 except for some compiler-generated variables in desugaring pattern matching.\n Pattern processing sets this reference for hidden variable introduced\n by desugaring pattern matching in arguments. The info indicates an\n alternative (compiler generated) identifier to be used because the\n name of the identifier is already bound.\n\n isCompilerGenerated: true if a compiler generated name\n isThisVal: true if \u0027this\u0027 variable in member\n isOptional: true if a \u0027?\u0027 is in front of the name\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepat.html#Typed","title":"SynSimplePat.Typed","content":"SynSimplePat.Typed \nTyped \n A type annotated simple pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepat.html#Attrib","title":"SynSimplePat.Attrib","content":"SynSimplePat.Attrib \nAttrib \n An attributed simple pattern","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepatalternativeidinfo.html","title":"SynSimplePatAlternativeIdInfo","content":"SynSimplePatAlternativeIdInfo \n Represents the alternative identifier for a simple pattern \nSynSimplePatAlternativeIdInfo.Undecided \nUndecided \nSynSimplePatAlternativeIdInfo.Decided \nDecided","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepatalternativeidinfo.html#Undecided","title":"SynSimplePatAlternativeIdInfo.Undecided","content":"SynSimplePatAlternativeIdInfo.Undecided \nUndecided \n We have not decided to use an alternative name in the pattern and related expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepatalternativeidinfo.html#Decided","title":"SynSimplePatAlternativeIdInfo.Decided","content":"SynSimplePatAlternativeIdInfo.Decided \nDecided \n We have decided to use an alternative name in the pattern and related expression","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepats.html","title":"SynSimplePats","content":"SynSimplePats \n Represents a simple set of variable bindings a, (a, b) or (a: Type, b: Type) at a lambda,\n function definition or other binding point, after the elimination of pattern matching\n from the construct, e.g. after changing a \u0022function pat1 -\u003E rule1 | ...\u0022 to a\n \u0022fun v -\u003E match v with ...\u0022 \nSynSimplePats.Range \nRange \nSynSimplePats.SimplePats \nSimplePats","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepats.html#Range","title":"SynSimplePats.Range","content":"SynSimplePats.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synsimplepats.html#SimplePats","title":"SynSimplePats.SimplePats","content":"SynSimplePats.SimplePats \nSimplePats \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstaticoptimizationconstraint.html","title":"SynStaticOptimizationConstraint","content":"SynStaticOptimizationConstraint \n Represents a syntax tree for a static optimization constraint in the F# core library \nSynStaticOptimizationConstraint.WhenTyparTyconEqualsTycon \nWhenTyparTyconEqualsTycon \nSynStaticOptimizationConstraint.WhenTyparIsStruct \nWhenTyparIsStruct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstaticoptimizationconstraint.html#WhenTyparTyconEqualsTycon","title":"SynStaticOptimizationConstraint.WhenTyparTyconEqualsTycon","content":"SynStaticOptimizationConstraint.WhenTyparTyconEqualsTycon \nWhenTyparTyconEqualsTycon \n A static optimization conditional that activates for a particular type instantiation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstaticoptimizationconstraint.html#WhenTyparIsStruct","title":"SynStaticOptimizationConstraint.WhenTyparIsStruct","content":"SynStaticOptimizationConstraint.WhenTyparIsStruct \nWhenTyparIsStruct \n A static optimization conditional that activates for a struct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstringkind.html","title":"SynStringKind","content":"SynStringKind \n Indicate if the string had a special format \nSynStringKind.Regular \nRegular \nSynStringKind.Verbatim \nVerbatim \nSynStringKind.TripleQuote \nTripleQuote","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstringkind.html#Regular","title":"SynStringKind.Regular","content":"SynStringKind.Regular \nRegular \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstringkind.html#Verbatim","title":"SynStringKind.Verbatim","content":"SynStringKind.Verbatim \nVerbatim \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synstringkind.html#TripleQuote","title":"SynStringKind.TripleQuote","content":"SynStringKind.TripleQuote \nTripleQuote \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntupletypesegment.html","title":"SynTupleTypeSegment","content":"SynTupleTypeSegment \n \nSynTupleTypeSegment.Range \nRange \nSynTupleTypeSegment.Type \nType \nSynTupleTypeSegment.Star \nStar \nSynTupleTypeSegment.Slash \nSlash","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntupletypesegment.html#Range","title":"SynTupleTypeSegment.Range","content":"SynTupleTypeSegment.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntupletypesegment.html#Type","title":"SynTupleTypeSegment.Type","content":"SynTupleTypeSegment.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntupletypesegment.html#Star","title":"SynTupleTypeSegment.Star","content":"SynTupleTypeSegment.Star \nStar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntupletypesegment.html#Slash","title":"SynTupleTypeSegment.Slash","content":"SynTupleTypeSegment.Slash \nSlash \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypar.html","title":"SynTypar","content":"SynTypar \n Represents a syntactic type parameter \nSynTypar.Range \nRange \nSynTypar.SynTypar \nSynTypar","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypar.html#Range","title":"SynTypar.Range","content":"SynTypar.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypar.html#SynTypar","title":"SynTypar.SynTypar","content":"SynTypar.SynTypar \nSynTypar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecl.html","title":"SynTyparDecl","content":"SynTyparDecl \n Represents the explicit declaration of a type parameter \nSynTyparDecl.SynTyparDecl \nSynTyparDecl","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecl.html#SynTyparDecl","title":"SynTyparDecl.SynTyparDecl","content":"SynTyparDecl.SynTyparDecl \nSynTyparDecl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html","title":"SynTyparDecls","content":"SynTyparDecls \n List of type parameter declarations with optional type constraints,\n enclosed in \u0060\u003C ... \u003E\u0060 (postfix) or \u0060( ... )\u0060 (prefix), or a single prefix parameter. \nSynTyparDecls.Range \nRange \nSynTyparDecls.Constraints \nConstraints \nSynTyparDecls.TyparDecls \nTyparDecls \nSynTyparDecls.PostfixList \nPostfixList \nSynTyparDecls.PrefixList \nPrefixList \nSynTyparDecls.SinglePrefix \nSinglePrefix","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html#Range","title":"SynTyparDecls.Range","content":"SynTyparDecls.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html#Constraints","title":"SynTyparDecls.Constraints","content":"SynTyparDecls.Constraints \nConstraints \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html#TyparDecls","title":"SynTyparDecls.TyparDecls","content":"SynTyparDecls.TyparDecls \nTyparDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html#PostfixList","title":"SynTyparDecls.PostfixList","content":"SynTyparDecls.PostfixList \nPostfixList \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html#PrefixList","title":"SynTyparDecls.PrefixList","content":"SynTyparDecls.PrefixList \nPrefixList \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypardecls.html#SinglePrefix","title":"SynTyparDecls.SinglePrefix","content":"SynTyparDecls.SinglePrefix \nSinglePrefix \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html","title":"SynType","content":"SynType \n Represents a syntax tree for F# types \nSynType.Range \nRange \nSynType.LongIdent \nLongIdent \nSynType.App \nApp \nSynType.LongIdentApp \nLongIdentApp \nSynType.Tuple \nTuple \nSynType.AnonRecd \nAnonRecd \nSynType.Array \nArray \nSynType.Fun \nFun \nSynType.Var \nVar \nSynType.Anon \nAnon \nSynType.WithGlobalConstraints \nWithGlobalConstraints \nSynType.HashConstraint \nHashConstraint \nSynType.MeasurePower \nMeasurePower \nSynType.StaticConstant \nStaticConstant \nSynType.StaticConstantExpr \nStaticConstantExpr \nSynType.StaticConstantNamed \nStaticConstantNamed \nSynType.Paren \nParen \nSynType.SignatureParameter \nSignatureParameter \nSynType.Or \nOr \nSynType.FromParseError \nFromParseError \nSynType.Intersection \nIntersection","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Range","title":"SynType.Range","content":"SynType.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#LongIdent","title":"SynType.LongIdent","content":"SynType.LongIdent \nLongIdent \n F# syntax: A.B.C","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#App","title":"SynType.App","content":"SynType.App \nApp \n\u003Cpre\u003E F# syntax: type\u003Ctype, ..., type\u003E or type type or (type, ..., type) type\n isPostfix: indicates a postfix type application e.g. \u0022int list\u0022 or \u0022(int, string) dict\u0022\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#LongIdentApp","title":"SynType.LongIdentApp","content":"SynType.LongIdentApp \nLongIdentApp \n F# syntax: type.A.B.C\u003Ctype, ..., type\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Tuple","title":"SynType.Tuple","content":"SynType.Tuple \nTuple \n F# syntax: type * ... * type\n F# syntax: struct (type * ... * type)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#AnonRecd","title":"SynType.AnonRecd","content":"SynType.AnonRecd \nAnonRecd \n F# syntax: {| id: type; ...; id: type |}\n F# syntax: struct {| id: type; ...; id: type |}","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Array","title":"SynType.Array","content":"SynType.Array \nArray \n F# syntax: type[]","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Fun","title":"SynType.Fun","content":"SynType.Fun \nFun \n F# syntax: type -\u003E type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Var","title":"SynType.Var","content":"SynType.Var \nVar \n F# syntax: \u0027Var","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Anon","title":"SynType.Anon","content":"SynType.Anon \nAnon \n F# syntax: _","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#WithGlobalConstraints","title":"SynType.WithGlobalConstraints","content":"SynType.WithGlobalConstraints \nWithGlobalConstraints \n F# syntax: typ with constraints","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#HashConstraint","title":"SynType.HashConstraint","content":"SynType.HashConstraint \nHashConstraint \n F# syntax: #type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#MeasurePower","title":"SynType.MeasurePower","content":"SynType.MeasurePower \nMeasurePower \n F# syntax: for units of measure e.g. m^3, kg^1/2","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#StaticConstant","title":"SynType.StaticConstant","content":"SynType.StaticConstant \nStaticConstant \n F# syntax: 1, \u0022abc\u0022 etc, used in parameters to type providers\n For the dimensionless units i.e. 1, and static parameters to provided types","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#StaticConstantExpr","title":"SynType.StaticConstantExpr","content":"SynType.StaticConstantExpr \nStaticConstantExpr \n F# syntax: const expr, used in static parameters to type providers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#StaticConstantNamed","title":"SynType.StaticConstantNamed","content":"SynType.StaticConstantNamed \nStaticConstantNamed \n F# syntax: ident=1 etc., used in static parameters to type providers","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Paren","title":"SynType.Paren","content":"SynType.Paren \nParen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#SignatureParameter","title":"SynType.SignatureParameter","content":"SynType.SignatureParameter \nSignatureParameter \n F# syntax: a: b, used in signatures and type annotations","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Or","title":"SynType.Or","content":"SynType.Or \nOr \n F# syntax: ^a or ^b, used in trait calls","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#FromParseError","title":"SynType.FromParseError","content":"SynType.FromParseError \nFromParseError \n A type arising from a parse error","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntype.html#Intersection","title":"SynType.Intersection","content":"SynType.Intersection \nIntersection \n F# syntax: x: #I1 \u0026 #I2\n F# syntax: x: \u0027t \u0026 #I1 \u0026 #I2\n Shorthand for x: \u0027t when \u0027t :\u003E I1 and \u0027t :\u003E I2","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html","title":"SynTypeConstraint","content":"SynTypeConstraint \n The unchecked abstract syntax tree of F# type constraints \nSynTypeConstraint.Range \nRange \nSynTypeConstraint.WhereTyparIsValueType \nWhereTyparIsValueType \nSynTypeConstraint.WhereTyparIsReferenceType \nWhereTyparIsReferenceType \nSynTypeConstraint.WhereTyparIsUnmanaged \nWhereTyparIsUnmanaged \nSynTypeConstraint.WhereTyparSupportsNull \nWhereTyparSupportsNull \nSynTypeConstraint.WhereTyparIsComparable \nWhereTyparIsComparable \nSynTypeConstraint.WhereTyparIsEquatable \nWhereTyparIsEquatable \nSynTypeConstraint.WhereTyparDefaultsToType \nWhereTyparDefaultsToType \nSynTypeConstraint.WhereTyparSubtypeOfType \nWhereTyparSubtypeOfType \nSynTypeConstraint.WhereTyparSupportsMember \nWhereTyparSupportsMember \nSynTypeConstraint.WhereTyparIsEnum \nWhereTyparIsEnum \nSynTypeConstraint.WhereTyparIsDelegate \nWhereTyparIsDelegate \nSynTypeConstraint.WhereSelfConstrained \nWhereSelfConstrained","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#Range","title":"SynTypeConstraint.Range","content":"SynTypeConstraint.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsValueType","title":"SynTypeConstraint.WhereTyparIsValueType","content":"SynTypeConstraint.WhereTyparIsValueType \nWhereTyparIsValueType \n F# syntax: is \u0027typar: struct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsReferenceType","title":"SynTypeConstraint.WhereTyparIsReferenceType","content":"SynTypeConstraint.WhereTyparIsReferenceType \nWhereTyparIsReferenceType \n F# syntax: is \u0027typar: not struct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsUnmanaged","title":"SynTypeConstraint.WhereTyparIsUnmanaged","content":"SynTypeConstraint.WhereTyparIsUnmanaged \nWhereTyparIsUnmanaged \n F# syntax is \u0027typar: unmanaged","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparSupportsNull","title":"SynTypeConstraint.WhereTyparSupportsNull","content":"SynTypeConstraint.WhereTyparSupportsNull \nWhereTyparSupportsNull \n F# syntax is \u0027typar: null","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsComparable","title":"SynTypeConstraint.WhereTyparIsComparable","content":"SynTypeConstraint.WhereTyparIsComparable \nWhereTyparIsComparable \n F# syntax is \u0027typar: comparison","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsEquatable","title":"SynTypeConstraint.WhereTyparIsEquatable","content":"SynTypeConstraint.WhereTyparIsEquatable \nWhereTyparIsEquatable \n F# syntax is \u0027typar: equality","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparDefaultsToType","title":"SynTypeConstraint.WhereTyparDefaultsToType","content":"SynTypeConstraint.WhereTyparDefaultsToType \nWhereTyparDefaultsToType \n F# syntax is default ^T: type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparSubtypeOfType","title":"SynTypeConstraint.WhereTyparSubtypeOfType","content":"SynTypeConstraint.WhereTyparSubtypeOfType \nWhereTyparSubtypeOfType \n F# syntax is \u0027typar :\u003E type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparSupportsMember","title":"SynTypeConstraint.WhereTyparSupportsMember","content":"SynTypeConstraint.WhereTyparSupportsMember \nWhereTyparSupportsMember \n F# syntax is ^T: (static member MemberName: ^T * int -\u003E ^T)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsEnum","title":"SynTypeConstraint.WhereTyparIsEnum","content":"SynTypeConstraint.WhereTyparIsEnum \nWhereTyparIsEnum \n F# syntax is \u0027typar: enum\u003C\u0027UnderlyingType\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereTyparIsDelegate","title":"SynTypeConstraint.WhereTyparIsDelegate","content":"SynTypeConstraint.WhereTyparIsDelegate \nWhereTyparIsDelegate \n F# syntax is \u0027typar: delegate\u003C\u0027Args, unit\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypeconstraint.html#WhereSelfConstrained","title":"SynTypeConstraint.WhereSelfConstrained","content":"SynTypeConstraint.WhereSelfConstrained \nWhereSelfConstrained \n F# syntax is SomeThing\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefn.html","title":"SynTypeDefn","content":"SynTypeDefn \n Represents a type or exception declaration \u0027type C = ... \u0027 plus\n any additional member definitions for the type \nSynTypeDefn.Range \nRange \nSynTypeDefn.SynTypeDefn \nSynTypeDefn","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefn.html#Range","title":"SynTypeDefn.Range","content":"SynTypeDefn.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefn.html#SynTypeDefn","title":"SynTypeDefn.SynTypeDefn","content":"SynTypeDefn.SynTypeDefn \nSynTypeDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html","title":"SynTypeDefnKind","content":"SynTypeDefnKind \n Represents the kind of a type definition whether explicit or inferred \nSynTypeDefnKind.Unspecified \nUnspecified \nSynTypeDefnKind.Class \nClass \nSynTypeDefnKind.Interface \nInterface \nSynTypeDefnKind.Struct \nStruct \nSynTypeDefnKind.Record \nRecord \nSynTypeDefnKind.Union \nUnion \nSynTypeDefnKind.Abbrev \nAbbrev \nSynTypeDefnKind.Opaque \nOpaque \nSynTypeDefnKind.Augmentation \nAugmentation \nSynTypeDefnKind.IL \nIL \nSynTypeDefnKind.Delegate \nDelegate","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Unspecified","title":"SynTypeDefnKind.Unspecified","content":"SynTypeDefnKind.Unspecified \nUnspecified \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Class","title":"SynTypeDefnKind.Class","content":"SynTypeDefnKind.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Interface","title":"SynTypeDefnKind.Interface","content":"SynTypeDefnKind.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Struct","title":"SynTypeDefnKind.Struct","content":"SynTypeDefnKind.Struct \nStruct \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Record","title":"SynTypeDefnKind.Record","content":"SynTypeDefnKind.Record \nRecord \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Union","title":"SynTypeDefnKind.Union","content":"SynTypeDefnKind.Union \nUnion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Abbrev","title":"SynTypeDefnKind.Abbrev","content":"SynTypeDefnKind.Abbrev \nAbbrev \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Opaque","title":"SynTypeDefnKind.Opaque","content":"SynTypeDefnKind.Opaque \nOpaque \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Augmentation","title":"SynTypeDefnKind.Augmentation","content":"SynTypeDefnKind.Augmentation \nAugmentation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#IL","title":"SynTypeDefnKind.IL","content":"SynTypeDefnKind.IL \nIL \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnkind.html#Delegate","title":"SynTypeDefnKind.Delegate","content":"SynTypeDefnKind.Delegate \nDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnrepr.html","title":"SynTypeDefnRepr","content":"SynTypeDefnRepr \n Represents the right hand side of a type or exception declaration \u0027type C = ... \u0027 plus\n any additional member definitions for the type \nSynTypeDefnRepr.Range \nRange \nSynTypeDefnRepr.ObjectModel \nObjectModel \nSynTypeDefnRepr.Simple \nSimple \nSynTypeDefnRepr.Exception \nException","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnrepr.html#Range","title":"SynTypeDefnRepr.Range","content":"SynTypeDefnRepr.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnrepr.html#ObjectModel","title":"SynTypeDefnRepr.ObjectModel","content":"SynTypeDefnRepr.ObjectModel \nObjectModel \n An object model type definition (class or interface)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnrepr.html#Simple","title":"SynTypeDefnRepr.Simple","content":"SynTypeDefnRepr.Simple \nSimple \n A simple type definition (record, union, abbreviation)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnrepr.html#Exception","title":"SynTypeDefnRepr.Exception","content":"SynTypeDefnRepr.Exception \nException \n An exception definition","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsig.html","title":"SynTypeDefnSig","content":"SynTypeDefnSig \n Represents the syntax tree for a type definition in a signature \nSynTypeDefnSig.Range \nRange \nSynTypeDefnSig.SynTypeDefnSig \nSynTypeDefnSig","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsig.html#Range","title":"SynTypeDefnSig.Range","content":"SynTypeDefnSig.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsig.html#SynTypeDefnSig","title":"SynTypeDefnSig.SynTypeDefnSig","content":"SynTypeDefnSig.SynTypeDefnSig \nSynTypeDefnSig \n The information for a type definition in a signature","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html","title":"SynTypeDefnSigRepr","content":"SynTypeDefnSigRepr \n Represents the syntax tree for the right-hand-side of a type definition in a signature.\n Note: in practice, using a discriminated union to make a distinction between\n \u0022simple\u0022 types and \u0022object oriented\u0022 types is not particularly useful. \nSynTypeDefnSigRepr.Range \nRange \nSynTypeDefnSigRepr.ObjectModel \nObjectModel \nSynTypeDefnSigRepr.Simple \nSimple \nSynTypeDefnSigRepr.Exception \nException","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html#Range","title":"SynTypeDefnSigRepr.Range","content":"SynTypeDefnSigRepr.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html#ObjectModel","title":"SynTypeDefnSigRepr.ObjectModel","content":"SynTypeDefnSigRepr.ObjectModel \nObjectModel \n Indicates the right right-hand-side is a class, struct, interface or other object-model type","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html#Simple","title":"SynTypeDefnSigRepr.Simple","content":"SynTypeDefnSigRepr.Simple \nSimple \n Indicates the right right-hand-side is a record, union or other simple type.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html#Exception","title":"SynTypeDefnSigRepr.Exception","content":"SynTypeDefnSigRepr.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html","title":"SynTypeDefnSimpleRepr","content":"SynTypeDefnSimpleRepr \n Represents the syntax tree for the core of a simple type definition, in either signature\n or implementation. \nSynTypeDefnSimpleRepr.Range \nRange \nSynTypeDefnSimpleRepr.Union \nUnion \nSynTypeDefnSimpleRepr.Enum \nEnum \nSynTypeDefnSimpleRepr.Record \nRecord \nSynTypeDefnSimpleRepr.General \nGeneral \nSynTypeDefnSimpleRepr.LibraryOnlyILAssembly \nLibraryOnlyILAssembly \nSynTypeDefnSimpleRepr.TypeAbbrev \nTypeAbbrev \nSynTypeDefnSimpleRepr.None \nNone \nSynTypeDefnSimpleRepr.Exception \nException","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#Range","title":"SynTypeDefnSimpleRepr.Range","content":"SynTypeDefnSimpleRepr.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#Union","title":"SynTypeDefnSimpleRepr.Union","content":"SynTypeDefnSimpleRepr.Union \nUnion \n A union type definition, type X = A | B","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#Enum","title":"SynTypeDefnSimpleRepr.Enum","content":"SynTypeDefnSimpleRepr.Enum \nEnum \n An enum type definition, type X = A = 1 | B = 2","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#Record","title":"SynTypeDefnSimpleRepr.Record","content":"SynTypeDefnSimpleRepr.Record \nRecord \n A record type definition, type X = { A: int; B: int }","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#General","title":"SynTypeDefnSimpleRepr.General","content":"SynTypeDefnSimpleRepr.General \nGeneral \n An object oriented type definition. This is not a parse-tree form, but represents the core\n type representation which the type checker splits out from the \u0022ObjectModel\u0022 cases of type definitions.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#LibraryOnlyILAssembly","title":"SynTypeDefnSimpleRepr.LibraryOnlyILAssembly","content":"SynTypeDefnSimpleRepr.LibraryOnlyILAssembly \nLibraryOnlyILAssembly \n A type defined by using an IL assembly representation. Only used in FSharp.Core.\n\n F# syntax: \u0022type X = (# \u0022...\u0022#)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#TypeAbbrev","title":"SynTypeDefnSimpleRepr.TypeAbbrev","content":"SynTypeDefnSimpleRepr.TypeAbbrev \nTypeAbbrev \n A type abbreviation, \u0022type X = A.B.C\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#None","title":"SynTypeDefnSimpleRepr.None","content":"SynTypeDefnSimpleRepr.None \nNone \n An abstract definition, \u0022type X\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html#Exception","title":"SynTypeDefnSimpleRepr.Exception","content":"SynTypeDefnSimpleRepr.Exception \nException \n An exception definition, \u0022exception E = ...\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synunioncase.html","title":"SynUnionCase","content":"SynUnionCase \n Represents the syntax tree for one case in a union definition. \nSynUnionCase.Range \nRange \nSynUnionCase.SynUnionCase \nSynUnionCase","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synunioncase.html#Range","title":"SynUnionCase.Range","content":"SynUnionCase.Range \nRange \n Gets the syntax range of this construct","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synunioncase.html#SynUnionCase","title":"SynUnionCase.SynUnionCase","content":"SynUnionCase.SynUnionCase \nSynUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synunioncasekind.html","title":"SynUnionCaseKind","content":"SynUnionCaseKind \n Represents the syntax tree for the right-hand-side of union definition, excluding members,\n in either a signature or implementation. \nSynUnionCaseKind.Fields \nFields \nSynUnionCaseKind.FullType \nFullType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synunioncasekind.html#Fields","title":"SynUnionCaseKind.Fields","content":"SynUnionCaseKind.Fields \nFields \n Normal style declaration","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synunioncasekind.html#FullType","title":"SynUnionCaseKind.FullType","content":"SynUnionCaseKind.FullType \nFullType \n Full type spec given by \u0027UnionCase: ty1 * tyN -\u003E rty\u0027. Only used in FSharp.Core, otherwise a warning.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvaldata.html","title":"SynValData","content":"SynValData \n Represents extra information about the declaration of a value \nSynValData.SynValInfo \nSynValInfo \nSynValData.SynValData \nSynValData","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvaldata.html#SynValInfo","title":"SynValData.SynValInfo","content":"SynValData.SynValInfo \nSynValInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvaldata.html#SynValData","title":"SynValData.SynValData","content":"SynValData.SynValData \nSynValData \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalinfo.html","title":"SynValInfo","content":"SynValInfo \n The argument names and other metadata for a member or function \nSynValInfo.CurriedArgInfos \nCurriedArgInfos \nSynValInfo.ArgNames \nArgNames \nSynValInfo.SynValInfo \nSynValInfo","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalinfo.html#CurriedArgInfos","title":"SynValInfo.CurriedArgInfos","content":"SynValInfo.CurriedArgInfos \nCurriedArgInfos \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalinfo.html#ArgNames","title":"SynValInfo.ArgNames","content":"SynValInfo.ArgNames \nArgNames \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalinfo.html#SynValInfo","title":"SynValInfo.SynValInfo","content":"SynValInfo.SynValInfo \nSynValInfo \n SynValInfo(curriedArgInfos, returnInfo)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalsig.html","title":"SynValSig","content":"SynValSig \n Represents the syntax tree for a \u0027val\u0027 definition in an abstract slot or a signature file \nSynValSig.SynInfo \nSynInfo \nSynValSig.RangeOfId \nRangeOfId \nSynValSig.SynType \nSynType \nSynValSig.SynValSig \nSynValSig","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalsig.html#SynInfo","title":"SynValSig.SynInfo","content":"SynValSig.SynInfo \nSynInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalsig.html#RangeOfId","title":"SynValSig.RangeOfId","content":"SynValSig.RangeOfId \nRangeOfId \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalsig.html#SynType","title":"SynValSig.SynType","content":"SynValSig.SynType \nSynType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvalsig.html#SynValSig","title":"SynValSig.SynValSig","content":"SynValSig.SynValSig \nSynValSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvaltypardecls.html","title":"SynValTyparDecls","content":"SynValTyparDecls \n Represents the names and other metadata for the type parameters for a member or function \nSynValTyparDecls.SynValTyparDecls \nSynValTyparDecls","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-synvaltypardecls.html#SynValTyparDecls","title":"SynValTyparDecls.SynValTyparDecls","content":"SynValTyparDecls.SynValTyparDecls \nSynValTyparDecls \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html","title":"SyntaxNode","content":"SyntaxNode \n Used to track route during traversal of syntax using SyntaxTraversal.Traverse \nSyntaxNode.SynPat \nSynPat \nSyntaxNode.SynType \nSynType \nSyntaxNode.SynExpr \nSynExpr \nSyntaxNode.SynModule \nSynModule \nSyntaxNode.SynModuleOrNamespace \nSynModuleOrNamespace \nSyntaxNode.SynTypeDefn \nSynTypeDefn \nSyntaxNode.SynMemberDefn \nSynMemberDefn \nSyntaxNode.SynMatchClause \nSynMatchClause \nSyntaxNode.SynBinding \nSynBinding \nSyntaxNode.SynModuleOrNamespaceSig \nSynModuleOrNamespaceSig \nSyntaxNode.SynModuleSigDecl \nSynModuleSigDecl \nSyntaxNode.SynValSig \nSynValSig \nSyntaxNode.SynTypeDefnSig \nSynTypeDefnSig \nSyntaxNode.SynMemberSig \nSynMemberSig","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynPat","title":"SyntaxNode.SynPat","content":"SyntaxNode.SynPat \nSynPat \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynType","title":"SyntaxNode.SynType","content":"SyntaxNode.SynType \nSynType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynExpr","title":"SyntaxNode.SynExpr","content":"SyntaxNode.SynExpr \nSynExpr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynModule","title":"SyntaxNode.SynModule","content":"SyntaxNode.SynModule \nSynModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynModuleOrNamespace","title":"SyntaxNode.SynModuleOrNamespace","content":"SyntaxNode.SynModuleOrNamespace \nSynModuleOrNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynTypeDefn","title":"SyntaxNode.SynTypeDefn","content":"SyntaxNode.SynTypeDefn \nSynTypeDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynMemberDefn","title":"SyntaxNode.SynMemberDefn","content":"SyntaxNode.SynMemberDefn \nSynMemberDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynMatchClause","title":"SyntaxNode.SynMatchClause","content":"SyntaxNode.SynMatchClause \nSynMatchClause \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynBinding","title":"SyntaxNode.SynBinding","content":"SyntaxNode.SynBinding \nSynBinding \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynModuleOrNamespaceSig","title":"SyntaxNode.SynModuleOrNamespaceSig","content":"SyntaxNode.SynModuleOrNamespaceSig \nSynModuleOrNamespaceSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynModuleSigDecl","title":"SyntaxNode.SynModuleSigDecl","content":"SyntaxNode.SynModuleSigDecl \nSynModuleSigDecl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynValSig","title":"SyntaxNode.SynValSig","content":"SyntaxNode.SynValSig \nSynValSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynTypeDefnSig","title":"SyntaxNode.SynTypeDefnSig","content":"SyntaxNode.SynTypeDefnSig \nSynTypeDefnSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxnode.html#SynMemberSig","title":"SyntaxNode.SynMemberSig","content":"SyntaxNode.SynMemberSig \nSynMemberSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html","title":"SyntaxVisitorBase\u003C\u0027T\u003E","content":"SyntaxVisitorBase\u003C\u0027T\u003E \n \nSyntaxVisitorBase\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitAttributeApplication \nVisitAttributeApplication \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitBinding \nVisitBinding \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitComponentInfo \nVisitComponentInfo \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitEnumDefn \nVisitEnumDefn \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitExpr \nVisitExpr \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitHashDirective \nVisitHashDirective \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitImplicitInherit \nVisitImplicitInherit \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitInheritSynMemberDefn \nVisitInheritSynMemberDefn \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitInterfaceSynMemberDefnType \nVisitInterfaceSynMemberDefnType \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitLetOrUse \nVisitLetOrUse \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitMatchClause \nVisitMatchClause \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleDecl \nVisitModuleDecl \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleOrNamespace \nVisitModuleOrNamespace \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleOrNamespaceSig \nVisitModuleOrNamespaceSig \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleSigDecl \nVisitModuleSigDecl \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitPat \nVisitPat \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitRecordDefn \nVisitRecordDefn \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitRecordField \nVisitRecordField \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitSimplePats \nVisitSimplePats \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitType \nVisitType \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitTypeAbbrev \nVisitTypeAbbrev \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitUnionDefn \nVisitUnionDefn \nSyntaxVisitorBase\u003C\u0027T\u003E.VisitValSig \nVisitValSig","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#\u0060\u0060.ctor\u0060\u0060","title":"SyntaxVisitorBase\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"SyntaxVisitorBase\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitAttributeApplication","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitAttributeApplication","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitAttributeApplication \nVisitAttributeApplication \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitBinding","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitBinding","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitBinding \nVisitBinding \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitComponentInfo","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitComponentInfo","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitComponentInfo \nVisitComponentInfo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitEnumDefn","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitEnumDefn","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitEnumDefn \nVisitEnumDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitExpr","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitExpr","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitExpr \nVisitExpr \n\u003Cpre\u003E Controls the behavior when a SynExpr is reached; it can just do\n defaultTraverse(expr) if you have no special logic for this node, and want the default processing to pick which sub-node to dive deeper into\n or can inject non-default behavior, which might incorporate:\n traverseSynExpr(subExpr) to recurse deeper on some particular sub-expression based on your own logic\n path helps to track AST nodes that were passed during traversal\u003C/pre\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitHashDirective","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitHashDirective","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitHashDirective \nVisitHashDirective \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitImplicitInherit","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitImplicitInherit","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitImplicitInherit \nVisitImplicitInherit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitInheritSynMemberDefn","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitInheritSynMemberDefn","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitInheritSynMemberDefn \nVisitInheritSynMemberDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitInterfaceSynMemberDefnType","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitInterfaceSynMemberDefnType","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitInterfaceSynMemberDefnType \nVisitInterfaceSynMemberDefnType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitLetOrUse","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitLetOrUse","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitLetOrUse \nVisitLetOrUse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitMatchClause","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitMatchClause","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitMatchClause \nVisitMatchClause \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitModuleDecl","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleDecl","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleDecl \nVisitModuleDecl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitModuleOrNamespace","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleOrNamespace","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleOrNamespace \nVisitModuleOrNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitModuleOrNamespaceSig","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleOrNamespaceSig","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleOrNamespaceSig \nVisitModuleOrNamespaceSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitModuleSigDecl","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleSigDecl","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitModuleSigDecl \nVisitModuleSigDecl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitPat","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitPat","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitPat \nVisitPat \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitRecordDefn","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitRecordDefn","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitRecordDefn \nVisitRecordDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitRecordField","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitRecordField","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitRecordField \nVisitRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitSimplePats","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitSimplePats","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitSimplePats \nVisitSimplePats \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitType","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitType","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitType \nVisitType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitTypeAbbrev","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitTypeAbbrev","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitTypeAbbrev \nVisitTypeAbbrev \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitUnionDefn","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitUnionDefn","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitUnionDefn \nVisitUnionDefn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html#VisitValSig","title":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitValSig","content":"SyntaxVisitorBase\u003C\u0027T\u003E.VisitValSig \nVisitValSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-typarstaticreq.html","title":"TyparStaticReq","content":"TyparStaticReq \n Represents whether a type parameter has a static requirement or not (^T or \u0027T) \nTyparStaticReq.None \nNone \nTyparStaticReq.HeadType \nHeadType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-typarstaticreq.html#None","title":"TyparStaticReq.None","content":"TyparStaticReq.None \nNone \n The construct is a normal type inference variable","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntax-typarstaticreq.html#HeadType","title":"TyparStaticReq.HeadType","content":"TyparStaticReq.HeadType \nHeadType \n The construct is a statically inferred type inference variable \u0027^T\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-commenttrivia.html","title":"CommentTrivia","content":"CommentTrivia \n \nCommentTrivia.LineComment \nLineComment \nCommentTrivia.BlockComment \nBlockComment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-commenttrivia.html#LineComment","title":"CommentTrivia.LineComment","content":"CommentTrivia.LineComment \nLineComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-commenttrivia.html#BlockComment","title":"CommentTrivia.BlockComment","content":"CommentTrivia.BlockComment \nBlockComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html","title":"ConditionalDirectiveTrivia","content":"ConditionalDirectiveTrivia \n \nConditionalDirectiveTrivia.If \nIf \nConditionalDirectiveTrivia.Else \nElse \nConditionalDirectiveTrivia.EndIf \nEndIf","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html#If","title":"ConditionalDirectiveTrivia.If","content":"ConditionalDirectiveTrivia.If \nIf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html#Else","title":"ConditionalDirectiveTrivia.Else","content":"ConditionalDirectiveTrivia.Else \nElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html#EndIf","title":"ConditionalDirectiveTrivia.EndIf","content":"ConditionalDirectiveTrivia.EndIf \nEndIf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html","title":"GetSetKeywords","content":"GetSetKeywords \n Represents additional information for \u0060get, set\u0060 syntax \nGetSetKeywords.Range \nRange \nGetSetKeywords.Get \nGet \nGetSetKeywords.Set \nSet \nGetSetKeywords.GetSet \nGetSet","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html#Range","title":"GetSetKeywords.Range","content":"GetSetKeywords.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html#Get","title":"GetSetKeywords.Get","content":"GetSetKeywords.Get \nGet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html#Set","title":"GetSetKeywords.Set","content":"GetSetKeywords.Set \nSet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html#GetSet","title":"GetSetKeywords.GetSet","content":"GetSetKeywords.GetSet \nGetSet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-identtrivia.html","title":"IdentTrivia","content":"IdentTrivia \n \nIdentTrivia.OriginalNotation \nOriginalNotation \nIdentTrivia.OriginalNotationWithParen \nOriginalNotationWithParen \nIdentTrivia.HasParenthesis \nHasParenthesis","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-identtrivia.html#OriginalNotation","title":"IdentTrivia.OriginalNotation","content":"IdentTrivia.OriginalNotation \nOriginalNotation \n The ident originally had a different notation.\n Example: a \u002B b\n The operator ident will be compiled into \u0022op_Addition\u0022, while the original notation was \u0022\u002B\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-identtrivia.html#OriginalNotationWithParen","title":"IdentTrivia.OriginalNotationWithParen","content":"IdentTrivia.OriginalNotationWithParen \nOriginalNotationWithParen \n The ident originally had a different notation and parenthesis\n Example: let (\u003E=\u003E) a b = ...\n The operator ident will be compiled into \u0022op_GreaterEqualsGreater\u0022, while the original notation was \u0022\u003E=\u003E\u0022 and had parenthesis","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-identtrivia.html#HasParenthesis","title":"IdentTrivia.HasParenthesis","content":"IdentTrivia.HasParenthesis \nHasParenthesis \n The ident had parenthesis\n Example: let (|Odd|Even|) = ...\n The active pattern ident will be \u0022|Odd|Even|\u0022, while originally there were parenthesis.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html","title":"IfDirectiveExpression","content":"IfDirectiveExpression \n \nIfDirectiveExpression.And \nAnd \nIfDirectiveExpression.Or \nOr \nIfDirectiveExpression.Not \nNot \nIfDirectiveExpression.Ident \nIdent","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html#And","title":"IfDirectiveExpression.And","content":"IfDirectiveExpression.And \nAnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html#Or","title":"IfDirectiveExpression.Or","content":"IfDirectiveExpression.Or \nOr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html#Not","title":"IfDirectiveExpression.Not","content":"IfDirectiveExpression.Not \nNot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html#Ident","title":"IfDirectiveExpression.Ident","content":"IfDirectiveExpression.Ident \nIdent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-parsedimplfileinputtrivia.html","title":"ParsedImplFileInputTrivia","content":"ParsedImplFileInputTrivia \n Represents additional information for ParsedImplFileInput \nParsedImplFileInputTrivia.ConditionalDirectives \nConditionalDirectives \nParsedImplFileInputTrivia.CodeComments \nCodeComments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-parsedimplfileinputtrivia.html#ConditionalDirectives","title":"ParsedImplFileInputTrivia.ConditionalDirectives","content":"ParsedImplFileInputTrivia.ConditionalDirectives \nConditionalDirectives \n Preprocessor directives of type #if, #else or #endif","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-parsedimplfileinputtrivia.html#CodeComments","title":"ParsedImplFileInputTrivia.CodeComments","content":"ParsedImplFileInputTrivia.CodeComments \nCodeComments \n Represent code comments found in the source file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-parsedsigfileinputtrivia.html","title":"ParsedSigFileInputTrivia","content":"ParsedSigFileInputTrivia \n Represents additional information for ParsedSigFileInputTrivia \nParsedSigFileInputTrivia.ConditionalDirectives \nConditionalDirectives \nParsedSigFileInputTrivia.CodeComments \nCodeComments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-parsedsigfileinputtrivia.html#ConditionalDirectives","title":"ParsedSigFileInputTrivia.ConditionalDirectives","content":"ParsedSigFileInputTrivia.ConditionalDirectives \nConditionalDirectives \n Preprocessor directives of type #if, #else or #endif","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-parsedsigfileinputtrivia.html#CodeComments","title":"ParsedSigFileInputTrivia.CodeComments","content":"ParsedSigFileInputTrivia.CodeComments \nCodeComments \n Represent code comments found in the source file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synargpatsnamepatpairstrivia.html","title":"SynArgPatsNamePatPairsTrivia","content":"SynArgPatsNamePatPairsTrivia \n Represents additional information for SynArgPats.NamePatPairs \nSynArgPatsNamePatPairsTrivia.ParenRange \nParenRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synargpatsnamepatpairstrivia.html#ParenRange","title":"SynArgPatsNamePatPairsTrivia.ParenRange","content":"SynArgPatsNamePatPairsTrivia.ParenRange \nParenRange \n The syntax range from the beginning of the \u0060(\u0060 token till the end of the \u0060)\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingreturninfotrivia.html","title":"SynBindingReturnInfoTrivia","content":"SynBindingReturnInfoTrivia \n Represents additional information for SynBindingReturnInfo \nSynBindingReturnInfoTrivia.ColonRange \nColonRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingreturninfotrivia.html#ColonRange","title":"SynBindingReturnInfoTrivia.ColonRange","content":"SynBindingReturnInfoTrivia.ColonRange \nColonRange \n The syntax range of the \u0060:\u0060 token","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html","title":"SynBindingTrivia","content":"SynBindingTrivia \n Represents additional information for SynBinding \nSynBindingTrivia.Zero \nZero \nSynBindingTrivia.LeadingKeyword \nLeadingKeyword \nSynBindingTrivia.InlineKeyword \nInlineKeyword \nSynBindingTrivia.EqualsRange \nEqualsRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html#Zero","title":"SynBindingTrivia.Zero","content":"SynBindingTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html#LeadingKeyword","title":"SynBindingTrivia.LeadingKeyword","content":"SynBindingTrivia.LeadingKeyword \nLeadingKeyword \n Used leading keyword of SynBinding","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html#InlineKeyword","title":"SynBindingTrivia.InlineKeyword","content":"SynBindingTrivia.InlineKeyword \nInlineKeyword \n The syntax range of the \u0060inline\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html#EqualsRange","title":"SynBindingTrivia.EqualsRange","content":"SynBindingTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synenumcasetrivia.html","title":"SynEnumCaseTrivia","content":"SynEnumCaseTrivia \n Represents additional information for \nSynEnumCaseTrivia.BarRange \nBarRange \nSynEnumCaseTrivia.EqualsRange \nEqualsRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synenumcasetrivia.html#BarRange","title":"SynEnumCaseTrivia.BarRange","content":"SynEnumCaseTrivia.BarRange \nBarRange \n The syntax range of the \u0060|\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synenumcasetrivia.html#EqualsRange","title":"SynEnumCaseTrivia.EqualsRange","content":"SynEnumCaseTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprandbangtrivia.html","title":"SynExprAndBangTrivia","content":"SynExprAndBangTrivia \n Represents additional information for SynExprAndBang \nSynExprAndBangTrivia.EqualsRange \nEqualsRange \nSynExprAndBangTrivia.InKeyword \nInKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprandbangtrivia.html#EqualsRange","title":"SynExprAndBangTrivia.EqualsRange","content":"SynExprAndBangTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprandbangtrivia.html#InKeyword","title":"SynExprAndBangTrivia.InKeyword","content":"SynExprAndBangTrivia.InKeyword \nInKeyword \n The syntax range of the \u0060in\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexpranonrecdtrivia.html","title":"SynExprAnonRecdTrivia","content":"SynExprAnonRecdTrivia \n Represents additional information for SynExpr.AnonRecd \nSynExprAnonRecdTrivia.OpeningBraceRange \nOpeningBraceRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexpranonrecdtrivia.html#OpeningBraceRange","title":"SynExprAnonRecdTrivia.OpeningBraceRange","content":"SynExprAnonRecdTrivia.OpeningBraceRange \nOpeningBraceRange \n The syntax range of the \u0060{|\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprdotlambdatrivia.html","title":"SynExprDotLambdaTrivia","content":"SynExprDotLambdaTrivia \n Represents additional information for SynExpr.DotLambda \nSynExprDotLambdaTrivia.UnderscoreRange \nUnderscoreRange \nSynExprDotLambdaTrivia.DotRange \nDotRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprdotlambdatrivia.html#UnderscoreRange","title":"SynExprDotLambdaTrivia.UnderscoreRange","content":"SynExprDotLambdaTrivia.UnderscoreRange \nUnderscoreRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprdotlambdatrivia.html#DotRange","title":"SynExprDotLambdaTrivia.DotRange","content":"SynExprDotLambdaTrivia.DotRange \nDotRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html","title":"SynExprIfThenElseTrivia","content":"SynExprIfThenElseTrivia \n Represents additional information for SynExpr.IfThenElse \nSynExprIfThenElseTrivia.IfKeyword \nIfKeyword \nSynExprIfThenElseTrivia.IsElif \nIsElif \nSynExprIfThenElseTrivia.ThenKeyword \nThenKeyword \nSynExprIfThenElseTrivia.ElseKeyword \nElseKeyword \nSynExprIfThenElseTrivia.IfToThenRange \nIfToThenRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html#IfKeyword","title":"SynExprIfThenElseTrivia.IfKeyword","content":"SynExprIfThenElseTrivia.IfKeyword \nIfKeyword \n The syntax range of the \u0060if\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html#IsElif","title":"SynExprIfThenElseTrivia.IsElif","content":"SynExprIfThenElseTrivia.IsElif \nIsElif \n Indicates if the \u0060elif\u0060 keyword was used","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html#ThenKeyword","title":"SynExprIfThenElseTrivia.ThenKeyword","content":"SynExprIfThenElseTrivia.ThenKeyword \nThenKeyword \n The syntax range of the \u0060then\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html#ElseKeyword","title":"SynExprIfThenElseTrivia.ElseKeyword","content":"SynExprIfThenElseTrivia.ElseKeyword \nElseKeyword \n The syntax range of the \u0060else\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html#IfToThenRange","title":"SynExprIfThenElseTrivia.IfToThenRange","content":"SynExprIfThenElseTrivia.IfToThenRange \nIfToThenRange \n The syntax range from the beginning of the \u0060if\u0060 keyword till the end of the \u0060then\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprlambdatrivia.html","title":"SynExprLambdaTrivia","content":"SynExprLambdaTrivia \n Represents additional information for SynExpr.Lambda \nSynExprLambdaTrivia.Zero \nZero \nSynExprLambdaTrivia.ArrowRange \nArrowRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprlambdatrivia.html#Zero","title":"SynExprLambdaTrivia.Zero","content":"SynExprLambdaTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprlambdatrivia.html#ArrowRange","title":"SynExprLambdaTrivia.ArrowRange","content":"SynExprLambdaTrivia.ArrowRange \nArrowRange \n The syntax range of the \u0060-\u003E\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprletorusebangtrivia.html","title":"SynExprLetOrUseBangTrivia","content":"SynExprLetOrUseBangTrivia \n Represents additional information for SynExpr.LetOrUseBang \nSynExprLetOrUseBangTrivia.Zero \nZero \nSynExprLetOrUseBangTrivia.EqualsRange \nEqualsRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprletorusebangtrivia.html#Zero","title":"SynExprLetOrUseBangTrivia.Zero","content":"SynExprLetOrUseBangTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprletorusebangtrivia.html#EqualsRange","title":"SynExprLetOrUseBangTrivia.EqualsRange","content":"SynExprLetOrUseBangTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprletorusetrivia.html","title":"SynExprLetOrUseTrivia","content":"SynExprLetOrUseTrivia \n Represents additional information for SynExpr.LetOrUse \nSynExprLetOrUseTrivia.Zero \nZero \nSynExprLetOrUseTrivia.InKeyword \nInKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprletorusetrivia.html#Zero","title":"SynExprLetOrUseTrivia.Zero","content":"SynExprLetOrUseTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprletorusetrivia.html#InKeyword","title":"SynExprLetOrUseTrivia.InKeyword","content":"SynExprLetOrUseTrivia.InKeyword \nInKeyword \n The syntax range of the \u0060in\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprmatchbangtrivia.html","title":"SynExprMatchBangTrivia","content":"SynExprMatchBangTrivia \n Represents additional information for SynExpr.MatchBang \nSynExprMatchBangTrivia.MatchBangKeyword \nMatchBangKeyword \nSynExprMatchBangTrivia.WithKeyword \nWithKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprmatchbangtrivia.html#MatchBangKeyword","title":"SynExprMatchBangTrivia.MatchBangKeyword","content":"SynExprMatchBangTrivia.MatchBangKeyword \nMatchBangKeyword \n The syntax range of the \u0060match!\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprmatchbangtrivia.html#WithKeyword","title":"SynExprMatchBangTrivia.WithKeyword","content":"SynExprMatchBangTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprmatchtrivia.html","title":"SynExprMatchTrivia","content":"SynExprMatchTrivia \n Represents additional information for SynExpr.Match \nSynExprMatchTrivia.MatchKeyword \nMatchKeyword \nSynExprMatchTrivia.WithKeyword \nWithKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprmatchtrivia.html#MatchKeyword","title":"SynExprMatchTrivia.MatchKeyword","content":"SynExprMatchTrivia.MatchKeyword \nMatchKeyword \n The syntax range of the \u0060match\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprmatchtrivia.html#WithKeyword","title":"SynExprMatchTrivia.WithKeyword","content":"SynExprMatchTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtryfinallytrivia.html","title":"SynExprTryFinallyTrivia","content":"SynExprTryFinallyTrivia \n Represents additional information for SynExpr.TryFinally \nSynExprTryFinallyTrivia.TryKeyword \nTryKeyword \nSynExprTryFinallyTrivia.FinallyKeyword \nFinallyKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtryfinallytrivia.html#TryKeyword","title":"SynExprTryFinallyTrivia.TryKeyword","content":"SynExprTryFinallyTrivia.TryKeyword \nTryKeyword \n The syntax range of the \u0060try\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtryfinallytrivia.html#FinallyKeyword","title":"SynExprTryFinallyTrivia.FinallyKeyword","content":"SynExprTryFinallyTrivia.FinallyKeyword \nFinallyKeyword \n The syntax range of the \u0060finally\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html","title":"SynExprTryWithTrivia","content":"SynExprTryWithTrivia \n Represents additional information for SynExpr.TryWith \nSynExprTryWithTrivia.TryKeyword \nTryKeyword \nSynExprTryWithTrivia.TryToWithRange \nTryToWithRange \nSynExprTryWithTrivia.WithKeyword \nWithKeyword \nSynExprTryWithTrivia.WithToEndRange \nWithToEndRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html#TryKeyword","title":"SynExprTryWithTrivia.TryKeyword","content":"SynExprTryWithTrivia.TryKeyword \nTryKeyword \n The syntax range of the \u0060try\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html#TryToWithRange","title":"SynExprTryWithTrivia.TryToWithRange","content":"SynExprTryWithTrivia.TryToWithRange \nTryToWithRange \n The syntax range from the beginning of the \u0060try\u0060 keyword till the end of the \u0060with\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html#WithKeyword","title":"SynExprTryWithTrivia.WithKeyword","content":"SynExprTryWithTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html#WithToEndRange","title":"SynExprTryWithTrivia.WithToEndRange","content":"SynExprTryWithTrivia.WithToEndRange \nWithToEndRange \n The syntax range from the beginning of the \u0060with\u0060 keyword till the end of the TryWith expression.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html","title":"SynFieldTrivia","content":"SynFieldTrivia \n Represents additional information for SynField \nSynFieldTrivia.Zero \nZero \nSynFieldTrivia.LeadingKeyword \nLeadingKeyword \nSynFieldTrivia.MutableKeyword \nMutableKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html#Zero","title":"SynFieldTrivia.Zero","content":"SynFieldTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html#LeadingKeyword","title":"SynFieldTrivia.LeadingKeyword","content":"SynFieldTrivia.LeadingKeyword \nLeadingKeyword \n Used leading keyword of SynField","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html#MutableKeyword","title":"SynFieldTrivia.MutableKeyword","content":"SynFieldTrivia.MutableKeyword \nMutableKeyword \n The syntax range of the \u0060mutable\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html","title":"SynLeadingKeyword","content":"SynLeadingKeyword \n Represents the leading keyword in a SynBinding or SynValSig \nSynLeadingKeyword.Range \nRange \nSynLeadingKeyword.Let \nLet \nSynLeadingKeyword.LetRec \nLetRec \nSynLeadingKeyword.And \nAnd \nSynLeadingKeyword.Use \nUse \nSynLeadingKeyword.UseRec \nUseRec \nSynLeadingKeyword.Extern \nExtern \nSynLeadingKeyword.Member \nMember \nSynLeadingKeyword.MemberVal \nMemberVal \nSynLeadingKeyword.Override \nOverride \nSynLeadingKeyword.OverrideVal \nOverrideVal \nSynLeadingKeyword.Abstract \nAbstract \nSynLeadingKeyword.AbstractMember \nAbstractMember \nSynLeadingKeyword.Static \nStatic \nSynLeadingKeyword.StaticMember \nStaticMember \nSynLeadingKeyword.StaticMemberVal \nStaticMemberVal \nSynLeadingKeyword.StaticAbstract \nStaticAbstract \nSynLeadingKeyword.StaticAbstractMember \nStaticAbstractMember \nSynLeadingKeyword.StaticVal \nStaticVal \nSynLeadingKeyword.StaticLet \nStaticLet \nSynLeadingKeyword.StaticLetRec \nStaticLetRec \nSynLeadingKeyword.StaticDo \nStaticDo \nSynLeadingKeyword.Default \nDefault \nSynLeadingKeyword.DefaultVal \nDefaultVal \nSynLeadingKeyword.Val \nVal \nSynLeadingKeyword.New \nNew \nSynLeadingKeyword.Do \nDo \nSynLeadingKeyword.Synthetic \nSynthetic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Range","title":"SynLeadingKeyword.Range","content":"SynLeadingKeyword.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Let","title":"SynLeadingKeyword.Let","content":"SynLeadingKeyword.Let \nLet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#LetRec","title":"SynLeadingKeyword.LetRec","content":"SynLeadingKeyword.LetRec \nLetRec \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#And","title":"SynLeadingKeyword.And","content":"SynLeadingKeyword.And \nAnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Use","title":"SynLeadingKeyword.Use","content":"SynLeadingKeyword.Use \nUse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#UseRec","title":"SynLeadingKeyword.UseRec","content":"SynLeadingKeyword.UseRec \nUseRec \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Extern","title":"SynLeadingKeyword.Extern","content":"SynLeadingKeyword.Extern \nExtern \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Member","title":"SynLeadingKeyword.Member","content":"SynLeadingKeyword.Member \nMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#MemberVal","title":"SynLeadingKeyword.MemberVal","content":"SynLeadingKeyword.MemberVal \nMemberVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Override","title":"SynLeadingKeyword.Override","content":"SynLeadingKeyword.Override \nOverride \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#OverrideVal","title":"SynLeadingKeyword.OverrideVal","content":"SynLeadingKeyword.OverrideVal \nOverrideVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Abstract","title":"SynLeadingKeyword.Abstract","content":"SynLeadingKeyword.Abstract \nAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#AbstractMember","title":"SynLeadingKeyword.AbstractMember","content":"SynLeadingKeyword.AbstractMember \nAbstractMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Static","title":"SynLeadingKeyword.Static","content":"SynLeadingKeyword.Static \nStatic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticMember","title":"SynLeadingKeyword.StaticMember","content":"SynLeadingKeyword.StaticMember \nStaticMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticMemberVal","title":"SynLeadingKeyword.StaticMemberVal","content":"SynLeadingKeyword.StaticMemberVal \nStaticMemberVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticAbstract","title":"SynLeadingKeyword.StaticAbstract","content":"SynLeadingKeyword.StaticAbstract \nStaticAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticAbstractMember","title":"SynLeadingKeyword.StaticAbstractMember","content":"SynLeadingKeyword.StaticAbstractMember \nStaticAbstractMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticVal","title":"SynLeadingKeyword.StaticVal","content":"SynLeadingKeyword.StaticVal \nStaticVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticLet","title":"SynLeadingKeyword.StaticLet","content":"SynLeadingKeyword.StaticLet \nStaticLet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticLetRec","title":"SynLeadingKeyword.StaticLetRec","content":"SynLeadingKeyword.StaticLetRec \nStaticLetRec \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#StaticDo","title":"SynLeadingKeyword.StaticDo","content":"SynLeadingKeyword.StaticDo \nStaticDo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Default","title":"SynLeadingKeyword.Default","content":"SynLeadingKeyword.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#DefaultVal","title":"SynLeadingKeyword.DefaultVal","content":"SynLeadingKeyword.DefaultVal \nDefaultVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Val","title":"SynLeadingKeyword.Val","content":"SynLeadingKeyword.Val \nVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#New","title":"SynLeadingKeyword.New","content":"SynLeadingKeyword.New \nNew \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Do","title":"SynLeadingKeyword.Do","content":"SynLeadingKeyword.Do \nDo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html#Synthetic","title":"SynLeadingKeyword.Synthetic","content":"SynLeadingKeyword.Synthetic \nSynthetic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html","title":"SynMatchClauseTrivia","content":"SynMatchClauseTrivia \n Represents additional information for SynMatchClause \nSynMatchClauseTrivia.Zero \nZero \nSynMatchClauseTrivia.ArrowRange \nArrowRange \nSynMatchClauseTrivia.BarRange \nBarRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html#Zero","title":"SynMatchClauseTrivia.Zero","content":"SynMatchClauseTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html#ArrowRange","title":"SynMatchClauseTrivia.ArrowRange","content":"SynMatchClauseTrivia.ArrowRange \nArrowRange \n The syntax range of the \u0060-\u003E\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html#BarRange","title":"SynMatchClauseTrivia.BarRange","content":"SynMatchClauseTrivia.BarRange \nBarRange \n The syntax range of the \u0060|\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmeasureconstanttrivia.html","title":"SynMeasureConstantTrivia","content":"SynMeasureConstantTrivia \n Represents additional information for SynConst.Measure \nSynMeasureConstantTrivia.LessRange \nLessRange \nSynMeasureConstantTrivia.GreaterRange \nGreaterRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmeasureconstanttrivia.html#LessRange","title":"SynMeasureConstantTrivia.LessRange","content":"SynMeasureConstantTrivia.LessRange \nLessRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmeasureconstanttrivia.html#GreaterRange","title":"SynMeasureConstantTrivia.GreaterRange","content":"SynMeasureConstantTrivia.GreaterRange \nGreaterRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnabstractslottrivia.html","title":"SynMemberDefnAbstractSlotTrivia","content":"SynMemberDefnAbstractSlotTrivia \n Represents additional information for SynMemberDefn.AbstractSlot \nSynMemberDefnAbstractSlotTrivia.Zero \nZero \nSynMemberDefnAbstractSlotTrivia.GetSetKeywords \nGetSetKeywords","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnabstractslottrivia.html#Zero","title":"SynMemberDefnAbstractSlotTrivia.Zero","content":"SynMemberDefnAbstractSlotTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnabstractslottrivia.html#GetSetKeywords","title":"SynMemberDefnAbstractSlotTrivia.GetSetKeywords","content":"SynMemberDefnAbstractSlotTrivia.GetSetKeywords \nGetSetKeywords \n The syntax range of \u0027get, set\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html","title":"SynMemberDefnAutoPropertyTrivia","content":"SynMemberDefnAutoPropertyTrivia \n Represents additional information for SynMemberDefn.AutoProperty \nSynMemberDefnAutoPropertyTrivia.LeadingKeyword \nLeadingKeyword \nSynMemberDefnAutoPropertyTrivia.WithKeyword \nWithKeyword \nSynMemberDefnAutoPropertyTrivia.EqualsRange \nEqualsRange \nSynMemberDefnAutoPropertyTrivia.GetSetKeywords \nGetSetKeywords","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html#LeadingKeyword","title":"SynMemberDefnAutoPropertyTrivia.LeadingKeyword","content":"SynMemberDefnAutoPropertyTrivia.LeadingKeyword \nLeadingKeyword \n Used leading keyword of AutoProperty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html#WithKeyword","title":"SynMemberDefnAutoPropertyTrivia.WithKeyword","content":"SynMemberDefnAutoPropertyTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html#EqualsRange","title":"SynMemberDefnAutoPropertyTrivia.EqualsRange","content":"SynMemberDefnAutoPropertyTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html#GetSetKeywords","title":"SynMemberDefnAutoPropertyTrivia.GetSetKeywords","content":"SynMemberDefnAutoPropertyTrivia.GetSetKeywords \nGetSetKeywords \n The syntax range of \u0027get, set\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnimplicitctortrivia.html","title":"SynMemberDefnImplicitCtorTrivia","content":"SynMemberDefnImplicitCtorTrivia \n Represents additional information for SynMemberDefn.ImplicitCtor \nSynMemberDefnImplicitCtorTrivia.AsKeyword \nAsKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmemberdefnimplicitctortrivia.html#AsKeyword","title":"SynMemberDefnImplicitCtorTrivia.AsKeyword","content":"SynMemberDefnImplicitCtorTrivia.AsKeyword \nAsKeyword \n The syntax range of the \u0060as\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html","title":"SynMemberGetSetTrivia","content":"SynMemberGetSetTrivia \n Represents additional information for SynMemberDefn.GetSetMember \nSynMemberGetSetTrivia.InlineKeyword \nInlineKeyword \nSynMemberGetSetTrivia.WithKeyword \nWithKeyword \nSynMemberGetSetTrivia.GetKeyword \nGetKeyword \nSynMemberGetSetTrivia.AndKeyword \nAndKeyword \nSynMemberGetSetTrivia.SetKeyword \nSetKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html#InlineKeyword","title":"SynMemberGetSetTrivia.InlineKeyword","content":"SynMemberGetSetTrivia.InlineKeyword \nInlineKeyword \n The syntax range of the \u0060inline\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html#WithKeyword","title":"SynMemberGetSetTrivia.WithKeyword","content":"SynMemberGetSetTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html#GetKeyword","title":"SynMemberGetSetTrivia.GetKeyword","content":"SynMemberGetSetTrivia.GetKeyword \nGetKeyword \n The syntax range of the \u0060get\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html#AndKeyword","title":"SynMemberGetSetTrivia.AndKeyword","content":"SynMemberGetSetTrivia.AndKeyword \nAndKeyword \n The syntax range of the \u0060and\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html#SetKeyword","title":"SynMemberGetSetTrivia.SetKeyword","content":"SynMemberGetSetTrivia.SetKeyword \nSetKeyword \n The syntax range of the \u0060set\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembersigmembertrivia.html","title":"SynMemberSigMemberTrivia","content":"SynMemberSigMemberTrivia \n Represents additional information for SynMemberSig.Member \nSynMemberSigMemberTrivia.Zero \nZero \nSynMemberSigMemberTrivia.GetSetKeywords \nGetSetKeywords","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembersigmembertrivia.html#Zero","title":"SynMemberSigMemberTrivia.Zero","content":"SynMemberSigMemberTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmembersigmembertrivia.html#GetSetKeywords","title":"SynMemberSigMemberTrivia.GetSetKeywords","content":"SynMemberSigMemberTrivia.GetSetKeywords \nGetSetKeywords \n The syntax range of \u0027get, set\u0027","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html","title":"SynModuleDeclNestedModuleTrivia","content":"SynModuleDeclNestedModuleTrivia \n Represents additional information for SynModuleDecl.NestedModule \nSynModuleDeclNestedModuleTrivia.Zero \nZero \nSynModuleDeclNestedModuleTrivia.ModuleKeyword \nModuleKeyword \nSynModuleDeclNestedModuleTrivia.EqualsRange \nEqualsRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html#Zero","title":"SynModuleDeclNestedModuleTrivia.Zero","content":"SynModuleDeclNestedModuleTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html#ModuleKeyword","title":"SynModuleDeclNestedModuleTrivia.ModuleKeyword","content":"SynModuleDeclNestedModuleTrivia.ModuleKeyword \nModuleKeyword \n The syntax range of the \u0060module\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html#EqualsRange","title":"SynModuleDeclNestedModuleTrivia.EqualsRange","content":"SynModuleDeclNestedModuleTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html","title":"SynModuleOrNamespaceLeadingKeyword","content":"SynModuleOrNamespaceLeadingKeyword \n Represents the leading keyword in a SynModuleOrNamespace or SynModuleOrNamespaceSig \nSynModuleOrNamespaceLeadingKeyword.Module \nModule \nSynModuleOrNamespaceLeadingKeyword.Namespace \nNamespace \nSynModuleOrNamespaceLeadingKeyword.None \nNone","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html#Module","title":"SynModuleOrNamespaceLeadingKeyword.Module","content":"SynModuleOrNamespaceLeadingKeyword.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html#Namespace","title":"SynModuleOrNamespaceLeadingKeyword.Namespace","content":"SynModuleOrNamespaceLeadingKeyword.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html#None","title":"SynModuleOrNamespaceLeadingKeyword.None","content":"SynModuleOrNamespaceLeadingKeyword.None \nNone \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacesigtrivia.html","title":"SynModuleOrNamespaceSigTrivia","content":"SynModuleOrNamespaceSigTrivia \n Represents additional information for SynModuleOrNamespaceSig \nSynModuleOrNamespaceSigTrivia.LeadingKeyword \nLeadingKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacesigtrivia.html#LeadingKeyword","title":"SynModuleOrNamespaceSigTrivia.LeadingKeyword","content":"SynModuleOrNamespaceSigTrivia.LeadingKeyword \nLeadingKeyword \n The syntax range of the \u0060module\u0060 or \u0060namespace\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacetrivia.html","title":"SynModuleOrNamespaceTrivia","content":"SynModuleOrNamespaceTrivia \n Represents additional information for SynModuleOrNamespace \nSynModuleOrNamespaceTrivia.LeadingKeyword \nLeadingKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacetrivia.html#LeadingKeyword","title":"SynModuleOrNamespaceTrivia.LeadingKeyword","content":"SynModuleOrNamespaceTrivia.LeadingKeyword \nLeadingKeyword \n The syntax range of the \u0060module\u0060 or \u0060namespace\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html","title":"SynModuleSigDeclNestedModuleTrivia","content":"SynModuleSigDeclNestedModuleTrivia \n Represents additional information for SynModuleSigDecl.NestedModule \nSynModuleSigDeclNestedModuleTrivia.Zero \nZero \nSynModuleSigDeclNestedModuleTrivia.ModuleKeyword \nModuleKeyword \nSynModuleSigDeclNestedModuleTrivia.EqualsRange \nEqualsRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html#Zero","title":"SynModuleSigDeclNestedModuleTrivia.Zero","content":"SynModuleSigDeclNestedModuleTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html#ModuleKeyword","title":"SynModuleSigDeclNestedModuleTrivia.ModuleKeyword","content":"SynModuleSigDeclNestedModuleTrivia.ModuleKeyword \nModuleKeyword \n The syntax range of the \u0060module\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html#EqualsRange","title":"SynModuleSigDeclNestedModuleTrivia.EqualsRange","content":"SynModuleSigDeclNestedModuleTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synpatlistconstrivia.html","title":"SynPatListConsTrivia","content":"SynPatListConsTrivia \n Represents additional information for SynPat.Cons \nSynPatListConsTrivia.ColonColonRange \nColonColonRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synpatlistconstrivia.html#ColonColonRange","title":"SynPatListConsTrivia.ColonColonRange","content":"SynPatListConsTrivia.ColonColonRange \nColonColonRange \n The syntax range of the \u0060::\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synpatortrivia.html","title":"SynPatOrTrivia","content":"SynPatOrTrivia \n Represents additional information for SynPat.Or \nSynPatOrTrivia.BarRange \nBarRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synpatortrivia.html#BarRange","title":"SynPatOrTrivia.BarRange","content":"SynPatOrTrivia.BarRange \nBarRange \n The syntax range of the \u0060|\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypardecltrivia.html","title":"SynTyparDeclTrivia","content":"SynTyparDeclTrivia \n Represents additional information for SynTyparDecl \nSynTyparDeclTrivia.Zero \nZero \nSynTyparDeclTrivia.AmpersandRanges \nAmpersandRanges","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypardecltrivia.html#Zero","title":"SynTyparDeclTrivia.Zero","content":"SynTyparDeclTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypardecltrivia.html#AmpersandRanges","title":"SynTyparDeclTrivia.AmpersandRanges","content":"SynTyparDeclTrivia.AmpersandRanges \nAmpersandRanges \n The syntax ranges of the \u0060\u0026\u0060 tokens","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html","title":"SynTypeDefnLeadingKeyword","content":"SynTypeDefnLeadingKeyword \n Represents the leading keyword in a SynTypeDefn or SynTypeDefnSig \nSynTypeDefnLeadingKeyword.Range \nRange \nSynTypeDefnLeadingKeyword.Type \nType \nSynTypeDefnLeadingKeyword.And \nAnd \nSynTypeDefnLeadingKeyword.StaticType \nStaticType \nSynTypeDefnLeadingKeyword.Synthetic \nSynthetic","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html#Range","title":"SynTypeDefnLeadingKeyword.Range","content":"SynTypeDefnLeadingKeyword.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html#Type","title":"SynTypeDefnLeadingKeyword.Type","content":"SynTypeDefnLeadingKeyword.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html#And","title":"SynTypeDefnLeadingKeyword.And","content":"SynTypeDefnLeadingKeyword.And \nAnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html#StaticType","title":"SynTypeDefnLeadingKeyword.StaticType","content":"SynTypeDefnLeadingKeyword.StaticType \nStaticType \n Can happen in SynMemberDefn.NestedType or SynMemberSig.NestedType","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html#Synthetic","title":"SynTypeDefnLeadingKeyword.Synthetic","content":"SynTypeDefnLeadingKeyword.Synthetic \nSynthetic \n Produced during type checking, should not be used in actual parsed trees.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html","title":"SynTypeDefnSigTrivia","content":"SynTypeDefnSigTrivia \n Represents additional information for SynTypeDefnSig \nSynTypeDefnSigTrivia.Zero \nZero \nSynTypeDefnSigTrivia.LeadingKeyword \nLeadingKeyword \nSynTypeDefnSigTrivia.EqualsRange \nEqualsRange \nSynTypeDefnSigTrivia.WithKeyword \nWithKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html#Zero","title":"SynTypeDefnSigTrivia.Zero","content":"SynTypeDefnSigTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html#LeadingKeyword","title":"SynTypeDefnSigTrivia.LeadingKeyword","content":"SynTypeDefnSigTrivia.LeadingKeyword \nLeadingKeyword \n The syntax range of the \u0060type\u0060 or \u0060and\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html#EqualsRange","title":"SynTypeDefnSigTrivia.EqualsRange","content":"SynTypeDefnSigTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html#WithKeyword","title":"SynTypeDefnSigTrivia.WithKeyword","content":"SynTypeDefnSigTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html","title":"SynTypeDefnTrivia","content":"SynTypeDefnTrivia \n Represents additional information for SynTypeDefn \nSynTypeDefnTrivia.Zero \nZero \nSynTypeDefnTrivia.LeadingKeyword \nLeadingKeyword \nSynTypeDefnTrivia.EqualsRange \nEqualsRange \nSynTypeDefnTrivia.WithKeyword \nWithKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html#Zero","title":"SynTypeDefnTrivia.Zero","content":"SynTypeDefnTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html#LeadingKeyword","title":"SynTypeDefnTrivia.LeadingKeyword","content":"SynTypeDefnTrivia.LeadingKeyword \nLeadingKeyword \n The syntax range of the \u0060type\u0060 or \u0060and\u0060 keyword.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html#EqualsRange","title":"SynTypeDefnTrivia.EqualsRange","content":"SynTypeDefnTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html#WithKeyword","title":"SynTypeDefnTrivia.WithKeyword","content":"SynTypeDefnTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypefuntrivia.html","title":"SynTypeFunTrivia","content":"SynTypeFunTrivia \n Represents additional information for SynType.Fun \nSynTypeFunTrivia.ArrowRange \nArrowRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypefuntrivia.html#ArrowRange","title":"SynTypeFunTrivia.ArrowRange","content":"SynTypeFunTrivia.ArrowRange \nArrowRange \n The syntax range of the \u0060-\u003E\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypeortrivia.html","title":"SynTypeOrTrivia","content":"SynTypeOrTrivia \n Represents additional information for SynType.Or \nSynTypeOrTrivia.OrKeyword \nOrKeyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-syntypeortrivia.html#OrKeyword","title":"SynTypeOrTrivia.OrKeyword","content":"SynTypeOrTrivia.OrKeyword \nOrKeyword \n The syntax range of the \u0060or\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synunioncasetrivia.html","title":"SynUnionCaseTrivia","content":"SynUnionCaseTrivia \n Represents additional information for SynUnionCase \nSynUnionCaseTrivia.BarRange \nBarRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synunioncasetrivia.html#BarRange","title":"SynUnionCaseTrivia.BarRange","content":"SynUnionCaseTrivia.BarRange \nBarRange \n The syntax range of the \u0060|\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html","title":"SynValSigTrivia","content":"SynValSigTrivia \n Represents additional information for SynValSig \nSynValSigTrivia.Zero \nZero \nSynValSigTrivia.LeadingKeyword \nLeadingKeyword \nSynValSigTrivia.InlineKeyword \nInlineKeyword \nSynValSigTrivia.WithKeyword \nWithKeyword \nSynValSigTrivia.EqualsRange \nEqualsRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html#Zero","title":"SynValSigTrivia.Zero","content":"SynValSigTrivia.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html#LeadingKeyword","title":"SynValSigTrivia.LeadingKeyword","content":"SynValSigTrivia.LeadingKeyword \nLeadingKeyword \n Used leading keyword of SynValSig\n In most cases this will be \u0060val\u0060,\n but in case of \u0060SynMemberDefn.AutoProperty\u0060 or \u0060SynMemberDefn.AbstractSlot\u0060 it could be something else.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html#InlineKeyword","title":"SynValSigTrivia.InlineKeyword","content":"SynValSigTrivia.InlineKeyword \nInlineKeyword \n The syntax range of the \u0060inline\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html#WithKeyword","title":"SynValSigTrivia.WithKeyword","content":"SynValSigTrivia.WithKeyword \nWithKeyword \n The syntax range of the \u0060with\u0060 keyword","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html#EqualsRange","title":"SynValSigTrivia.EqualsRange","content":"SynValSigTrivia.EqualsRange \nEqualsRange \n The syntax range of the \u0060=\u0060 token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-line.html","title":"Line","content":"Line \n Functions related to converting between lines indexed at 0 and 1 \nLine.fromZ \nfromZ \nLine.toZ \ntoZ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-line.html#fromZ","title":"Line.fromZ","content":"Line.fromZ \nfromZ \n Convert a line number from zero-based line counting (used by Visual Studio) to one-based line counting (used internally in the F# compiler and in F# error messages) ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-line.html#toZ","title":"Line.toZ","content":"Line.toZ \ntoZ \n Convert a line number from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html","title":"Position","content":"Position \n \nPosition.mkPos \nmkPos \nPosition.posLt \nposLt \nPosition.posGt \nposGt \nPosition.posEq \nposEq \nPosition.posGeq \nposGeq \nPosition.fromZ \nfromZ \nPosition.toZ \ntoZ \nPosition.outputPos \noutputPos \nPosition.stringOfPos \nstringOfPos \nPosition.pos0 \npos0","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#mkPos","title":"Position.mkPos","content":"Position.mkPos \nmkPos \n Create a position for the given line and column","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#posLt","title":"Position.posLt","content":"Position.posLt \nposLt \n Compare positions for less-than","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#posGt","title":"Position.posGt","content":"Position.posGt \nposGt \n Compare positions for greater-than","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#posEq","title":"Position.posEq","content":"Position.posEq \nposEq \n Compare positions for equality","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#posGeq","title":"Position.posGeq","content":"Position.posGeq \nposGeq \n Compare positions for greater-than-or-equal-to","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#fromZ","title":"Position.fromZ","content":"Position.fromZ \nfromZ \n Convert a position from zero-based line counting (used by Visual Studio) to one-based line counting (used internally in the F# compiler and in F# error messages) ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#toZ","title":"Position.toZ","content":"Position.toZ \ntoZ \n Convert a position from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#outputPos","title":"Position.outputPos","content":"Position.outputPos \noutputPos \n Output a position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#stringOfPos","title":"Position.stringOfPos","content":"Position.stringOfPos \nstringOfPos \n Convert a position to a string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-positionmodule.html#pos0","title":"Position.pos0","content":"Position.pos0 \npos0 \n The zero position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html","title":"Range","content":"Range \n \nRange.posOrder \nposOrder \nRange.mkFileIndexRange \nmkFileIndexRange \nRange.mkRange \nmkRange \nRange.mkFirstLineOfFile \nmkFirstLineOfFile \nRange.equals \nequals \nRange.trimRangeToLine \ntrimRangeToLine \nRange.rangeOrder \nrangeOrder \nRange.outputRange \noutputRange \nRange.unionRanges \nunionRanges \nRange.withStartEnd \nwithStartEnd \nRange.withStart \nwithStart \nRange.withEnd \nwithEnd \nRange.shiftStart \nshiftStart \nRange.shiftEnd \nshiftEnd \nRange.rangeContainsRange \nrangeContainsRange \nRange.rangeContainsPos \nrangeContainsPos \nRange.rangeBeforePos \nrangeBeforePos \nRange.rangeN \nrangeN \nRange.range0 \nrange0 \nRange.rangeStartup \nrangeStartup \nRange.rangeCmdArgs \nrangeCmdArgs \nRange.stringOfRange \nstringOfRange \nRange.toZ \ntoZ \nRange.toFileZ \ntoFileZ \nRange.comparer \ncomparer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#posOrder","title":"Range.posOrder","content":"Range.posOrder \nposOrder \n Ordering on positions","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#mkFileIndexRange","title":"Range.mkFileIndexRange","content":"Range.mkFileIndexRange \nmkFileIndexRange \n This view of range marks uses file indexes explicitly ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#mkRange","title":"Range.mkRange","content":"Range.mkRange \nmkRange \n This view hides the use of file indexes and just uses filenames ","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#mkFirstLineOfFile","title":"Range.mkFirstLineOfFile","content":"Range.mkFirstLineOfFile \nmkFirstLineOfFile \n Make a range for the first non-whitespace line of the file if any. Otherwise use line 1 chars 0-80.\n This involves reading the file.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#equals","title":"Range.equals","content":"Range.equals \nequals \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#trimRangeToLine","title":"Range.trimRangeToLine","content":"Range.trimRangeToLine \ntrimRangeToLine \n Reduce a range so it only covers a line","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeOrder","title":"Range.rangeOrder","content":"Range.rangeOrder \nrangeOrder \n Order ranges (file, then start pos, then end pos)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#outputRange","title":"Range.outputRange","content":"Range.outputRange \noutputRange \n Output a range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#unionRanges","title":"Range.unionRanges","content":"Range.unionRanges \nunionRanges \n Union two ranges, taking their first occurring start position and last occurring end position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#withStartEnd","title":"Range.withStartEnd","content":"Range.withStartEnd \nwithStartEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#withStart","title":"Range.withStart","content":"Range.withStart \nwithStart \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#withEnd","title":"Range.withEnd","content":"Range.withEnd \nwithEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#shiftStart","title":"Range.shiftStart","content":"Range.shiftStart \nshiftStart \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#shiftEnd","title":"Range.shiftEnd","content":"Range.shiftEnd \nshiftEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeContainsRange","title":"Range.rangeContainsRange","content":"Range.rangeContainsRange \nrangeContainsRange \n Test to see if one range contains another range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeContainsPos","title":"Range.rangeContainsPos","content":"Range.rangeContainsPos \nrangeContainsPos \n Test to see if a range contains a position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeBeforePos","title":"Range.rangeBeforePos","content":"Range.rangeBeforePos \nrangeBeforePos \n Test to see if a range occurs fully before a position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeN","title":"Range.rangeN","content":"Range.rangeN \nrangeN \n Make a dummy range for a file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#range0","title":"Range.range0","content":"Range.range0 \nrange0 \n The zero range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeStartup","title":"Range.rangeStartup","content":"Range.rangeStartup \nrangeStartup \n A range associated with a dummy file called \u0022startup\u0022","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#rangeCmdArgs","title":"Range.rangeCmdArgs","content":"Range.rangeCmdArgs \nrangeCmdArgs \n A range associated with a dummy file for the command line arguments","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#stringOfRange","title":"Range.stringOfRange","content":"Range.stringOfRange \nstringOfRange \n Convert a range to a string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#toZ","title":"Range.toZ","content":"Range.toZ \ntoZ \n Convert a range from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#toFileZ","title":"Range.toFileZ","content":"Range.toFileZ \ntoFileZ \n Convert a range from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-rangemodule.html#comparer","title":"Range.comparer","content":"Range.comparer \ncomparer \n Equality comparer for range.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-sourcetext.html","title":"SourceText","content":"SourceText \n Functions related to ISourceText objects \nSourceText.ofString \nofString","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-sourcetext.html#ofString","title":"SourceText.ofString","content":"SourceText.ofString \nofString \n Creates an ISourceText object from the given string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html","title":"TaggedText","content":"TaggedText \n \nTaggedText.tagText \ntagText \nTaggedText.tagClass \ntagClass \nTaggedText.comma \ncomma \nTaggedText.tagNamespace \ntagNamespace \nTaggedText.tagParameter \ntagParameter \nTaggedText.tagSpace \ntagSpace \nTaggedText.dot \ndot \nTaggedText.colon \ncolon \nTaggedText.minus \nminus \nTaggedText.lineBreak \nlineBreak \nTaggedText.space \nspace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#tagText","title":"TaggedText.tagText","content":"TaggedText.tagText \ntagText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#tagClass","title":"TaggedText.tagClass","content":"TaggedText.tagClass \ntagClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#comma","title":"TaggedText.comma","content":"TaggedText.comma \ncomma \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#tagNamespace","title":"TaggedText.tagNamespace","content":"TaggedText.tagNamespace \ntagNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#tagParameter","title":"TaggedText.tagParameter","content":"TaggedText.tagParameter \ntagParameter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#tagSpace","title":"TaggedText.tagSpace","content":"TaggedText.tagSpace \ntagSpace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#dot","title":"TaggedText.dot","content":"TaggedText.dot \ndot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#colon","title":"TaggedText.colon","content":"TaggedText.colon \ncolon \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#minus","title":"TaggedText.minus","content":"TaggedText.minus \nminus \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#lineBreak","title":"TaggedText.lineBreak","content":"TaggedText.lineBreak \nlineBreak \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtextmodule.html#space","title":"TaggedText.space","content":"TaggedText.space \nspace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html","title":"ISourceText","content":"ISourceText \n Represents an input to the F# compiler \nISourceText.ContentEquals \nContentEquals \nISourceText.CopyTo \nCopyTo \nISourceText.GetLastCharacterPosition \nGetLastCharacterPosition \nISourceText.GetLineCount \nGetLineCount \nISourceText.GetLineString \nGetLineString \nISourceText.GetSubTextFromRange \nGetSubTextFromRange \nISourceText.GetSubTextString \nGetSubTextString \nISourceText.SubTextEquals \nSubTextEquals \nISourceText.Length \nLength \nISourceText.Item \nItem","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#ContentEquals","title":"ISourceText.ContentEquals","content":"ISourceText.ContentEquals \nContentEquals \n Checks if one input is equal to another","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#CopyTo","title":"ISourceText.CopyTo","content":"ISourceText.CopyTo \nCopyTo \n Copies a section of the input to the given destination ad the given index","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#GetLastCharacterPosition","title":"ISourceText.GetLastCharacterPosition","content":"ISourceText.GetLastCharacterPosition \nGetLastCharacterPosition \n Gets the last character position in the input, returning line and column","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#GetLineCount","title":"ISourceText.GetLineCount","content":"ISourceText.GetLineCount \nGetLineCount \n Gets the count of lines in the input","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#GetLineString","title":"ISourceText.GetLineString","content":"ISourceText.GetLineString \nGetLineString \n Gets a line of an input by index","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#GetSubTextFromRange","title":"ISourceText.GetSubTextFromRange","content":"ISourceText.GetSubTextFromRange \nGetSubTextFromRange \n Gets a section of the input based on a given range.\n \u003Cexception cref=\u0022System.ArgumentException\u0022\u003EThrows an exception when the input range is outside the file boundaries.\u003C/exception\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#GetSubTextString","title":"ISourceText.GetSubTextString","content":"ISourceText.GetSubTextString \nGetSubTextString \n Gets a section of the input","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#SubTextEquals","title":"ISourceText.SubTextEquals","content":"ISourceText.SubTextEquals \nSubTextEquals \n Checks if a section of the input is equal to the given string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#Length","title":"ISourceText.Length","content":"ISourceText.Length \nLength \n Gets the total length of the input in characters","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-isourcetext.html#Item","title":"ISourceText.Item","content":"ISourceText.Item \nItem \n Gets a character in an input based on an index of characters from the start of the file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-line0.html","title":"Line0","content":"Line0 \n Represents a line number when using zero-based line counting (used by Visual Studio)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-navigabletaggedtext.html","title":"NavigableTaggedText","content":"NavigableTaggedText \n An enhancement to TaggedText in the TaggedText layouts generated by FSharp.Compiler.Service \nNavigableTaggedText.Range \nRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-navigabletaggedtext.html#Range","title":"NavigableTaggedText.Range","content":"NavigableTaggedText.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-position.html","title":"Position","content":"Position \n Represents a position in a file \nPosition.Column \nColumn \nPosition.Line \nLine","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-position.html#Column","title":"Position.Column","content":"Position.Column \nColumn \n The column number for the position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-position.html#Line","title":"Position.Line","content":"Position.Line \nLine \n The line number for the position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html","title":"Range","content":"Range \n Represents a range within a file \nRange.Start \nStart \nRange.FileName \nFileName \nRange.EndColumn \nEndColumn \nRange.StartRange \nStartRange \nRange.EndRange \nEndRange \nRange.StartColumn \nStartColumn \nRange.End \nEnd \nRange.EndLine \nEndLine \nRange.StartLine \nStartLine \nRange.IsSynthetic \nIsSynthetic \nRange.Zero \nZero","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#Start","title":"Range.Start","content":"Range.Start \nStart \n The start position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#FileName","title":"Range.FileName","content":"Range.FileName \nFileName \n The file name for the file of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#EndColumn","title":"Range.EndColumn","content":"Range.EndColumn \nEndColumn \n The column number for the end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#StartRange","title":"Range.StartRange","content":"Range.StartRange \nStartRange \n The empty range that is located at the start position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#EndRange","title":"Range.EndRange","content":"Range.EndRange \nEndRange \n The empty range that is located at the end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#StartColumn","title":"Range.StartColumn","content":"Range.StartColumn \nStartColumn \n The start column of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#End","title":"Range.End","content":"Range.End \nEnd \n The end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#EndLine","title":"Range.EndLine","content":"Range.EndLine \nEndLine \n The line number for the end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#StartLine","title":"Range.StartLine","content":"Range.StartLine \nStartLine \n The start line of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#IsSynthetic","title":"Range.IsSynthetic","content":"Range.IsSynthetic \nIsSynthetic \n Synthetic marks ranges which are produced by intermediate compilation phases. This\n bit signifies that the range covers something that should not be visible to language\n service operations like dot-completion.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range.html#Zero","title":"Range.Zero","content":"Range.Zero \nZero \n The range where all values are zero","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtext.html","title":"TaggedText","content":"TaggedText \n Represents text with a tag \nTaggedText.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTaggedText.Text \nText \nTaggedText.Tag \nTag","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtext.html#\u0060\u0060.ctor\u0060\u0060","title":"TaggedText.\u0060\u0060.ctor\u0060\u0060","content":"TaggedText.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Creates text with a tag","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtext.html#Text","title":"TaggedText.Text","content":"TaggedText.Text \nText \n Gets the text","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-taggedtext.html#Tag","title":"TaggedText.Tag","content":"TaggedText.Tag \nTag \n Gets the tag","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html","title":"TextTag","content":"TextTag \n Represents the tag of some tagged text \nTextTag.ActivePatternCase \nActivePatternCase \nTextTag.ActivePatternResult \nActivePatternResult \nTextTag.Alias \nAlias \nTextTag.Class \nClass \nTextTag.Union \nUnion \nTextTag.UnionCase \nUnionCase \nTextTag.Delegate \nDelegate \nTextTag.Enum \nEnum \nTextTag.Event \nEvent \nTextTag.Field \nField \nTextTag.Interface \nInterface \nTextTag.Keyword \nKeyword \nTextTag.LineBreak \nLineBreak \nTextTag.Local \nLocal \nTextTag.Record \nRecord \nTextTag.RecordField \nRecordField \nTextTag.Method \nMethod \nTextTag.Member \nMember \nTextTag.ModuleBinding \nModuleBinding \nTextTag.Function \nFunction \nTextTag.Module \nModule \nTextTag.Namespace \nNamespace \nTextTag.NumericLiteral \nNumericLiteral \nTextTag.Operator \nOperator \nTextTag.Parameter \nParameter \nTextTag.Property \nProperty \nTextTag.Space \nSpace \nTextTag.StringLiteral \nStringLiteral \nTextTag.Struct \nStruct \nTextTag.TypeParameter \nTypeParameter \nTextTag.Text \nText \nTextTag.Punctuation \nPunctuation \nTextTag.UnknownType \nUnknownType \nTextTag.UnknownEntity \nUnknownEntity","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#ActivePatternCase","title":"TextTag.ActivePatternCase","content":"TextTag.ActivePatternCase \nActivePatternCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#ActivePatternResult","title":"TextTag.ActivePatternResult","content":"TextTag.ActivePatternResult \nActivePatternResult \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Alias","title":"TextTag.Alias","content":"TextTag.Alias \nAlias \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Class","title":"TextTag.Class","content":"TextTag.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Union","title":"TextTag.Union","content":"TextTag.Union \nUnion \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#UnionCase","title":"TextTag.UnionCase","content":"TextTag.UnionCase \nUnionCase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Delegate","title":"TextTag.Delegate","content":"TextTag.Delegate \nDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Enum","title":"TextTag.Enum","content":"TextTag.Enum \nEnum \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Event","title":"TextTag.Event","content":"TextTag.Event \nEvent \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Field","title":"TextTag.Field","content":"TextTag.Field \nField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Interface","title":"TextTag.Interface","content":"TextTag.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Keyword","title":"TextTag.Keyword","content":"TextTag.Keyword \nKeyword \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#LineBreak","title":"TextTag.LineBreak","content":"TextTag.LineBreak \nLineBreak \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Local","title":"TextTag.Local","content":"TextTag.Local \nLocal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Record","title":"TextTag.Record","content":"TextTag.Record \nRecord \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#RecordField","title":"TextTag.RecordField","content":"TextTag.RecordField \nRecordField \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Method","title":"TextTag.Method","content":"TextTag.Method \nMethod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Member","title":"TextTag.Member","content":"TextTag.Member \nMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#ModuleBinding","title":"TextTag.ModuleBinding","content":"TextTag.ModuleBinding \nModuleBinding \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Function","title":"TextTag.Function","content":"TextTag.Function \nFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Module","title":"TextTag.Module","content":"TextTag.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Namespace","title":"TextTag.Namespace","content":"TextTag.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#NumericLiteral","title":"TextTag.NumericLiteral","content":"TextTag.NumericLiteral \nNumericLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Operator","title":"TextTag.Operator","content":"TextTag.Operator \nOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Parameter","title":"TextTag.Parameter","content":"TextTag.Parameter \nParameter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Property","title":"TextTag.Property","content":"TextTag.Property \nProperty \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Space","title":"TextTag.Space","content":"TextTag.Space \nSpace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#StringLiteral","title":"TextTag.StringLiteral","content":"TextTag.StringLiteral \nStringLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Struct","title":"TextTag.Struct","content":"TextTag.Struct \nStruct \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#TypeParameter","title":"TextTag.TypeParameter","content":"TextTag.TypeParameter \nTypeParameter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Text","title":"TextTag.Text","content":"TextTag.Text \nText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#Punctuation","title":"TextTag.Punctuation","content":"TextTag.Punctuation \nPunctuation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#UnknownType","title":"TextTag.UnknownType","content":"TextTag.UnknownType \nUnknownType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-texttag.html#UnknownEntity","title":"TextTag.UnknownEntity","content":"TextTag.UnknownEntity \nUnknownEntity \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-pos.html","title":"pos","content":"pos \n Represents a position in a file \npos.Column \nColumn \npos.Line \nLine","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-pos.html#Column","title":"pos.Column","content":"pos.Column \nColumn \n The column number for the position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-pos.html#Line","title":"pos.Line","content":"pos.Line \nLine \n The line number for the position","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html","title":"range","content":"range \n Represents a range within a file \nrange.Start \nStart \nrange.FileName \nFileName \nrange.EndColumn \nEndColumn \nrange.StartRange \nStartRange \nrange.EndRange \nEndRange \nrange.StartColumn \nStartColumn \nrange.End \nEnd \nrange.EndLine \nEndLine \nrange.StartLine \nStartLine \nrange.IsSynthetic \nIsSynthetic \nrange.Zero \nZero","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#Start","title":"range.Start","content":"range.Start \nStart \n The start position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#FileName","title":"range.FileName","content":"range.FileName \nFileName \n The file name for the file of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#EndColumn","title":"range.EndColumn","content":"range.EndColumn \nEndColumn \n The column number for the end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#StartRange","title":"range.StartRange","content":"range.StartRange \nStartRange \n The empty range that is located at the start position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#EndRange","title":"range.EndRange","content":"range.EndRange \nEndRange \n The empty range that is located at the end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#StartColumn","title":"range.StartColumn","content":"range.StartColumn \nStartColumn \n The start column of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#End","title":"range.End","content":"range.End \nEnd \n The end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#EndLine","title":"range.EndLine","content":"range.EndLine \nEndLine \n The line number for the end position of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#StartLine","title":"range.StartLine","content":"range.StartLine \nStartLine \n The start line of the range","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#IsSynthetic","title":"range.IsSynthetic","content":"range.IsSynthetic \nIsSynthetic \n Synthetic marks ranges which are produced by intermediate compilation phases. This\n bit signifies that the range covers something that should not be visible to language\n service operations like dot-completion.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-text-range-0.html#Zero","title":"range.Zero","content":"range.Zero \nZero \n The range where all values are zero","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpkeywords.html","title":"FSharpKeywords","content":"FSharpKeywords \n \nFSharpKeywords.NormalizeIdentifierBackticks \nNormalizeIdentifierBackticks \nFSharpKeywords.KeywordsWithDescription \nKeywordsWithDescription \nFSharpKeywords.KeywordNames \nKeywordNames","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpkeywords.html#NormalizeIdentifierBackticks","title":"FSharpKeywords.NormalizeIdentifierBackticks","content":"FSharpKeywords.NormalizeIdentifierBackticks \nNormalizeIdentifierBackticks \n Add backticks if the identifier is a keyword.\n Remove backticks if present and not needed.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpkeywords.html#KeywordsWithDescription","title":"FSharpKeywords.KeywordsWithDescription","content":"FSharpKeywords.KeywordsWithDescription \nKeywordsWithDescription \n Keywords paired with their descriptions. Used in completion and quick info.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpkeywords.html#KeywordNames","title":"FSharpKeywords.KeywordNames","content":"FSharpKeywords.KeywordNames \nKeywordNames \n All the keywords in the F# language","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html","title":"FSharpTokenTag","content":"FSharpTokenTag \n Some of the values in the field FSharpTokenInfo.Tag \nFSharpTokenTag.Identifier \nIdentifier \nFSharpTokenTag.String \nString \nFSharpTokenTag.IDENT \nIDENT \nFSharpTokenTag.STRING \nSTRING \nFSharpTokenTag.INTERP_STRING_BEGIN_END \nINTERP_STRING_BEGIN_END \nFSharpTokenTag.INTERP_STRING_BEGIN_PART \nINTERP_STRING_BEGIN_PART \nFSharpTokenTag.INTERP_STRING_PART \nINTERP_STRING_PART \nFSharpTokenTag.INTERP_STRING_END \nINTERP_STRING_END \nFSharpTokenTag.LPAREN \nLPAREN \nFSharpTokenTag.RPAREN \nRPAREN \nFSharpTokenTag.LBRACK \nLBRACK \nFSharpTokenTag.RBRACK \nRBRACK \nFSharpTokenTag.LBRACE \nLBRACE \nFSharpTokenTag.RBRACE \nRBRACE \nFSharpTokenTag.LBRACK_LESS \nLBRACK_LESS \nFSharpTokenTag.GREATER_RBRACK \nGREATER_RBRACK \nFSharpTokenTag.LESS \nLESS \nFSharpTokenTag.GREATER \nGREATER \nFSharpTokenTag.LBRACK_BAR \nLBRACK_BAR \nFSharpTokenTag.BAR_RBRACK \nBAR_RBRACK \nFSharpTokenTag.PLUS_MINUS_OP \nPLUS_MINUS_OP \nFSharpTokenTag.MINUS \nMINUS \nFSharpTokenTag.STAR \nSTAR \nFSharpTokenTag.INFIX_STAR_DIV_MOD_OP \nINFIX_STAR_DIV_MOD_OP \nFSharpTokenTag.PERCENT_OP \nPERCENT_OP \nFSharpTokenTag.INFIX_AT_HAT_OP \nINFIX_AT_HAT_OP \nFSharpTokenTag.QMARK \nQMARK \nFSharpTokenTag.COLON \nCOLON \nFSharpTokenTag.EQUALS \nEQUALS \nFSharpTokenTag.SEMICOLON \nSEMICOLON \nFSharpTokenTag.COMMA \nCOMMA \nFSharpTokenTag.DOT \nDOT \nFSharpTokenTag.DOT_DOT \nDOT_DOT \nFSharpTokenTag.DOT_DOT_HAT \nDOT_DOT_HAT \nFSharpTokenTag.INT32_DOT_DOT \nINT32_DOT_DOT \nFSharpTokenTag.UNDERSCORE \nUNDERSCORE \nFSharpTokenTag.BAR \nBAR \nFSharpTokenTag.COLON_GREATER \nCOLON_GREATER \nFSharpTokenTag.COLON_QMARK_GREATER \nCOLON_QMARK_GREATER \nFSharpTokenTag.COLON_QMARK \nCOLON_QMARK \nFSharpTokenTag.INFIX_BAR_OP \nINFIX_BAR_OP \nFSharpTokenTag.INFIX_COMPARE_OP \nINFIX_COMPARE_OP \nFSharpTokenTag.COLON_COLON \nCOLON_COLON \nFSharpTokenTag.AMP_AMP \nAMP_AMP \nFSharpTokenTag.PREFIX_OP \nPREFIX_OP \nFSharpTokenTag.COLON_EQUALS \nCOLON_EQUALS \nFSharpTokenTag.BAR_BAR \nBAR_BAR \nFSharpTokenTag.RARROW \nRARROW \nFSharpTokenTag.LARROW \nLARROW \nFSharpTokenTag.QUOTE \nQUOTE \nFSharpTokenTag.WHITESPACE \nWHITESPACE \nFSharpTokenTag.COMMENT \nCOMMENT \nFSharpTokenTag.LINE_COMMENT \nLINE_COMMENT \nFSharpTokenTag.BEGIN \nBEGIN \nFSharpTokenTag.DO \nDO \nFSharpTokenTag.FUNCTION \nFUNCTION \nFSharpTokenTag.THEN \nTHEN \nFSharpTokenTag.ELSE \nELSE \nFSharpTokenTag.STRUCT \nSTRUCT \nFSharpTokenTag.CLASS \nCLASS \nFSharpTokenTag.TRY \nTRY \nFSharpTokenTag.WITH \nWITH \nFSharpTokenTag.OWITH \nOWITH \nFSharpTokenTag.NEW \nNEW","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#Identifier","title":"FSharpTokenTag.Identifier","content":"FSharpTokenTag.Identifier \nIdentifier \n Indicates the token is an identifier","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#String","title":"FSharpTokenTag.String","content":"FSharpTokenTag.String \nString \n Indicates the token is a string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#IDENT","title":"FSharpTokenTag.IDENT","content":"FSharpTokenTag.IDENT \nIDENT \n Indicates the token is an identifier (synonym for FSharpTokenTag.Identifier)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#STRING","title":"FSharpTokenTag.STRING","content":"FSharpTokenTag.STRING \nSTRING \n Indicates the token is a string (synonym for FSharpTokenTag.String)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INTERP_STRING_BEGIN_END","title":"FSharpTokenTag.INTERP_STRING_BEGIN_END","content":"FSharpTokenTag.INTERP_STRING_BEGIN_END \nINTERP_STRING_BEGIN_END \n Indicates the token is a part of an interpolated string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INTERP_STRING_BEGIN_PART","title":"FSharpTokenTag.INTERP_STRING_BEGIN_PART","content":"FSharpTokenTag.INTERP_STRING_BEGIN_PART \nINTERP_STRING_BEGIN_PART \n Indicates the token is a part of an interpolated string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INTERP_STRING_PART","title":"FSharpTokenTag.INTERP_STRING_PART","content":"FSharpTokenTag.INTERP_STRING_PART \nINTERP_STRING_PART \n Indicates the token is a part of an interpolated string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INTERP_STRING_END","title":"FSharpTokenTag.INTERP_STRING_END","content":"FSharpTokenTag.INTERP_STRING_END \nINTERP_STRING_END \n Indicates the token is a part of an interpolated string","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LPAREN","title":"FSharpTokenTag.LPAREN","content":"FSharpTokenTag.LPAREN \nLPAREN \n Indicates the token is a \u0060(\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#RPAREN","title":"FSharpTokenTag.RPAREN","content":"FSharpTokenTag.RPAREN \nRPAREN \n Indicates the token is a \u0060)\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LBRACK","title":"FSharpTokenTag.LBRACK","content":"FSharpTokenTag.LBRACK \nLBRACK \n Indicates the token is a \u0060[\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#RBRACK","title":"FSharpTokenTag.RBRACK","content":"FSharpTokenTag.RBRACK \nRBRACK \n Indicates the token is a \u0060]\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LBRACE","title":"FSharpTokenTag.LBRACE","content":"FSharpTokenTag.LBRACE \nLBRACE \n Indicates the token is a \u0060{\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#RBRACE","title":"FSharpTokenTag.RBRACE","content":"FSharpTokenTag.RBRACE \nRBRACE \n Indicates the token is a \u0060}\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LBRACK_LESS","title":"FSharpTokenTag.LBRACK_LESS","content":"FSharpTokenTag.LBRACK_LESS \nLBRACK_LESS \n Indicates the token is a \u0060[\u003C\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#GREATER_RBRACK","title":"FSharpTokenTag.GREATER_RBRACK","content":"FSharpTokenTag.GREATER_RBRACK \nGREATER_RBRACK \n Indicates the token is a \u0060\u003E]\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LESS","title":"FSharpTokenTag.LESS","content":"FSharpTokenTag.LESS \nLESS \n Indicates the token is a \u0060\u003C\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#GREATER","title":"FSharpTokenTag.GREATER","content":"FSharpTokenTag.GREATER \nGREATER \n Indicates the token is a \u0060\u003E\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LBRACK_BAR","title":"FSharpTokenTag.LBRACK_BAR","content":"FSharpTokenTag.LBRACK_BAR \nLBRACK_BAR \n Indicates the token is a \u0060[|\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#BAR_RBRACK","title":"FSharpTokenTag.BAR_RBRACK","content":"FSharpTokenTag.BAR_RBRACK \nBAR_RBRACK \n Indicates the token is a \u0060|]\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#PLUS_MINUS_OP","title":"FSharpTokenTag.PLUS_MINUS_OP","content":"FSharpTokenTag.PLUS_MINUS_OP \nPLUS_MINUS_OP \n Indicates the token is a \u0060\u002B\u0060 or \u0060-\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#MINUS","title":"FSharpTokenTag.MINUS","content":"FSharpTokenTag.MINUS \nMINUS \n Indicates the token is a \u0060-\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#STAR","title":"FSharpTokenTag.STAR","content":"FSharpTokenTag.STAR \nSTAR \n Indicates the token is a \u0060*\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INFIX_STAR_DIV_MOD_OP","title":"FSharpTokenTag.INFIX_STAR_DIV_MOD_OP","content":"FSharpTokenTag.INFIX_STAR_DIV_MOD_OP \nINFIX_STAR_DIV_MOD_OP \n Indicates the token is a \u0060%\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#PERCENT_OP","title":"FSharpTokenTag.PERCENT_OP","content":"FSharpTokenTag.PERCENT_OP \nPERCENT_OP \n Indicates the token is a \u0060%\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INFIX_AT_HAT_OP","title":"FSharpTokenTag.INFIX_AT_HAT_OP","content":"FSharpTokenTag.INFIX_AT_HAT_OP \nINFIX_AT_HAT_OP \n Indicates the token is a \u0060^\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#QMARK","title":"FSharpTokenTag.QMARK","content":"FSharpTokenTag.QMARK \nQMARK \n Indicates the token is a \u0060?\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COLON","title":"FSharpTokenTag.COLON","content":"FSharpTokenTag.COLON \nCOLON \n Indicates the token is a \u0060:\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#EQUALS","title":"FSharpTokenTag.EQUALS","content":"FSharpTokenTag.EQUALS \nEQUALS \n Indicates the token is a \u0060=\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#SEMICOLON","title":"FSharpTokenTag.SEMICOLON","content":"FSharpTokenTag.SEMICOLON \nSEMICOLON \n Indicates the token is a \u0060;\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COMMA","title":"FSharpTokenTag.COMMA","content":"FSharpTokenTag.COMMA \nCOMMA \n Indicates the token is a \u0060,\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#DOT","title":"FSharpTokenTag.DOT","content":"FSharpTokenTag.DOT \nDOT \n Indicates the token is a \u0060.\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#DOT_DOT","title":"FSharpTokenTag.DOT_DOT","content":"FSharpTokenTag.DOT_DOT \nDOT_DOT \n Indicates the token is a \u0060..\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#DOT_DOT_HAT","title":"FSharpTokenTag.DOT_DOT_HAT","content":"FSharpTokenTag.DOT_DOT_HAT \nDOT_DOT_HAT \n Indicates the token is a \u0060..\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INT32_DOT_DOT","title":"FSharpTokenTag.INT32_DOT_DOT","content":"FSharpTokenTag.INT32_DOT_DOT \nINT32_DOT_DOT \n Indicates the token is a \u0060..^\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#UNDERSCORE","title":"FSharpTokenTag.UNDERSCORE","content":"FSharpTokenTag.UNDERSCORE \nUNDERSCORE \n Indicates the token is a \u0060..\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#BAR","title":"FSharpTokenTag.BAR","content":"FSharpTokenTag.BAR \nBAR \n Indicates the token is a \u0060_\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COLON_GREATER","title":"FSharpTokenTag.COLON_GREATER","content":"FSharpTokenTag.COLON_GREATER \nCOLON_GREATER \n Indicates the token is a \u0060:\u003E\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COLON_QMARK_GREATER","title":"FSharpTokenTag.COLON_QMARK_GREATER","content":"FSharpTokenTag.COLON_QMARK_GREATER \nCOLON_QMARK_GREATER \n Indicates the token is a \u0060:?\u003E\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COLON_QMARK","title":"FSharpTokenTag.COLON_QMARK","content":"FSharpTokenTag.COLON_QMARK \nCOLON_QMARK \n Indicates the token is a \u0060:?\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INFIX_BAR_OP","title":"FSharpTokenTag.INFIX_BAR_OP","content":"FSharpTokenTag.INFIX_BAR_OP \nINFIX_BAR_OP \n Indicates the token is a \u0060|\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#INFIX_COMPARE_OP","title":"FSharpTokenTag.INFIX_COMPARE_OP","content":"FSharpTokenTag.INFIX_COMPARE_OP \nINFIX_COMPARE_OP \n Indicates the token is a \u0060|\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COLON_COLON","title":"FSharpTokenTag.COLON_COLON","content":"FSharpTokenTag.COLON_COLON \nCOLON_COLON \n Indicates the token is a \u0060::\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#AMP_AMP","title":"FSharpTokenTag.AMP_AMP","content":"FSharpTokenTag.AMP_AMP \nAMP_AMP \n Indicates the token is a \u0060@@\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#PREFIX_OP","title":"FSharpTokenTag.PREFIX_OP","content":"FSharpTokenTag.PREFIX_OP \nPREFIX_OP \n Indicates the token is a \u0060~\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COLON_EQUALS","title":"FSharpTokenTag.COLON_EQUALS","content":"FSharpTokenTag.COLON_EQUALS \nCOLON_EQUALS \n Indicates the token is a \u0060:=\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#BAR_BAR","title":"FSharpTokenTag.BAR_BAR","content":"FSharpTokenTag.BAR_BAR \nBAR_BAR \n Indicates the token is a \u0060||\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#RARROW","title":"FSharpTokenTag.RARROW","content":"FSharpTokenTag.RARROW \nRARROW \n Indicates the token is a \u0060-\u003E\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LARROW","title":"FSharpTokenTag.LARROW","content":"FSharpTokenTag.LARROW \nLARROW \n Indicates the token is a \u0060\u003C-\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#QUOTE","title":"FSharpTokenTag.QUOTE","content":"FSharpTokenTag.QUOTE \nQUOTE \n Indicates the token is a \u0060\u0022\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#WHITESPACE","title":"FSharpTokenTag.WHITESPACE","content":"FSharpTokenTag.WHITESPACE \nWHITESPACE \n Indicates the token is a whitespace","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#COMMENT","title":"FSharpTokenTag.COMMENT","content":"FSharpTokenTag.COMMENT \nCOMMENT \n Indicates the token is a comment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#LINE_COMMENT","title":"FSharpTokenTag.LINE_COMMENT","content":"FSharpTokenTag.LINE_COMMENT \nLINE_COMMENT \n Indicates the token is a line comment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#BEGIN","title":"FSharpTokenTag.BEGIN","content":"FSharpTokenTag.BEGIN \nBEGIN \n Indicates the token is keyword \u0060begin\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#DO","title":"FSharpTokenTag.DO","content":"FSharpTokenTag.DO \nDO \n Indicates the token is keyword \u0060do\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#FUNCTION","title":"FSharpTokenTag.FUNCTION","content":"FSharpTokenTag.FUNCTION \nFUNCTION \n Indicates the token is keyword \u0060function\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#THEN","title":"FSharpTokenTag.THEN","content":"FSharpTokenTag.THEN \nTHEN \n Indicates the token is keyword \u0060then\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#ELSE","title":"FSharpTokenTag.ELSE","content":"FSharpTokenTag.ELSE \nELSE \n Indicates the token is keyword \u0060else\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#STRUCT","title":"FSharpTokenTag.STRUCT","content":"FSharpTokenTag.STRUCT \nSTRUCT \n Indicates the token is keyword \u0060struct\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#CLASS","title":"FSharpTokenTag.CLASS","content":"FSharpTokenTag.CLASS \nCLASS \n Indicates the token is keyword \u0060class\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#TRY","title":"FSharpTokenTag.TRY","content":"FSharpTokenTag.TRY \nTRY \n Indicates the token is keyword \u0060try\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#WITH","title":"FSharpTokenTag.WITH","content":"FSharpTokenTag.WITH \nWITH \n Indicates the token is keyword \u0060with\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#OWITH","title":"FSharpTokenTag.OWITH","content":"FSharpTokenTag.OWITH \nOWITH \n Indicates the token is keyword \u0060with\u0060 in #light","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentag.html#NEW","title":"FSharpTokenTag.NEW","content":"FSharpTokenTag.NEW \nNEW \n Indicates the token is keyword \u0060new\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexer.html","title":"FSharpLexer","content":"FSharpLexer \n \nFSharpLexer.Tokenize \nTokenize","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexer.html#Tokenize","title":"FSharpLexer.Tokenize","content":"FSharpLexer.Tokenize \nTokenize \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html","title":"FSharpLexerFlags","content":"FSharpLexerFlags \n \nFSharpLexerFlags.Default \nDefault \nFSharpLexerFlags.LightSyntaxOn \nLightSyntaxOn \nFSharpLexerFlags.Compiling \nCompiling \nFSharpLexerFlags.CompilingFSharpCore \nCompilingFSharpCore \nFSharpLexerFlags.SkipTrivia \nSkipTrivia \nFSharpLexerFlags.UseLexFilter \nUseLexFilter","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html#Default","title":"FSharpLexerFlags.Default","content":"FSharpLexerFlags.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html#LightSyntaxOn","title":"FSharpLexerFlags.LightSyntaxOn","content":"FSharpLexerFlags.LightSyntaxOn \nLightSyntaxOn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html#Compiling","title":"FSharpLexerFlags.Compiling","content":"FSharpLexerFlags.Compiling \nCompiling \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html#CompilingFSharpCore","title":"FSharpLexerFlags.CompilingFSharpCore","content":"FSharpLexerFlags.CompilingFSharpCore \nCompilingFSharpCore \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html#SkipTrivia","title":"FSharpLexerFlags.SkipTrivia","content":"FSharpLexerFlags.SkipTrivia \nSkipTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplexerflags.html#UseLexFilter","title":"FSharpLexerFlags.UseLexFilter","content":"FSharpLexerFlags.UseLexFilter \nUseLexFilter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html","title":"FSharpLineTokenizer","content":"FSharpLineTokenizer \n Object to tokenize a line of F# source code, starting with the given lexState. The lexState should be FSharpTokenizerLexState.Initial for\n the first line of text. Returns an array of ranges of the text and two enumerations categorizing the\n tokens and characters covered by that range, i.e. FSharpTokenColorKind and FSharpTokenCharKind. The enumerations\n are somewhat adhoc but useful enough to give good colorization options to the user in an IDE.\n\n A new lexState is also returned. An IDE-plugin should in general cache the lexState\n values for each line of the edited code. \nFSharpLineTokenizer.ScanToken \nScanToken \nFSharpLineTokenizer.ColorStateOfLexState \nColorStateOfLexState \nFSharpLineTokenizer.LexStateOfColorState \nLexStateOfColorState","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html#ScanToken","title":"FSharpLineTokenizer.ScanToken","content":"FSharpLineTokenizer.ScanToken \nScanToken \n Scan one token from the line","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html#ColorStateOfLexState","title":"FSharpLineTokenizer.ColorStateOfLexState","content":"FSharpLineTokenizer.ColorStateOfLexState \nColorStateOfLexState \n Get the color state from the lexer state","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html#LexStateOfColorState","title":"FSharpLineTokenizer.LexStateOfColorState","content":"FSharpLineTokenizer.LexStateOfColorState \nLexStateOfColorState \n Get a default lexer state for a color state.\n\n NOTE: This may result in an inaccurate lexer state\n not taking into account things such as the #if/#endif and string interpolation context\n within the file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html","title":"FSharpSourceTokenizer","content":"FSharpSourceTokenizer \n Tokenizer for a source file. Holds some expensive-to-compute resources at the scope of the file. \nFSharpSourceTokenizer.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nFSharpSourceTokenizer.CreateBufferTokenizer \nCreateBufferTokenizer \nFSharpSourceTokenizer.CreateLineTokenizer \nCreateLineTokenizer","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html#\u0060\u0060.ctor\u0060\u0060","title":"FSharpSourceTokenizer.\u0060\u0060.ctor\u0060\u0060","content":"FSharpSourceTokenizer.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n Create a tokenizer for a source file.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html#CreateBufferTokenizer","title":"FSharpSourceTokenizer.CreateBufferTokenizer","content":"FSharpSourceTokenizer.CreateBufferTokenizer \nCreateBufferTokenizer \n Create a tokenizer for a line of this source file using a buffer filler","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html#CreateLineTokenizer","title":"FSharpSourceTokenizer.CreateLineTokenizer","content":"FSharpSourceTokenizer.CreateLineTokenizer \nCreateLineTokenizer \n Create a tokenizer for a line of this source file","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html","title":"FSharpToken","content":"FSharpToken \n \nFSharpToken.Range \nRange \nFSharpToken.IsIdentifier \nIsIdentifier \nFSharpToken.IsStringLiteral \nIsStringLiteral \nFSharpToken.IsKeyword \nIsKeyword \nFSharpToken.IsNumericLiteral \nIsNumericLiteral \nFSharpToken.Kind \nKind \nFSharpToken.IsCommentTrivia \nIsCommentTrivia \nFSharpToken.tok \ntok \nFSharpToken.tokRange \ntokRange","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#Range","title":"FSharpToken.Range","content":"FSharpToken.Range \nRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#IsIdentifier","title":"FSharpToken.IsIdentifier","content":"FSharpToken.IsIdentifier \nIsIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#IsStringLiteral","title":"FSharpToken.IsStringLiteral","content":"FSharpToken.IsStringLiteral \nIsStringLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#IsKeyword","title":"FSharpToken.IsKeyword","content":"FSharpToken.IsKeyword \nIsKeyword \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#IsNumericLiteral","title":"FSharpToken.IsNumericLiteral","content":"FSharpToken.IsNumericLiteral \nIsNumericLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#Kind","title":"FSharpToken.Kind","content":"FSharpToken.Kind \nKind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#IsCommentTrivia","title":"FSharpToken.IsCommentTrivia","content":"FSharpToken.IsCommentTrivia \nIsCommentTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#tok","title":"FSharpToken.tok","content":"FSharpToken.tok \ntok \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptoken.html#tokRange","title":"FSharpToken.tokRange","content":"FSharpToken.tokRange \ntokRange \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html","title":"FSharpTokenCharKind","content":"FSharpTokenCharKind \n Gives an indication of the class to assign to the characters of the token an IDE \nFSharpTokenCharKind.Default \nDefault \nFSharpTokenCharKind.Text \nText \nFSharpTokenCharKind.Keyword \nKeyword \nFSharpTokenCharKind.Identifier \nIdentifier \nFSharpTokenCharKind.String \nString \nFSharpTokenCharKind.Literal \nLiteral \nFSharpTokenCharKind.Operator \nOperator \nFSharpTokenCharKind.Delimiter \nDelimiter \nFSharpTokenCharKind.WhiteSpace \nWhiteSpace \nFSharpTokenCharKind.LineComment \nLineComment \nFSharpTokenCharKind.Comment \nComment","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Default","title":"FSharpTokenCharKind.Default","content":"FSharpTokenCharKind.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Text","title":"FSharpTokenCharKind.Text","content":"FSharpTokenCharKind.Text \nText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Keyword","title":"FSharpTokenCharKind.Keyword","content":"FSharpTokenCharKind.Keyword \nKeyword \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Identifier","title":"FSharpTokenCharKind.Identifier","content":"FSharpTokenCharKind.Identifier \nIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#String","title":"FSharpTokenCharKind.String","content":"FSharpTokenCharKind.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Literal","title":"FSharpTokenCharKind.Literal","content":"FSharpTokenCharKind.Literal \nLiteral \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Operator","title":"FSharpTokenCharKind.Operator","content":"FSharpTokenCharKind.Operator \nOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Delimiter","title":"FSharpTokenCharKind.Delimiter","content":"FSharpTokenCharKind.Delimiter \nDelimiter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#WhiteSpace","title":"FSharpTokenCharKind.WhiteSpace","content":"FSharpTokenCharKind.WhiteSpace \nWhiteSpace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#LineComment","title":"FSharpTokenCharKind.LineComment","content":"FSharpTokenCharKind.LineComment \nLineComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencharkind.html#Comment","title":"FSharpTokenCharKind.Comment","content":"FSharpTokenCharKind.Comment \nComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html","title":"FSharpTokenColorKind","content":"FSharpTokenColorKind \n Gives an indication of the color class to assign to the token an IDE \nFSharpTokenColorKind.Default \nDefault \nFSharpTokenColorKind.Text \nText \nFSharpTokenColorKind.Keyword \nKeyword \nFSharpTokenColorKind.Comment \nComment \nFSharpTokenColorKind.Identifier \nIdentifier \nFSharpTokenColorKind.String \nString \nFSharpTokenColorKind.UpperIdentifier \nUpperIdentifier \nFSharpTokenColorKind.InactiveCode \nInactiveCode \nFSharpTokenColorKind.PreprocessorKeyword \nPreprocessorKeyword \nFSharpTokenColorKind.Number \nNumber \nFSharpTokenColorKind.Operator \nOperator \nFSharpTokenColorKind.Punctuation \nPunctuation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Default","title":"FSharpTokenColorKind.Default","content":"FSharpTokenColorKind.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Text","title":"FSharpTokenColorKind.Text","content":"FSharpTokenColorKind.Text \nText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Keyword","title":"FSharpTokenColorKind.Keyword","content":"FSharpTokenColorKind.Keyword \nKeyword \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Comment","title":"FSharpTokenColorKind.Comment","content":"FSharpTokenColorKind.Comment \nComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Identifier","title":"FSharpTokenColorKind.Identifier","content":"FSharpTokenColorKind.Identifier \nIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#String","title":"FSharpTokenColorKind.String","content":"FSharpTokenColorKind.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#UpperIdentifier","title":"FSharpTokenColorKind.UpperIdentifier","content":"FSharpTokenColorKind.UpperIdentifier \nUpperIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#InactiveCode","title":"FSharpTokenColorKind.InactiveCode","content":"FSharpTokenColorKind.InactiveCode \nInactiveCode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#PreprocessorKeyword","title":"FSharpTokenColorKind.PreprocessorKeyword","content":"FSharpTokenColorKind.PreprocessorKeyword \nPreprocessorKeyword \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Number","title":"FSharpTokenColorKind.Number","content":"FSharpTokenColorKind.Number \nNumber \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Operator","title":"FSharpTokenColorKind.Operator","content":"FSharpTokenColorKind.Operator \nOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html#Punctuation","title":"FSharpTokenColorKind.Punctuation","content":"FSharpTokenColorKind.Punctuation \nPunctuation \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html","title":"FSharpTokenInfo","content":"FSharpTokenInfo \n Information about a particular token from the tokenizer \nFSharpTokenInfo.LeftColumn \nLeftColumn \nFSharpTokenInfo.RightColumn \nRightColumn \nFSharpTokenInfo.ColorClass \nColorClass \nFSharpTokenInfo.CharClass \nCharClass \nFSharpTokenInfo.FSharpTokenTriggerClass \nFSharpTokenTriggerClass \nFSharpTokenInfo.Tag \nTag \nFSharpTokenInfo.TokenName \nTokenName \nFSharpTokenInfo.FullMatchedLength \nFullMatchedLength","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#LeftColumn","title":"FSharpTokenInfo.LeftColumn","content":"FSharpTokenInfo.LeftColumn \nLeftColumn \n Left column of the token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#RightColumn","title":"FSharpTokenInfo.RightColumn","content":"FSharpTokenInfo.RightColumn \nRightColumn \n Right column of the token.","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#ColorClass","title":"FSharpTokenInfo.ColorClass","content":"FSharpTokenInfo.ColorClass \nColorClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#CharClass","title":"FSharpTokenInfo.CharClass","content":"FSharpTokenInfo.CharClass \nCharClass \n Gives an indication of the class to assign to the token an IDE","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#FSharpTokenTriggerClass","title":"FSharpTokenInfo.FSharpTokenTriggerClass","content":"FSharpTokenInfo.FSharpTokenTriggerClass \nFSharpTokenTriggerClass \n Actions taken when the token is typed","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#Tag","title":"FSharpTokenInfo.Tag","content":"FSharpTokenInfo.Tag \nTag \n The tag is an integer identifier for the token","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#TokenName","title":"FSharpTokenInfo.TokenName","content":"FSharpTokenInfo.TokenName \nTokenName \n Provides additional information about the token","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokeninfo.html#FullMatchedLength","title":"FSharpTokenInfo.FullMatchedLength","content":"FSharpTokenInfo.FullMatchedLength \nFullMatchedLength \n The full length consumed by this match, including delayed tokens (which can be ignored in naive lexers)","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html","title":"FSharpTokenKind","content":"FSharpTokenKind \n \nFSharpTokenKind.None \nNone \nFSharpTokenKind.HashIf \nHashIf \nFSharpTokenKind.HashElse \nHashElse \nFSharpTokenKind.HashEndIf \nHashEndIf \nFSharpTokenKind.CommentTrivia \nCommentTrivia \nFSharpTokenKind.WhitespaceTrivia \nWhitespaceTrivia \nFSharpTokenKind.HashLine \nHashLine \nFSharpTokenKind.HashLight \nHashLight \nFSharpTokenKind.InactiveCode \nInactiveCode \nFSharpTokenKind.LineCommentTrivia \nLineCommentTrivia \nFSharpTokenKind.StringText \nStringText \nFSharpTokenKind.Fixed \nFixed \nFSharpTokenKind.OffsideInterfaceMember \nOffsideInterfaceMember \nFSharpTokenKind.OffsideBlockEnd \nOffsideBlockEnd \nFSharpTokenKind.OffsideRightBlockEnd \nOffsideRightBlockEnd \nFSharpTokenKind.OffsideDeclEnd \nOffsideDeclEnd \nFSharpTokenKind.OffsideEnd \nOffsideEnd \nFSharpTokenKind.OffsideBlockSep \nOffsideBlockSep \nFSharpTokenKind.OffsideBlockBegin \nOffsideBlockBegin \nFSharpTokenKind.OffsideReset \nOffsideReset \nFSharpTokenKind.OffsideFun \nOffsideFun \nFSharpTokenKind.OffsideFunction \nOffsideFunction \nFSharpTokenKind.OffsideWith \nOffsideWith \nFSharpTokenKind.OffsideElse \nOffsideElse \nFSharpTokenKind.OffsideThen \nOffsideThen \nFSharpTokenKind.OffsideDoBang \nOffsideDoBang \nFSharpTokenKind.OffsideDo \nOffsideDo \nFSharpTokenKind.OffsideBinder \nOffsideBinder \nFSharpTokenKind.OffsideLet \nOffsideLet \nFSharpTokenKind.HighPrecedenceTypeApp \nHighPrecedenceTypeApp \nFSharpTokenKind.HighPrecedenceParenthesisApp \nHighPrecedenceParenthesisApp \nFSharpTokenKind.HighPrecedenceBracketApp \nHighPrecedenceBracketApp \nFSharpTokenKind.Extern \nExtern \nFSharpTokenKind.Void \nVoid \nFSharpTokenKind.Public \nPublic \nFSharpTokenKind.Private \nPrivate \nFSharpTokenKind.Internal \nInternal \nFSharpTokenKind.Global \nGlobal \nFSharpTokenKind.Static \nStatic \nFSharpTokenKind.Member \nMember \nFSharpTokenKind.Class \nClass \nFSharpTokenKind.Abstract \nAbstract \nFSharpTokenKind.Override \nOverride \nFSharpTokenKind.Default \nDefault \nFSharpTokenKind.Constructor \nConstructor \nFSharpTokenKind.Inherit \nInherit \nFSharpTokenKind.GreaterRightBracket \nGreaterRightBracket \nFSharpTokenKind.Struct \nStruct \nFSharpTokenKind.Sig \nSig \nFSharpTokenKind.Bar \nBar \nFSharpTokenKind.RightBracket \nRightBracket \nFSharpTokenKind.RightBrace \nRightBrace \nFSharpTokenKind.Minus \nMinus \nFSharpTokenKind.Dollar \nDollar \nFSharpTokenKind.BarRightBracket \nBarRightBracket \nFSharpTokenKind.BarRightBrace \nBarRightBrace \nFSharpTokenKind.Underscore \nUnderscore \nFSharpTokenKind.Semicolon \nSemicolon \nFSharpTokenKind.SemicolonSemicolon \nSemicolonSemicolon \nFSharpTokenKind.LeftArrow \nLeftArrow \nFSharpTokenKind.Equals \nEquals \nFSharpTokenKind.LeftBracket \nLeftBracket \nFSharpTokenKind.LeftBracketBar \nLeftBracketBar \nFSharpTokenKind.LeftBraceBar \nLeftBraceBar \nFSharpTokenKind.LeftBracketLess \nLeftBracketLess \nFSharpTokenKind.LeftBrace \nLeftBrace \nFSharpTokenKind.QuestionMark \nQuestionMark \nFSharpTokenKind.QuestionMarkQuestionMark \nQuestionMarkQuestionMark \nFSharpTokenKind.Dot \nDot \nFSharpTokenKind.Colon \nColon \nFSharpTokenKind.ColonColon \nColonColon \nFSharpTokenKind.ColonGreater \nColonGreater \nFSharpTokenKind.ColonQuestionMark \nColonQuestionMark \nFSharpTokenKind.ColonQuestionMarkGreater \nColonQuestionMarkGreater \nFSharpTokenKind.ColonEquals \nColonEquals \nFSharpTokenKind.When \nWhen \nFSharpTokenKind.While \nWhile \nFSharpTokenKind.WhileBang \nWhileBang \nFSharpTokenKind.With \nWith \nFSharpTokenKind.Hash \nHash \nFSharpTokenKind.Ampersand \nAmpersand \nFSharpTokenKind.AmpersandAmpersand \nAmpersandAmpersand \nFSharpTokenKind.Quote \nQuote \nFSharpTokenKind.LeftParenthesis \nLeftParenthesis \nFSharpTokenKind.RightParenthesis \nRightParenthesis \nFSharpTokenKind.Star \nStar \nFSharpTokenKind.Comma \nComma \nFSharpTokenKind.RightArrow \nRightArrow \nFSharpTokenKind.GreaterBarRightBracket \nGreaterBarRightBracket \nFSharpTokenKind.LeftParenthesisStarRightParenthesis \nLeftParenthesisStarRightParenthesis \nFSharpTokenKind.Open \nOpen \nFSharpTokenKind.Or \nOr \nFSharpTokenKind.Rec \nRec \nFSharpTokenKind.Then \nThen \nFSharpTokenKind.To \nTo \nFSharpTokenKind.True \nTrue \nFSharpTokenKind.Try \nTry \nFSharpTokenKind.Type \nType \nFSharpTokenKind.Val \nVal \nFSharpTokenKind.Inline \nInline \nFSharpTokenKind.Interface \nInterface \nFSharpTokenKind.Instance \nInstance \nFSharpTokenKind.Const \nConst \nFSharpTokenKind.Lazy \nLazy \nFSharpTokenKind.OffsideLazy \nOffsideLazy \nFSharpTokenKind.Match \nMatch \nFSharpTokenKind.MatchBang \nMatchBang \nFSharpTokenKind.Mutable \nMutable \nFSharpTokenKind.New \nNew \nFSharpTokenKind.Of \nOf \nFSharpTokenKind.Exception \nException \nFSharpTokenKind.False \nFalse \nFSharpTokenKind.For \nFor \nFSharpTokenKind.Fun \nFun \nFSharpTokenKind.Function \nFunction \nFSharpTokenKind.If \nIf \nFSharpTokenKind.In \nIn \nFSharpTokenKind.JoinIn \nJoinIn \nFSharpTokenKind.Finally \nFinally \nFSharpTokenKind.DoBang \nDoBang \nFSharpTokenKind.And \nAnd \nFSharpTokenKind.As \nAs \nFSharpTokenKind.Assert \nAssert \nFSharpTokenKind.OffsideAssert \nOffsideAssert \nFSharpTokenKind.Begin \nBegin \nFSharpTokenKind.Do \nDo \nFSharpTokenKind.Done \nDone \nFSharpTokenKind.DownTo \nDownTo \nFSharpTokenKind.Else \nElse \nFSharpTokenKind.Elif \nElif \nFSharpTokenKind.End \nEnd \nFSharpTokenKind.DotDot \nDotDot \nFSharpTokenKind.DotDotHat \nDotDotHat \nFSharpTokenKind.BarBar \nBarBar \nFSharpTokenKind.Upcast \nUpcast \nFSharpTokenKind.Downcast \nDowncast \nFSharpTokenKind.Null \nNull \nFSharpTokenKind.Reserved \nReserved \nFSharpTokenKind.Module \nModule \nFSharpTokenKind.Namespace \nNamespace \nFSharpTokenKind.Delegate \nDelegate \nFSharpTokenKind.Constraint \nConstraint \nFSharpTokenKind.Base \nBase \nFSharpTokenKind.LeftQuote \nLeftQuote \nFSharpTokenKind.RightQuote \nRightQuote \nFSharpTokenKind.RightQuoteDot \nRightQuoteDot \nFSharpTokenKind.PercentOperator \nPercentOperator \nFSharpTokenKind.Binder \nBinder \nFSharpTokenKind.Less \nLess \nFSharpTokenKind.Greater \nGreater \nFSharpTokenKind.Let \nLet \nFSharpTokenKind.Yield \nYield \nFSharpTokenKind.YieldBang \nYieldBang \nFSharpTokenKind.BigNumber \nBigNumber \nFSharpTokenKind.Decimal \nDecimal \nFSharpTokenKind.Char \nChar \nFSharpTokenKind.Ieee64 \nIeee64 \nFSharpTokenKind.Ieee32 \nIeee32 \nFSharpTokenKind.NativeInt \nNativeInt \nFSharpTokenKind.UNativeInt \nUNativeInt \nFSharpTokenKind.UInt64 \nUInt64 \nFSharpTokenKind.UInt32 \nUInt32 \nFSharpTokenKind.UInt16 \nUInt16 \nFSharpTokenKind.UInt8 \nUInt8 \nFSharpTokenKind.Int64 \nInt64 \nFSharpTokenKind.Int32 \nInt32 \nFSharpTokenKind.Int32DotDot \nInt32DotDot \nFSharpTokenKind.Int16 \nInt16 \nFSharpTokenKind.Int8 \nInt8 \nFSharpTokenKind.FunkyOperatorName \nFunkyOperatorName \nFSharpTokenKind.AdjacentPrefixOperator \nAdjacentPrefixOperator \nFSharpTokenKind.PlusMinusOperator \nPlusMinusOperator \nFSharpTokenKind.InfixAmpersandOperator \nInfixAmpersandOperator \nFSharpTokenKind.InfixStarDivideModuloOperator \nInfixStarDivideModuloOperator \nFSharpTokenKind.PrefixOperator \nPrefixOperator \nFSharpTokenKind.InfixBarOperator \nInfixBarOperator \nFSharpTokenKind.InfixAtHatOperator \nInfixAtHatOperator \nFSharpTokenKind.InfixCompareOperator \nInfixCompareOperator \nFSharpTokenKind.InfixStarStarOperator \nInfixStarStarOperator \nFSharpTokenKind.Identifier \nIdentifier \nFSharpTokenKind.KeywordString \nKeywordString \nFSharpTokenKind.String \nString \nFSharpTokenKind.ByteArray \nByteArray \nFSharpTokenKind.Asr \nAsr \nFSharpTokenKind.InfixAsr \nInfixAsr \nFSharpTokenKind.InfixLand \nInfixLand \nFSharpTokenKind.InfixLor \nInfixLor \nFSharpTokenKind.InfixLsl \nInfixLsl \nFSharpTokenKind.InfixLsr \nInfixLsr \nFSharpTokenKind.InfixLxor \nInfixLxor \nFSharpTokenKind.InfixMod \nInfixMod","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#None","title":"FSharpTokenKind.None","content":"FSharpTokenKind.None \nNone \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HashIf","title":"FSharpTokenKind.HashIf","content":"FSharpTokenKind.HashIf \nHashIf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HashElse","title":"FSharpTokenKind.HashElse","content":"FSharpTokenKind.HashElse \nHashElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HashEndIf","title":"FSharpTokenKind.HashEndIf","content":"FSharpTokenKind.HashEndIf \nHashEndIf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#CommentTrivia","title":"FSharpTokenKind.CommentTrivia","content":"FSharpTokenKind.CommentTrivia \nCommentTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#WhitespaceTrivia","title":"FSharpTokenKind.WhitespaceTrivia","content":"FSharpTokenKind.WhitespaceTrivia \nWhitespaceTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HashLine","title":"FSharpTokenKind.HashLine","content":"FSharpTokenKind.HashLine \nHashLine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HashLight","title":"FSharpTokenKind.HashLight","content":"FSharpTokenKind.HashLight \nHashLight \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InactiveCode","title":"FSharpTokenKind.InactiveCode","content":"FSharpTokenKind.InactiveCode \nInactiveCode \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LineCommentTrivia","title":"FSharpTokenKind.LineCommentTrivia","content":"FSharpTokenKind.LineCommentTrivia \nLineCommentTrivia \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#StringText","title":"FSharpTokenKind.StringText","content":"FSharpTokenKind.StringText \nStringText \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Fixed","title":"FSharpTokenKind.Fixed","content":"FSharpTokenKind.Fixed \nFixed \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideInterfaceMember","title":"FSharpTokenKind.OffsideInterfaceMember","content":"FSharpTokenKind.OffsideInterfaceMember \nOffsideInterfaceMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideBlockEnd","title":"FSharpTokenKind.OffsideBlockEnd","content":"FSharpTokenKind.OffsideBlockEnd \nOffsideBlockEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideRightBlockEnd","title":"FSharpTokenKind.OffsideRightBlockEnd","content":"FSharpTokenKind.OffsideRightBlockEnd \nOffsideRightBlockEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideDeclEnd","title":"FSharpTokenKind.OffsideDeclEnd","content":"FSharpTokenKind.OffsideDeclEnd \nOffsideDeclEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideEnd","title":"FSharpTokenKind.OffsideEnd","content":"FSharpTokenKind.OffsideEnd \nOffsideEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideBlockSep","title":"FSharpTokenKind.OffsideBlockSep","content":"FSharpTokenKind.OffsideBlockSep \nOffsideBlockSep \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideBlockBegin","title":"FSharpTokenKind.OffsideBlockBegin","content":"FSharpTokenKind.OffsideBlockBegin \nOffsideBlockBegin \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideReset","title":"FSharpTokenKind.OffsideReset","content":"FSharpTokenKind.OffsideReset \nOffsideReset \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideFun","title":"FSharpTokenKind.OffsideFun","content":"FSharpTokenKind.OffsideFun \nOffsideFun \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideFunction","title":"FSharpTokenKind.OffsideFunction","content":"FSharpTokenKind.OffsideFunction \nOffsideFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideWith","title":"FSharpTokenKind.OffsideWith","content":"FSharpTokenKind.OffsideWith \nOffsideWith \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideElse","title":"FSharpTokenKind.OffsideElse","content":"FSharpTokenKind.OffsideElse \nOffsideElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideThen","title":"FSharpTokenKind.OffsideThen","content":"FSharpTokenKind.OffsideThen \nOffsideThen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideDoBang","title":"FSharpTokenKind.OffsideDoBang","content":"FSharpTokenKind.OffsideDoBang \nOffsideDoBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideDo","title":"FSharpTokenKind.OffsideDo","content":"FSharpTokenKind.OffsideDo \nOffsideDo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideBinder","title":"FSharpTokenKind.OffsideBinder","content":"FSharpTokenKind.OffsideBinder \nOffsideBinder \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideLet","title":"FSharpTokenKind.OffsideLet","content":"FSharpTokenKind.OffsideLet \nOffsideLet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HighPrecedenceTypeApp","title":"FSharpTokenKind.HighPrecedenceTypeApp","content":"FSharpTokenKind.HighPrecedenceTypeApp \nHighPrecedenceTypeApp \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HighPrecedenceParenthesisApp","title":"FSharpTokenKind.HighPrecedenceParenthesisApp","content":"FSharpTokenKind.HighPrecedenceParenthesisApp \nHighPrecedenceParenthesisApp \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#HighPrecedenceBracketApp","title":"FSharpTokenKind.HighPrecedenceBracketApp","content":"FSharpTokenKind.HighPrecedenceBracketApp \nHighPrecedenceBracketApp \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Extern","title":"FSharpTokenKind.Extern","content":"FSharpTokenKind.Extern \nExtern \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Void","title":"FSharpTokenKind.Void","content":"FSharpTokenKind.Void \nVoid \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Public","title":"FSharpTokenKind.Public","content":"FSharpTokenKind.Public \nPublic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Private","title":"FSharpTokenKind.Private","content":"FSharpTokenKind.Private \nPrivate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Internal","title":"FSharpTokenKind.Internal","content":"FSharpTokenKind.Internal \nInternal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Global","title":"FSharpTokenKind.Global","content":"FSharpTokenKind.Global \nGlobal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Static","title":"FSharpTokenKind.Static","content":"FSharpTokenKind.Static \nStatic \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Member","title":"FSharpTokenKind.Member","content":"FSharpTokenKind.Member \nMember \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Class","title":"FSharpTokenKind.Class","content":"FSharpTokenKind.Class \nClass \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Abstract","title":"FSharpTokenKind.Abstract","content":"FSharpTokenKind.Abstract \nAbstract \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Override","title":"FSharpTokenKind.Override","content":"FSharpTokenKind.Override \nOverride \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Default","title":"FSharpTokenKind.Default","content":"FSharpTokenKind.Default \nDefault \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Constructor","title":"FSharpTokenKind.Constructor","content":"FSharpTokenKind.Constructor \nConstructor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Inherit","title":"FSharpTokenKind.Inherit","content":"FSharpTokenKind.Inherit \nInherit \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#GreaterRightBracket","title":"FSharpTokenKind.GreaterRightBracket","content":"FSharpTokenKind.GreaterRightBracket \nGreaterRightBracket \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Struct","title":"FSharpTokenKind.Struct","content":"FSharpTokenKind.Struct \nStruct \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Sig","title":"FSharpTokenKind.Sig","content":"FSharpTokenKind.Sig \nSig \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Bar","title":"FSharpTokenKind.Bar","content":"FSharpTokenKind.Bar \nBar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#RightBracket","title":"FSharpTokenKind.RightBracket","content":"FSharpTokenKind.RightBracket \nRightBracket \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#RightBrace","title":"FSharpTokenKind.RightBrace","content":"FSharpTokenKind.RightBrace \nRightBrace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Minus","title":"FSharpTokenKind.Minus","content":"FSharpTokenKind.Minus \nMinus \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Dollar","title":"FSharpTokenKind.Dollar","content":"FSharpTokenKind.Dollar \nDollar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#BarRightBracket","title":"FSharpTokenKind.BarRightBracket","content":"FSharpTokenKind.BarRightBracket \nBarRightBracket \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#BarRightBrace","title":"FSharpTokenKind.BarRightBrace","content":"FSharpTokenKind.BarRightBrace \nBarRightBrace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Underscore","title":"FSharpTokenKind.Underscore","content":"FSharpTokenKind.Underscore \nUnderscore \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Semicolon","title":"FSharpTokenKind.Semicolon","content":"FSharpTokenKind.Semicolon \nSemicolon \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#SemicolonSemicolon","title":"FSharpTokenKind.SemicolonSemicolon","content":"FSharpTokenKind.SemicolonSemicolon \nSemicolonSemicolon \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftArrow","title":"FSharpTokenKind.LeftArrow","content":"FSharpTokenKind.LeftArrow \nLeftArrow \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Equals","title":"FSharpTokenKind.Equals","content":"FSharpTokenKind.Equals \nEquals \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftBracket","title":"FSharpTokenKind.LeftBracket","content":"FSharpTokenKind.LeftBracket \nLeftBracket \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftBracketBar","title":"FSharpTokenKind.LeftBracketBar","content":"FSharpTokenKind.LeftBracketBar \nLeftBracketBar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftBraceBar","title":"FSharpTokenKind.LeftBraceBar","content":"FSharpTokenKind.LeftBraceBar \nLeftBraceBar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftBracketLess","title":"FSharpTokenKind.LeftBracketLess","content":"FSharpTokenKind.LeftBracketLess \nLeftBracketLess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftBrace","title":"FSharpTokenKind.LeftBrace","content":"FSharpTokenKind.LeftBrace \nLeftBrace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#QuestionMark","title":"FSharpTokenKind.QuestionMark","content":"FSharpTokenKind.QuestionMark \nQuestionMark \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#QuestionMarkQuestionMark","title":"FSharpTokenKind.QuestionMarkQuestionMark","content":"FSharpTokenKind.QuestionMarkQuestionMark \nQuestionMarkQuestionMark \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Dot","title":"FSharpTokenKind.Dot","content":"FSharpTokenKind.Dot \nDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Colon","title":"FSharpTokenKind.Colon","content":"FSharpTokenKind.Colon \nColon \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#ColonColon","title":"FSharpTokenKind.ColonColon","content":"FSharpTokenKind.ColonColon \nColonColon \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#ColonGreater","title":"FSharpTokenKind.ColonGreater","content":"FSharpTokenKind.ColonGreater \nColonGreater \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#ColonQuestionMark","title":"FSharpTokenKind.ColonQuestionMark","content":"FSharpTokenKind.ColonQuestionMark \nColonQuestionMark \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#ColonQuestionMarkGreater","title":"FSharpTokenKind.ColonQuestionMarkGreater","content":"FSharpTokenKind.ColonQuestionMarkGreater \nColonQuestionMarkGreater \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#ColonEquals","title":"FSharpTokenKind.ColonEquals","content":"FSharpTokenKind.ColonEquals \nColonEquals \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#When","title":"FSharpTokenKind.When","content":"FSharpTokenKind.When \nWhen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#While","title":"FSharpTokenKind.While","content":"FSharpTokenKind.While \nWhile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#WhileBang","title":"FSharpTokenKind.WhileBang","content":"FSharpTokenKind.WhileBang \nWhileBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#With","title":"FSharpTokenKind.With","content":"FSharpTokenKind.With \nWith \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Hash","title":"FSharpTokenKind.Hash","content":"FSharpTokenKind.Hash \nHash \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Ampersand","title":"FSharpTokenKind.Ampersand","content":"FSharpTokenKind.Ampersand \nAmpersand \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#AmpersandAmpersand","title":"FSharpTokenKind.AmpersandAmpersand","content":"FSharpTokenKind.AmpersandAmpersand \nAmpersandAmpersand \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Quote","title":"FSharpTokenKind.Quote","content":"FSharpTokenKind.Quote \nQuote \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftParenthesis","title":"FSharpTokenKind.LeftParenthesis","content":"FSharpTokenKind.LeftParenthesis \nLeftParenthesis \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#RightParenthesis","title":"FSharpTokenKind.RightParenthesis","content":"FSharpTokenKind.RightParenthesis \nRightParenthesis \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Star","title":"FSharpTokenKind.Star","content":"FSharpTokenKind.Star \nStar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Comma","title":"FSharpTokenKind.Comma","content":"FSharpTokenKind.Comma \nComma \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#RightArrow","title":"FSharpTokenKind.RightArrow","content":"FSharpTokenKind.RightArrow \nRightArrow \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#GreaterBarRightBracket","title":"FSharpTokenKind.GreaterBarRightBracket","content":"FSharpTokenKind.GreaterBarRightBracket \nGreaterBarRightBracket \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftParenthesisStarRightParenthesis","title":"FSharpTokenKind.LeftParenthesisStarRightParenthesis","content":"FSharpTokenKind.LeftParenthesisStarRightParenthesis \nLeftParenthesisStarRightParenthesis \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Open","title":"FSharpTokenKind.Open","content":"FSharpTokenKind.Open \nOpen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Or","title":"FSharpTokenKind.Or","content":"FSharpTokenKind.Or \nOr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Rec","title":"FSharpTokenKind.Rec","content":"FSharpTokenKind.Rec \nRec \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Then","title":"FSharpTokenKind.Then","content":"FSharpTokenKind.Then \nThen \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#To","title":"FSharpTokenKind.To","content":"FSharpTokenKind.To \nTo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#True","title":"FSharpTokenKind.True","content":"FSharpTokenKind.True \nTrue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Try","title":"FSharpTokenKind.Try","content":"FSharpTokenKind.Try \nTry \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Type","title":"FSharpTokenKind.Type","content":"FSharpTokenKind.Type \nType \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Val","title":"FSharpTokenKind.Val","content":"FSharpTokenKind.Val \nVal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Inline","title":"FSharpTokenKind.Inline","content":"FSharpTokenKind.Inline \nInline \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Interface","title":"FSharpTokenKind.Interface","content":"FSharpTokenKind.Interface \nInterface \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Instance","title":"FSharpTokenKind.Instance","content":"FSharpTokenKind.Instance \nInstance \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Const","title":"FSharpTokenKind.Const","content":"FSharpTokenKind.Const \nConst \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Lazy","title":"FSharpTokenKind.Lazy","content":"FSharpTokenKind.Lazy \nLazy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideLazy","title":"FSharpTokenKind.OffsideLazy","content":"FSharpTokenKind.OffsideLazy \nOffsideLazy \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Match","title":"FSharpTokenKind.Match","content":"FSharpTokenKind.Match \nMatch \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#MatchBang","title":"FSharpTokenKind.MatchBang","content":"FSharpTokenKind.MatchBang \nMatchBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Mutable","title":"FSharpTokenKind.Mutable","content":"FSharpTokenKind.Mutable \nMutable \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#New","title":"FSharpTokenKind.New","content":"FSharpTokenKind.New \nNew \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Of","title":"FSharpTokenKind.Of","content":"FSharpTokenKind.Of \nOf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Exception","title":"FSharpTokenKind.Exception","content":"FSharpTokenKind.Exception \nException \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#False","title":"FSharpTokenKind.False","content":"FSharpTokenKind.False \nFalse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#For","title":"FSharpTokenKind.For","content":"FSharpTokenKind.For \nFor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Fun","title":"FSharpTokenKind.Fun","content":"FSharpTokenKind.Fun \nFun \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Function","title":"FSharpTokenKind.Function","content":"FSharpTokenKind.Function \nFunction \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#If","title":"FSharpTokenKind.If","content":"FSharpTokenKind.If \nIf \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#In","title":"FSharpTokenKind.In","content":"FSharpTokenKind.In \nIn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#JoinIn","title":"FSharpTokenKind.JoinIn","content":"FSharpTokenKind.JoinIn \nJoinIn \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Finally","title":"FSharpTokenKind.Finally","content":"FSharpTokenKind.Finally \nFinally \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#DoBang","title":"FSharpTokenKind.DoBang","content":"FSharpTokenKind.DoBang \nDoBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#And","title":"FSharpTokenKind.And","content":"FSharpTokenKind.And \nAnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#As","title":"FSharpTokenKind.As","content":"FSharpTokenKind.As \nAs \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Assert","title":"FSharpTokenKind.Assert","content":"FSharpTokenKind.Assert \nAssert \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#OffsideAssert","title":"FSharpTokenKind.OffsideAssert","content":"FSharpTokenKind.OffsideAssert \nOffsideAssert \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Begin","title":"FSharpTokenKind.Begin","content":"FSharpTokenKind.Begin \nBegin \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Do","title":"FSharpTokenKind.Do","content":"FSharpTokenKind.Do \nDo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Done","title":"FSharpTokenKind.Done","content":"FSharpTokenKind.Done \nDone \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#DownTo","title":"FSharpTokenKind.DownTo","content":"FSharpTokenKind.DownTo \nDownTo \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Else","title":"FSharpTokenKind.Else","content":"FSharpTokenKind.Else \nElse \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Elif","title":"FSharpTokenKind.Elif","content":"FSharpTokenKind.Elif \nElif \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#End","title":"FSharpTokenKind.End","content":"FSharpTokenKind.End \nEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#DotDot","title":"FSharpTokenKind.DotDot","content":"FSharpTokenKind.DotDot \nDotDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#DotDotHat","title":"FSharpTokenKind.DotDotHat","content":"FSharpTokenKind.DotDotHat \nDotDotHat \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#BarBar","title":"FSharpTokenKind.BarBar","content":"FSharpTokenKind.BarBar \nBarBar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Upcast","title":"FSharpTokenKind.Upcast","content":"FSharpTokenKind.Upcast \nUpcast \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Downcast","title":"FSharpTokenKind.Downcast","content":"FSharpTokenKind.Downcast \nDowncast \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Null","title":"FSharpTokenKind.Null","content":"FSharpTokenKind.Null \nNull \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Reserved","title":"FSharpTokenKind.Reserved","content":"FSharpTokenKind.Reserved \nReserved \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Module","title":"FSharpTokenKind.Module","content":"FSharpTokenKind.Module \nModule \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Namespace","title":"FSharpTokenKind.Namespace","content":"FSharpTokenKind.Namespace \nNamespace \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Delegate","title":"FSharpTokenKind.Delegate","content":"FSharpTokenKind.Delegate \nDelegate \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Constraint","title":"FSharpTokenKind.Constraint","content":"FSharpTokenKind.Constraint \nConstraint \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Base","title":"FSharpTokenKind.Base","content":"FSharpTokenKind.Base \nBase \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#LeftQuote","title":"FSharpTokenKind.LeftQuote","content":"FSharpTokenKind.LeftQuote \nLeftQuote \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#RightQuote","title":"FSharpTokenKind.RightQuote","content":"FSharpTokenKind.RightQuote \nRightQuote \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#RightQuoteDot","title":"FSharpTokenKind.RightQuoteDot","content":"FSharpTokenKind.RightQuoteDot \nRightQuoteDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#PercentOperator","title":"FSharpTokenKind.PercentOperator","content":"FSharpTokenKind.PercentOperator \nPercentOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Binder","title":"FSharpTokenKind.Binder","content":"FSharpTokenKind.Binder \nBinder \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Less","title":"FSharpTokenKind.Less","content":"FSharpTokenKind.Less \nLess \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Greater","title":"FSharpTokenKind.Greater","content":"FSharpTokenKind.Greater \nGreater \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Let","title":"FSharpTokenKind.Let","content":"FSharpTokenKind.Let \nLet \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Yield","title":"FSharpTokenKind.Yield","content":"FSharpTokenKind.Yield \nYield \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#YieldBang","title":"FSharpTokenKind.YieldBang","content":"FSharpTokenKind.YieldBang \nYieldBang \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#BigNumber","title":"FSharpTokenKind.BigNumber","content":"FSharpTokenKind.BigNumber \nBigNumber \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Decimal","title":"FSharpTokenKind.Decimal","content":"FSharpTokenKind.Decimal \nDecimal \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Char","title":"FSharpTokenKind.Char","content":"FSharpTokenKind.Char \nChar \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Ieee64","title":"FSharpTokenKind.Ieee64","content":"FSharpTokenKind.Ieee64 \nIeee64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Ieee32","title":"FSharpTokenKind.Ieee32","content":"FSharpTokenKind.Ieee32 \nIeee32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#NativeInt","title":"FSharpTokenKind.NativeInt","content":"FSharpTokenKind.NativeInt \nNativeInt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#UNativeInt","title":"FSharpTokenKind.UNativeInt","content":"FSharpTokenKind.UNativeInt \nUNativeInt \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#UInt64","title":"FSharpTokenKind.UInt64","content":"FSharpTokenKind.UInt64 \nUInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#UInt32","title":"FSharpTokenKind.UInt32","content":"FSharpTokenKind.UInt32 \nUInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#UInt16","title":"FSharpTokenKind.UInt16","content":"FSharpTokenKind.UInt16 \nUInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#UInt8","title":"FSharpTokenKind.UInt8","content":"FSharpTokenKind.UInt8 \nUInt8 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Int64","title":"FSharpTokenKind.Int64","content":"FSharpTokenKind.Int64 \nInt64 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Int32","title":"FSharpTokenKind.Int32","content":"FSharpTokenKind.Int32 \nInt32 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Int32DotDot","title":"FSharpTokenKind.Int32DotDot","content":"FSharpTokenKind.Int32DotDot \nInt32DotDot \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Int16","title":"FSharpTokenKind.Int16","content":"FSharpTokenKind.Int16 \nInt16 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Int8","title":"FSharpTokenKind.Int8","content":"FSharpTokenKind.Int8 \nInt8 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#FunkyOperatorName","title":"FSharpTokenKind.FunkyOperatorName","content":"FSharpTokenKind.FunkyOperatorName \nFunkyOperatorName \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#AdjacentPrefixOperator","title":"FSharpTokenKind.AdjacentPrefixOperator","content":"FSharpTokenKind.AdjacentPrefixOperator \nAdjacentPrefixOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#PlusMinusOperator","title":"FSharpTokenKind.PlusMinusOperator","content":"FSharpTokenKind.PlusMinusOperator \nPlusMinusOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixAmpersandOperator","title":"FSharpTokenKind.InfixAmpersandOperator","content":"FSharpTokenKind.InfixAmpersandOperator \nInfixAmpersandOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixStarDivideModuloOperator","title":"FSharpTokenKind.InfixStarDivideModuloOperator","content":"FSharpTokenKind.InfixStarDivideModuloOperator \nInfixStarDivideModuloOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#PrefixOperator","title":"FSharpTokenKind.PrefixOperator","content":"FSharpTokenKind.PrefixOperator \nPrefixOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixBarOperator","title":"FSharpTokenKind.InfixBarOperator","content":"FSharpTokenKind.InfixBarOperator \nInfixBarOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixAtHatOperator","title":"FSharpTokenKind.InfixAtHatOperator","content":"FSharpTokenKind.InfixAtHatOperator \nInfixAtHatOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixCompareOperator","title":"FSharpTokenKind.InfixCompareOperator","content":"FSharpTokenKind.InfixCompareOperator \nInfixCompareOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixStarStarOperator","title":"FSharpTokenKind.InfixStarStarOperator","content":"FSharpTokenKind.InfixStarStarOperator \nInfixStarStarOperator \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Identifier","title":"FSharpTokenKind.Identifier","content":"FSharpTokenKind.Identifier \nIdentifier \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#KeywordString","title":"FSharpTokenKind.KeywordString","content":"FSharpTokenKind.KeywordString \nKeywordString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#String","title":"FSharpTokenKind.String","content":"FSharpTokenKind.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#ByteArray","title":"FSharpTokenKind.ByteArray","content":"FSharpTokenKind.ByteArray \nByteArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#Asr","title":"FSharpTokenKind.Asr","content":"FSharpTokenKind.Asr \nAsr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixAsr","title":"FSharpTokenKind.InfixAsr","content":"FSharpTokenKind.InfixAsr \nInfixAsr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixLand","title":"FSharpTokenKind.InfixLand","content":"FSharpTokenKind.InfixLand \nInfixLand \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixLor","title":"FSharpTokenKind.InfixLor","content":"FSharpTokenKind.InfixLor \nInfixLor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixLsl","title":"FSharpTokenKind.InfixLsl","content":"FSharpTokenKind.InfixLsl \nInfixLsl \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixLsr","title":"FSharpTokenKind.InfixLsr","content":"FSharpTokenKind.InfixLsr \nInfixLsr \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixLxor","title":"FSharpTokenKind.InfixLxor","content":"FSharpTokenKind.InfixLxor \nInfixLxor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenkind.html#InfixMod","title":"FSharpTokenKind.InfixMod","content":"FSharpTokenKind.InfixMod \nInfixMod \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html","title":"FSharpTokenTriggerClass","content":"FSharpTokenTriggerClass \n Gives an indication of what should happen when the token is typed in an IDE \nFSharpTokenTriggerClass.None \nNone \nFSharpTokenTriggerClass.MemberSelect \nMemberSelect \nFSharpTokenTriggerClass.MatchBraces \nMatchBraces \nFSharpTokenTriggerClass.ChoiceSelect \nChoiceSelect \nFSharpTokenTriggerClass.MethodTip \nMethodTip \nFSharpTokenTriggerClass.ParamStart \nParamStart \nFSharpTokenTriggerClass.ParamNext \nParamNext \nFSharpTokenTriggerClass.ParamEnd \nParamEnd","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#None","title":"FSharpTokenTriggerClass.None","content":"FSharpTokenTriggerClass.None \nNone \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#MemberSelect","title":"FSharpTokenTriggerClass.MemberSelect","content":"FSharpTokenTriggerClass.MemberSelect \nMemberSelect \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#MatchBraces","title":"FSharpTokenTriggerClass.MatchBraces","content":"FSharpTokenTriggerClass.MatchBraces \nMatchBraces \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#ChoiceSelect","title":"FSharpTokenTriggerClass.ChoiceSelect","content":"FSharpTokenTriggerClass.ChoiceSelect \nChoiceSelect \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#MethodTip","title":"FSharpTokenTriggerClass.MethodTip","content":"FSharpTokenTriggerClass.MethodTip \nMethodTip \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#ParamStart","title":"FSharpTokenTriggerClass.ParamStart","content":"FSharpTokenTriggerClass.ParamStart \nParamStart \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#ParamNext","title":"FSharpTokenTriggerClass.ParamNext","content":"FSharpTokenTriggerClass.ParamNext \nParamNext \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html#ParamEnd","title":"FSharpTokenTriggerClass.ParamEnd","content":"FSharpTokenTriggerClass.ParamEnd \nParamEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html","title":"FSharpTokenizerColorState","content":"FSharpTokenizerColorState \n Represents stable information for the state of the lexing engine at the end of a line \nFSharpTokenizerColorState.Token \nToken \nFSharpTokenizerColorState.IfDefSkip \nIfDefSkip \nFSharpTokenizerColorState.String \nString \nFSharpTokenizerColorState.Comment \nComment \nFSharpTokenizerColorState.StringInComment \nStringInComment \nFSharpTokenizerColorState.VerbatimStringInComment \nVerbatimStringInComment \nFSharpTokenizerColorState.CamlOnly \nCamlOnly \nFSharpTokenizerColorState.VerbatimString \nVerbatimString \nFSharpTokenizerColorState.SingleLineComment \nSingleLineComment \nFSharpTokenizerColorState.EndLineThenSkip \nEndLineThenSkip \nFSharpTokenizerColorState.EndLineThenToken \nEndLineThenToken \nFSharpTokenizerColorState.TripleQuoteString \nTripleQuoteString \nFSharpTokenizerColorState.TripleQuoteStringInComment \nTripleQuoteStringInComment \nFSharpTokenizerColorState.InitialState \nInitialState","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#Token","title":"FSharpTokenizerColorState.Token","content":"FSharpTokenizerColorState.Token \nToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#IfDefSkip","title":"FSharpTokenizerColorState.IfDefSkip","content":"FSharpTokenizerColorState.IfDefSkip \nIfDefSkip \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#String","title":"FSharpTokenizerColorState.String","content":"FSharpTokenizerColorState.String \nString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#Comment","title":"FSharpTokenizerColorState.Comment","content":"FSharpTokenizerColorState.Comment \nComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#StringInComment","title":"FSharpTokenizerColorState.StringInComment","content":"FSharpTokenizerColorState.StringInComment \nStringInComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#VerbatimStringInComment","title":"FSharpTokenizerColorState.VerbatimStringInComment","content":"FSharpTokenizerColorState.VerbatimStringInComment \nVerbatimStringInComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#CamlOnly","title":"FSharpTokenizerColorState.CamlOnly","content":"FSharpTokenizerColorState.CamlOnly \nCamlOnly \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#VerbatimString","title":"FSharpTokenizerColorState.VerbatimString","content":"FSharpTokenizerColorState.VerbatimString \nVerbatimString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#SingleLineComment","title":"FSharpTokenizerColorState.SingleLineComment","content":"FSharpTokenizerColorState.SingleLineComment \nSingleLineComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#EndLineThenSkip","title":"FSharpTokenizerColorState.EndLineThenSkip","content":"FSharpTokenizerColorState.EndLineThenSkip \nEndLineThenSkip \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#EndLineThenToken","title":"FSharpTokenizerColorState.EndLineThenToken","content":"FSharpTokenizerColorState.EndLineThenToken \nEndLineThenToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#TripleQuoteString","title":"FSharpTokenizerColorState.TripleQuoteString","content":"FSharpTokenizerColorState.TripleQuoteString \nTripleQuoteString \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#TripleQuoteStringInComment","title":"FSharpTokenizerColorState.TripleQuoteStringInComment","content":"FSharpTokenizerColorState.TripleQuoteStringInComment \nTripleQuoteStringInComment \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html#InitialState","title":"FSharpTokenizerColorState.InitialState","content":"FSharpTokenizerColorState.InitialState \nInitialState \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html","title":"FSharpTokenizerLexState","content":"FSharpTokenizerLexState \n Represents encoded information for the end-of-line continuation of lexing \nFSharpTokenizerLexState.Equals \nEquals \nFSharpTokenizerLexState.Initial \nInitial \nFSharpTokenizerLexState.PosBits \nPosBits \nFSharpTokenizerLexState.OtherBits \nOtherBits","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html#Equals","title":"FSharpTokenizerLexState.Equals","content":"FSharpTokenizerLexState.Equals \nEquals \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html#Initial","title":"FSharpTokenizerLexState.Initial","content":"FSharpTokenizerLexState.Initial \nInitial \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html#PosBits","title":"FSharpTokenizerLexState.PosBits","content":"FSharpTokenizerLexState.PosBits \nPosBits \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html#OtherBits","title":"FSharpTokenizerLexState.OtherBits","content":"FSharpTokenizerLexState.OtherBits \nOtherBits \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html","title":"PreXmlDoc","content":"PreXmlDoc \n Represents the XmlDoc fragments as collected from the lexer during parsing \nPreXmlDoc.ToXmlDoc \nToXmlDoc \nPreXmlDoc.Range \nRange \nPreXmlDoc.IsEmpty \nIsEmpty \nPreXmlDoc.Create \nCreate \nPreXmlDoc.Merge \nMerge \nPreXmlDoc.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html#ToXmlDoc","title":"PreXmlDoc.ToXmlDoc","content":"PreXmlDoc.ToXmlDoc \nToXmlDoc \n Process and check the PreXmlDoc, checking with respect to the given parameter names","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html#Range","title":"PreXmlDoc.Range","content":"PreXmlDoc.Range \nRange \n Get the overall range of the PreXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html#IsEmpty","title":"PreXmlDoc.IsEmpty","content":"PreXmlDoc.IsEmpty \nIsEmpty \n Indicates if the PreXmlDoc is non-empty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html#Create","title":"PreXmlDoc.Create","content":"PreXmlDoc.Create \nCreate \n Create a PreXmlDoc from a collection of unprocessed lines","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html#Merge","title":"PreXmlDoc.Merge","content":"PreXmlDoc.Merge \nMerge \n Merge two PreXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-prexmldoc.html#Empty","title":"PreXmlDoc.Empty","content":"PreXmlDoc.Empty \nEmpty \n Get the empty PreXmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html","title":"XmlDoc","content":"XmlDoc \n Represents collected XmlDoc lines \nXmlDoc.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nXmlDoc.GetElaboratedXmlLines \nGetElaboratedXmlLines \nXmlDoc.GetXmlText \nGetXmlText \nXmlDoc.Range \nRange \nXmlDoc.IsEmpty \nIsEmpty \nXmlDoc.NonEmpty \nNonEmpty \nXmlDoc.UnprocessedLines \nUnprocessedLines \nXmlDoc.Merge \nMerge \nXmlDoc.Empty \nEmpty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#\u0060\u0060.ctor\u0060\u0060","title":"XmlDoc.\u0060\u0060.ctor\u0060\u0060","content":"XmlDoc.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#GetElaboratedXmlLines","title":"XmlDoc.GetElaboratedXmlLines","content":"XmlDoc.GetElaboratedXmlLines \nGetElaboratedXmlLines \n Get the lines after insertion of implicit summary tags and encoding","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#GetXmlText","title":"XmlDoc.GetXmlText","content":"XmlDoc.GetXmlText \nGetXmlText \n Get the elaborated XML documentation as XML text","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#Range","title":"XmlDoc.Range","content":"XmlDoc.Range \nRange \n Indicates the overall original source range of the XmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#IsEmpty","title":"XmlDoc.IsEmpty","content":"XmlDoc.IsEmpty \nIsEmpty \n Indicates if the XmlDoc is empty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#NonEmpty","title":"XmlDoc.NonEmpty","content":"XmlDoc.NonEmpty \nNonEmpty \n Indicates if the XmlDoc is non-empty","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#UnprocessedLines","title":"XmlDoc.UnprocessedLines","content":"XmlDoc.UnprocessedLines \nUnprocessedLines \n Get the lines before insertion of implicit summary tags and encoding","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#Merge","title":"XmlDoc.Merge","content":"XmlDoc.Merge \nMerge \n Merge two XML documentation","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/fsharp-compiler-xml-xmldoc.html#Empty","title":"XmlDoc.Empty","content":"XmlDoc.Empty \nEmpty \n Get the empty XmlDoc","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy.html","title":"InterruptibleLazy","content":"InterruptibleLazy \n \nInterruptibleLazy.force \nforce","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy.html#force","title":"InterruptibleLazy.force","content":"InterruptibleLazy.force \nforce \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-delayinitarraymap-3.html","title":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E","content":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E \n \nDelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nDelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.CreateDictionary \nCreateDictionary \nDelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.GetArray \nGetArray \nDelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.GetDictionary \nGetDictionary","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-delayinitarraymap-3.html#\u0060\u0060.ctor\u0060\u0060","title":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.\u0060\u0060.ctor\u0060\u0060","content":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-delayinitarraymap-3.html#CreateDictionary","title":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.CreateDictionary","content":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.CreateDictionary \nCreateDictionary \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-delayinitarraymap-3.html#GetArray","title":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.GetArray","content":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.GetArray \nGetArray \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-delayinitarraymap-3.html#GetDictionary","title":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.GetDictionary","content":"DelayInitArrayMap\u003C\u0027T, \u0027TDictKey, \u0027TDictValue\u003E.GetDictionary \nGetDictionary \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy-1.html","title":"InterruptibleLazy\u003C\u0027T\u003E","content":"InterruptibleLazy\u003C\u0027T\u003E \n \nInterruptibleLazy\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nInterruptibleLazy\u003C\u0027T\u003E.Force \nForce \nInterruptibleLazy\u003C\u0027T\u003E.IsValueCreated \nIsValueCreated \nInterruptibleLazy\u003C\u0027T\u003E.Value \nValue \nInterruptibleLazy\u003C\u0027T\u003E.FromValue \nFromValue","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy-1.html#\u0060\u0060.ctor\u0060\u0060","title":"InterruptibleLazy\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"InterruptibleLazy\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy-1.html#Force","title":"InterruptibleLazy\u003C\u0027T\u003E.Force","content":"InterruptibleLazy\u003C\u0027T\u003E.Force \nForce \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy-1.html#IsValueCreated","title":"InterruptibleLazy\u003C\u0027T\u003E.IsValueCreated","content":"InterruptibleLazy\u003C\u0027T\u003E.IsValueCreated \nIsValueCreated \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy-1.html#Value","title":"InterruptibleLazy\u003C\u0027T\u003E.Value","content":"InterruptibleLazy\u003C\u0027T\u003E.Value \nValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/reference/internal-utilities-library-interruptiblelazy-1.html#FromValue","title":"InterruptibleLazy\u003C\u0027T\u003E.FromValue","content":"InterruptibleLazy\u003C\u0027T\u003E.FromValue \nFromValue \n","headings":[],"type":"apiDocs"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/coding-standards.html","title":"Coding standards","content":"\nCoding standards and idioms\nThe F# compiler code base is slowly being updated to better coding standards. There is a long way to go.\nThe future work includes\n\n[ ] Consistent use of fantomas formatting across as much of the codebase as feasible\n[ ] Consistent naming conventions\n[ ] Reduction in line length\n[ ] Reduction in single-character identifiers\n[ ] XML documentation for all types, members and cross-module functions\n\nAbbreviations\nThe compiler codebase uses various abbreviations. Here are some of the most common ones.\n\n\n\nAbbreviation\nMeaning\n\n\n\n\nad\nAccessor domain, meaning the permissions the accessing code has to access other constructs\n\n\namap\nAssembly map, saying how to map IL references to F# CCUs\n\n\narg\nArgument (parameter)\n\n\nargty\nArgument (parameter) type\n\n\narginfo\nArgument (parameter) metadata\n\n\nccu\nReference to an F# compilation unit = an F# DLL (possibly including the DLL being compiled)\n\n\ncelem\nCustom attribute element\n\n\ncenv\nCompilation environment. Means different things in different contexts, but usually a parameter for a single compilation state object being passed through a set of related functions in a single phase. The compilation state is often mutable.\n\n\ncpath\nCompilation path, meaning A.B.C for the overall names containing a type or module definition\n\n\ncss\nConstraint solver state.\n\n\ndenv\nDisplay Environment. Parameters guiding the formatting of types\n\n\neinfo\nAn info object for an event (whether a .NET event, an F# event or a provided event)\n\n\ne\nExpression\n\n\nenv\nEnvironment. Means different things in different contexts, but usually immutable state being passed and adjusted through a set of related functions in a single phase.\n\n\nfinfo\nAn info object for a field (whether a .NET field or a provided field)\n\n\nfref\nA reference to an ILFieldRef Abstract IL node for a field reference. Would normally be modernized to ilFieldRef\n\n\ng\nThe TcGlobals value\n\n\nid\nIdentifier\n\n\nlid\nLong Identifier\n\n\nm\nA source code range marker\n\n\nmimpl\nIL interface method implementation\n\n\nminfo\nAn info object for a method (whether a .NET method, an F# method or a provided method)\n\n\nmk\nMeans make in old fashioned F#/OCaml coding style\n\n\nmodul\na Typed Tree structure for a namespace or F# module\n\n\npat\nPattern, a syntactic AST node representing part of a pattern in a pattern match\n\n\npinfo\nAn info object for a property (whether a .NET property, an F# property or a provided property)\n\n\nrfref\nRecord or class field reference, a reference to a Typed Tree node for a record or class field\n\n\nscoref\nThe scope of a reference in IL metadata, either assembly, .netmodule or local\n\n\nsp\nSequence points or debug points\n\n\nspat\nSimple Pattern, a syntactic AST node representing part of a pattern in a pattern match\n\n\ntau\nA type with the \u0022forall\u0022 nodes stripped off (i.e. the nodes which represent generic type parameters). Comes from the notation \uD835\uDED5 used in type theory\n\n\ntcref\nType constructor reference (an EntityRef)\n\n\ntinst\nType instantiation\n\n\ntpenv\nType parameter environment, tracks the type parameters in scope during type checking\n\n\nty (not: typ)\nType, usually a Typed Tree type\n\n\ntys (not: typs)\nList of types, usually Typed Tree types\n\n\ntypar\nType Parameter\n\n\ntyvar\nType Variable, usually referring to an IL type variable, the compiled form of an F# type parameter\n\n\nucref\nUnion case reference, a reference to a Typed Tree node for a union case\n\n\nvref\nValue reference, a reference to a Typed Tree node for a value\n\n\n\n\n\n\n\nPhase Abbreviation\nMeaning\n\n\n\n\nSyn\nAbstract Syntax Tree\n\n\nTc\nType-checker\n\n\nIL\nAbstract IL = F# representation of .NET IL\n\n\nIlx\nExtended Abstract IL = .NET IL plus a couple of contructs that get erased\n\n\n\n\n","headings":["Coding standards and idioms","Abbreviations"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/representations.html","title":"Representations","content":"\nRepresentation Decisions in the F# Compiler\nConsider the following declarations, all of which look very similar.\nmodule M = \n let z = 1 \n let f = x \u002B z \n \n\ntype C(w: int, z: int) = \n \n let f x = x \u002B z \n let f x = f 3 \u002B x \n \n\nlet g (z: int) = \n let f x = x \u002B 1 \n\nPart of the job of the F# compiler is to \u0022decide\u0022 how these declarations are compiled. The following acts as a guide to how these different bindings are represented and where these decisions are made.\nFirst for module-level let bindings. These representations are decided by code in CheckExpressions.fs and CheckDeclarations.fs based on syntax.\nmodule M = \n let z = 1 // z --\u0026gt; static property \u002B field, required by spec, compiled name mandated\n let f x = x \u002B z // f --\u0026gt; static method, required by spec, compiled name mandated\n\nNext for class-level let bindings. These representations are decided by code in CheckIncrementalClasses.fs based on analysis of use.\n// Decided in CheckIncrementalClasses.fs based on analysis of use\ntype C(w: int, z: int) = // w --\u0026gt; local to object constructor, required by spec\n // z --\u0026gt; private instance field, required by spec\n let f x = x \u002B z // f --\u0026gt; private instance method, required by spec, compiled name not mandated\n // Note: initially uses an ephemeral \u0026#39;f\u0026#39; Val then creates a member Val with compiled name\n \n let f x = f 3 \u002B x // f --\u0026gt; private instance method, required by spec, compiled name not mandated\n // Note: initially uses an ephemeral \u0026#39;f\u0026#39; Val then creates a member Val with compiled name\n \n static let g x = x \u002B 1 // g --\u0026gt; private static method, required by spec, compiled name not mandated, initially uses an ephemeral \u0026#39;g\u0026#39; Val then creates a member Val with compiled name\n \n static let g x = g 3 // g --\u0026gt; private static method, required by spec, compiled name not mandated, initially uses an ephemeral \u0026#39;g\u0026#39; Val then creates a member Val with compiled name\n\nNext for expression-level let bindings. These representations are decided by code in various optimization phases.\nlet g (z: int) = // z --\u0026gt; local \u002B field in closure for \u0026#39;f\u0026#39;, not mandated\n let f x = x \u002B 1 // f --\u0026gt; FSharpFunc value, or maybe a static method, not mandated \n // Decided in various optimization phases\n\n\nNOTE: The representation decision is implied by the addition of ValReprInfo to the Val node.\n\n","headings":["Representation Decisions in the F# Compiler"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/large-inputs-and-stack-overflows.html","title":"Large inputs","content":"\nProcessing large inputs without stack overflows\nThe compiler accepts large inputs such as:\n\nLarge literals, such as let str = \u0022a1\u0022 \u002B \u0022a2\u0022 \u002B ... \u002B \u0022a1000\u0022\nLarge array expressions\nLarge list expressions\nLong lists of sequential expressions\nLong lists of bindings, such as let v1 = e1 in let v2 = e2 in ....\nLong sequences of if .. then ... else expressions\nLong sequences of match x with ... | ... expressions\nCombinations of these\n\nThe compiler performs constant folding for large constants so there are no costs to using them at runtime. However, this is subject to a machine\u0027s stack size when compiling, leading to StackOverflow exceptions if those constants are very large. The same can be observed for certain kinds of array, list, or sequence expressions. This appears to be more prominent when compiling on macOS because macOS has a smaller stack size.\nMany sources of StackOverflow exceptions prior to F# 4.7 when processing these kinds of constructs were resolved by processing them on the heap via continuation passing techniques. This avoids filling data on the stack and appears to have negligible effects on overall throughput or memory usage of the compiler.\nThere are two techniques to deal with this\n\nLinearizing processing of specific input shapes, keeping stacks small\nUsing stack guards to simply temporarily move to a new thread when a certain threshold is reached.\n\nLinearizing processing if certain inputs\nAside from array expressions, most of the previously-listed inputs are called \u0022linear\u0022 expressions. This means that there is a single linear hole in the shape of expressions. For example:\n\nexpr :: HOLE (list expressions or other right-linear constructions)\nexpr; HOLE (sequential expressions)\nlet v = expr in HOLE (let expressions)\nif expr then expr else HOLE (conditional expression)\nmatch expr with pat[vs] -\u0026gt; e1[vs] | pat2 -\u0026gt; HOLE (for example, match expr with Some x -\u0026gt; ... | None -\u0026gt; ...)\n\nProcessing these constructs with continuation passing is more difficult than a more \u0022natural\u0022 approach that would use the stack.\nFor example, consider the following contrived example:\nand remapLinearExpr g compgen tmenv expr contf =\n match expr with\n | Expr.Let (bind, bodyExpr, m, _) -\u0026gt;\n ...\n // tailcall for the linear position\n remapLinearExpr g compgen tmenvinner bodyExpr (contf \u0026lt;\u0026lt; (fun bodyExpr\u0026#39; -\u0026gt;\n ...))\n\n | Expr.Sequential (expr1, expr2, dir, spSeq, m) -\u0026gt;\n ...\n // tailcall for the linear position\n remapLinearExpr g compgen tmenv expr2 (contf \u0026lt;\u0026lt; (fun expr2\u0026#39; -\u0026gt;\n ...))\n\n | LinearMatchExpr (spBind, exprm, dtree, tg1, expr2, sp2, m2, ty) -\u0026gt;\n ...\n // tailcall for the linear position\n remapLinearExpr g compgen tmenv expr2 (contf \u0026lt;\u0026lt; (fun expr2\u0026#39; -\u0026gt; ...))\n\n | LinearOpExpr (op, tyargs, argsFront, argLast, m) -\u0026gt;\n ...\n // tailcall for the linear position\n remapLinearExpr g compgen tmenv argLast (contf \u0026lt;\u0026lt; (fun argLast\u0026#39; -\u0026gt; ...))\n\n | _ -\u0026gt; contf (remapExpr g compgen tmenv e)\n\nand remapExpr (g: TcGlobals) (compgen:ValCopyFlag) (tmenv:Remap) expr =\n match expr with\n ...\n | LinearOpExpr _\n | LinearMatchExpr _\n | Expr.Sequential _\n | Expr.Let _ -\u0026gt; remapLinearExpr g compgen tmenv expr (fun x -\u0026gt; x)\n\nThe remapExpr operation becomes two functions, remapExpr (for non-linear cases) and remapLinearExpr (for linear cases). remapLinearExpr uses tailcalls for constructs in the HOLE positions mentioned previously, passing the result to the continuation.\nSome common aspects of this style of programming are:\n\nThe tell-tale use of contf (continuation function)\nThe processing of the body expression e of a let-expression is tail-recursive, if the next construct is also a let-expression.\nThe processing of the e2 expression of a sequential-expression is tail-recursive\nThe processing of the second expression in a cons is tail-recursive\n\nThe previous example is considered incomplete, because arbitrary combinations of let and sequential expressions aren\u0027t going to be dealt with in a tail-recursive way. The compiler generally tries to do these combinations as well.\nStack Guards\nThe StackGuard type is used to count synchronous recursive processing and move to a new thread if a limit is reached. Compilation globals are re-installed. Sample:\nlet TcStackGuardDepth = StackGuard.GetDepthOption \u0026quot;Tc\u0026quot;\n\n...\n stackGuard = StackGuard(TcMaxStackGuardDepth)\n\nlet rec ....\n\nand TcExpr cenv ty (env: TcEnv) tpenv (expr: SynExpr) =\n\n // Guard the stack for deeply nested expressions\n cenv.stackGuard.Guard \u0026lt;| fun () -\u0026gt;\n\n ...\n\nNote stack guarding doesn\u0027t result in a tailcall so will appear in recursive stack frames, because a counter must be decremented after the call. This is used systematically for recursive processing of:\n\nSyntaxTree SynExpr\nTypedTree Expr\n\nWe don\u0027t use it for other inputs.\n","headings":["Processing large inputs without stack overflows","Linearizing processing if certain inputs","Stack Guards"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fsharp-core-notes.html","title":"Guidance","content":"\nNotes and Guidance on FSharp.Core\nThis technical guide discusses the FSharp.Core library.\nReference documentation for FSharp.Core can be found here: https://fsharp.github.io/fsharp-core-docs/\nMuch of the guidance below applies to any .NET library respecting binary compatibility.\nFSharp.Core is binary compatible\nFSharp.Core is binary compatible across versions of the F# language. For example, this means you can create a newer project with a newer FSharp.Core in an older codebase and things should generally \u0022just work\u0022.\nBinary compatibility means that a component built for X can bind to Y at runtime. It doesn\u0027t mean that Y behaves 100% the same as X, though. For example, an older compiler that doesn\u0027t know how to understand inref\u0026lt;\u0027T\u0026gt; referencing a newer FSharp.Core that has inref\u0026lt;\u0027T\u0026gt; defined may not behave correctly if inref\u0026lt;\u0027T\u0026gt; is used in source.\nFSharp.Core and F# scripts\nF# scripts, executed by F# interactive, execute against the FSharp.Core deployed with the .NET SDK you are using. If you\u0027re expecting to use a more modern library feature and find that it\u0027s missing, it\u0027s likely because you have an older .NET SDK and thus an older F# Interactive. Upgrade your .NET SDK.\nGuidance for package authors\nIf you are authoring a NuGet package for consumption in the F# and .NET ecosystem, you already have to make a decision about functionality vs. reach by deciding what target framework(s) you support.\nAs an F# package author, you also need to make this decision with respect to FSharp.Core:\n\nTargeting an earlier version of FSharp.Core increases your reach because older codebases can use it without issue\nTargeting a newer version of FSharp.Core lets you use and extend newer features\n\nThis decision is critical, because it can have a network effect. If you choose a higher FSharp.Core version, then that also becomes a dependency for any other package that may depend on your package.\nPackage authors should pin their FSharp.Core reference\nThe default templates for F# projects carry an implicit reference to FSharp.Core. This is ideal for application developers, since applications almost always want to be referencing the highest FSharp.Core available to them. As you upgrade your .NET SDK, the FSharp.Core package referenced implicitly will also be upgraded over time, since FSharp.Core is also distributed with the .NET SDK.\nHowever, as a package author this means that unless you reference FSharp.Core explicitly, you will default to the latest possible version and thus eliminate any hope of reaching older projects in older environments.\nHow to explicitly reference FSharp.Core\nIt\u0027s a simple gesture in your project file that pins to FSharp.Core 4.7.2:\n\u0026lt;ItemGroup\u0026gt;\n \u0026lt;PackageReference Update=\u0022FSharp.Core\u0022 Version=\u00224.7.2\u0022 /\u0026gt;\n\u0026lt;/ItemGroup\u0026gt;\n\nOr if you\u0027re using Paket:\nnuget FSharp.Core \u0026gt;= 4.7.2\n\nAnd that\u0027s it!\nCompatibility table\nThe following table can help you decide the minimum language/package version you want to support:\n\n\n\nMinimum F# language version\nMinimum FSharp.Core package version\n\n\n\n\nF# 4.1\n4.3.4\n\n\nF# 4.5\n4.5.2\n\n\nF# 4.6\n4.6.2\n\n\nF# 4.7\n4.7.2\n\n\nF# 5.0\n5.0.0\n\n\nF# 6.0\n6.0.0\n\n\n\n\nIf you want to be compatible with much older projects using an F# 4.0 compiler or earlier, you can still do that but it\u0027s not recommended. People using those codebases should upgrade instead.\nDo not bundle FSharp.Core directly with a library\nDo not include a copy of FSharp.Core with your library or package, such in the lib folder of a package. If you do this, you will create havoc for users of your library.\nThe decision about which FSharp.Core a library binds to is up to the application hosting of the library.\nGuidance for everyone else\nIf you\u0027re not authoring packages for distribution, you have a lot less to worry about.\nIf you are distributing library code across a private organization as if it were a NuGet package, please see the above guidance, as it likely still applies. Otherwise, the below guidance applies.\nApplication authors don\u0027t have to explicitly reference FSharp.Core\nIn general, applications can always just use the latest FSharp.Core bundled in the SDK they are built with.\nC# projects referencing F# projects may need to pin FSharp.Core\nYou can reference an F# project just fine without needing to be explicit about an FSharp.Core reference when using C# projects based on the .NET SDK. References flow transitively for SDK-style projects, so even if you need to use types directly from FSharp.Core (which you probably shouldn\u0027t do anyways) it will pick up the right types from the right assembly.\nIf you do have an explicit FSharp.Core reference in your C# project that you need, you should pin your FSharp.Core reference across your entire codebase. Being in a mixed pinned/non-pinned world is difficult to keep straight over a long period of time.\nGuidance for older projects, compilers, and tools\nModern .NET development, including F#, uses SDK-style projects. You can read about that here: https://learn.microsoft.com/dotnet/core/project-sdk/overview\nIf you are not using SDK-style projects F# projects and/or have an older toolset, the following guidance applies.\nConsider upgrading\nYes, really. The old project system that manages legacy projects is not that good, the compiler is older and unoptimized for supporting larger codebases, tooling is not as responsive, etc. You will really have a much better life if you upgrade. Try out the try-convert tool to do that: https://github.com/dotnet/try-convert\nIf you cannot upgrade for some reason, the rest of the guidance applies.\nAlways deploy FSharp.Core as part of a compiled application\nFor applications, FSharp.Core is normally part of the application itself (so-called \u0022xcopy deploy\u0022 of FSharp.Core).\nFor older project files, you may need to use \u0026lt;Private\u0026gt;true\u0026lt;/Private\u0026gt; in your project file. In Visual Studio this is equivalent to setting the CopyLocal property to true properties for the FSharp.Core reference.\nFSharp.Core.dll will normally appear in the bin output folder for your application. For example:\n Directory of ...\n \n 18/04/2020 13:20 5,632 ConsoleApplication3.exe\n 14/10/2020 12:12 1,400,472 FSharp.Core.dll\n\nFSharp.Core and static linking\nThe ILMerge tool and the F# compiler both allow static linking of assemblies including static linking of FSharp.Core.\nThis can be useful to build a single standalone file for a tool.\nHowever, these options must be used with caution.\n\nOnly use this option for applications, not libraries. If it\u0027s not a .EXE (or a library that is effectively an application) then don\u0027t even try using this option.\n\nSearching on stackoverflow reveals further guidance on this topic.\nReference: FSharp.Core version and NuGet package numbers\nSee the F# version information RFC.\n","headings":["Notes and Guidance on FSharp.Core","FSharp.Core is binary compatible","FSharp.Core and F# scripts","Guidance for package authors","Package authors should pin their FSharp.Core reference","How to explicitly reference FSharp.Core","Compatibility table","Guidance for everyone else","Application authors don\u0027t have to explicitly reference FSharp.Core","C# projects referencing F# projects may need to pin FSharp.Core","Guidance for older projects, compilers, and tools","Consider upgrading","Always deploy FSharp.Core as part of a compiled application","FSharp.Core and static linking","Reference: FSharp.Core version and NuGet package numbers"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fsi-emit.html","title":"F# Interactive Emit","content":"\nF# Interactive Code Generation\nF# Interactive (dotnet fsi) accepts incremental code fragments. This capability is also used by hosted execution capability of the FSharp.Compiler.Service API which is used to build the F# kernel for .NET Interactive notebooks.\nHistorically F# Interactive code was emitted into a single dynamic assembly using Reflection.Emit and ilreflect.fs (meaning one assembly that is continually growing). However, .NET Core Reflection.Emit does not support the emit of debug symbols for dynamic assemblies, so in Feb 2022 we switched to emitting multiple non-dynamic assemblies (meaning assemblies dynamically created in-memory using ilwrite.fs, and loaded, but not growing).\nThe assemblies are named:\nFSI-ASSEMBLY1\nFSI-ASSEMBLY2\netc.\nCompat switch\nThere is a switch fsi --multiemit that turns on the use of multi-assembly generation (when it is off, we use Reflection Emit for single-dynamic-assembly generation). This is on by default for .NET Core, and off by default for .NET Framework for compat reasons.\nAre multiple assemblies too costly?\nThere is general assumption in this that on modern dev machines (where users execute multiple interactions) then generating 50, 100 or 1,000 or 10,000 dynamic assemblies by repeated manual execution of code is not a problem: the extra overheads of multiple assemblies compared to one dynamic assembly is of no real significance in developer REPL scenarios given the vast amount of memory available on modern 64-bit machines.\nQuick check: adding 10,000 let x = 1;; interactions to .NET Core dotnet fsi adds about 300MB to the FSI.EXE process, meaning 30K/interaction. A budget of 1GB for interactive fragments (reasonable on a 64-bit machine), and an expected maximum of 10000 fragments before restart (that\u0027s a lot!), then each fragment can take up to 100K. This is well below the cost of a new assembly.\nAdditionally, these costs are not substantially reduced if --multiemit is disabled, so they\u0027ve always been the approximate costs of F# Interactive fragment generation.\nInternals and accessibility across fragments\nGenerating into multiple assemblies raises issues for some things that are assembly bound such as \u0022internals\u0022 accessibility. In a first iteration of this we had a failing case here:\n\u0026gt; artifacts\n...\n// Fragment 1\n\u0026gt; let internal f() = 1;;\nval internal f: unit -\u0026gt; int\n\n// Fragment 2 - according to existing rules it is allowed to access internal things of the first\nf();; \nSystem.MethodAccessException: Attempt by method \u0026#39;\u0026lt;StartupCode$FSI_0003\u0026gt;FSI_0003.main@()\u0026#39; to access method \u0026#39;FSI_0002.f()\u0026#39; failed.\n at \u0026lt;StartupCode$FSI_0003\u0026gt;FSI_0003.main@()\n\nThis is because we are now generating into multiple assemblies. Another bug was this:\n\u0026gt; artifacts\n...\n// Fragment 1 - not \u0060x\u0060 becomes an internal field of the class\n\u0026gt; type C() =\n\u0026gt; let mutable x = 1\n\u0026gt; member _.M() = x\n\u0026gt; ;;\n...\n// Fragment 2 - inlining \u0026#39;M()\u0026#39; gave an access to the internal field \u0060x\u0060\n\u0026gt; C().M();;\n...\u0026lt;bang\u0026gt;\n\nAccording to the current F# scripting programming model (the one checked in the editor), the \u0022internal\u0022 thing should be accessible in subsequent fragments. Should this be changed? No:\n\nIt\u0027s very hard to adjust the implementation of the editor scripting model to consider fragments delimited by ;; to be different assemblies, whether in the editor or in F# Interactive.\nAnd would we even want to? It\u0027s common enough for people to debug code scattered with \u0022internal\u0022 declarations.\n\nIn scripts, the ;; aren\u0027t actually accurate markers for what will or won\u0027t be sent to F# Interactive, which get added implicitly.\nFor example, consider the script\nlet internal f() = 1;;\nf();; \n\nIn the editor should this be given an error or not? That is, should the ;; be seen as accurate indicators of separate script fragments? (Answer: yes if we know the script will be piped-to-input, no if the script is used as a single file entry - when the ;; are ignored)\n\nFurther, this would be a breaking change, e.g. it could arise in an automated compat situation if people are piping into standard input and the input contains ;; markers.\n\nBecause of this we emit IVTs for the next 30 FSI-ASSEMBLYnnn assemblies on each assembly fragment, giving a warning when an internal thing is accessed across assembly boundaries within that 30 (reporting it as a deprecated feature), and give an error if internal access happens after that.\nFrom a compat perspective this seems reasonable, and the compat flag is available to return the whole system to generate-one-assembly behavior.\n","headings":["F# Interactive Code Generation","Compat switch","Are multiple assemblies too costly?","Internals and accessibility across fragments"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/memory-usage.html","title":"Memory usage","content":"\nCompiler Memory Usage\nOverall memory usage is a primary determinant of the usability of the F# compiler and instances of the F# compiler service.\nWhy memory usage matters\nOverly high memory usage results in poor throughput (particularly due to increased GC times) and low user interface responsivity in tools such as Visual Studio or other editing environments. In some extreme cases, it can lead to Visual Studio crashing or another IDE becoming unusable due to constant paging from absurdly high memory usage. Luckily, these extreme cases are very rare.\nWhen you do a single compilation to produce a binary, memory usage typically doesn\u0027t matter much. It\u0027s often fine to allocate a lot of memory because it will just be reclaimed after compilation is over.\nHowever, the F# compiler is not simply a batch process that accepts source code as input and produces an assembly as output. When you consider the needs of editor and project tooling in IDEs, the F# compiler is:\n\nA database of syntactic and semantic data about the code hosted in an IDE\nAn API for tools to request tooling-specific data (e.g. F# tooltip information)\nIn FsAutoComplete or other LSP implementations, it\u0027s a server process that accepts requests for syntactic and semantic information\n\nThinking about the F# compiler in these ways makes performance far more complicated than just throughput of a batch compilation process.\nAnalyzing compiler memory usage\nIn general, the F# compiler allocates a lot of memory. More than it needs to. However, most of the \u0022easy\u0022 sources of allocations have been squashed out and what remains are many smaller sources of allocations. The remaining \u0022big\u0022 pieces allocate as a result of their current architecture, so it isn\u0027t straightforward to address them.\nSome allocations are much more than others\n* Large Object Heap (LOH) allocations (\u0026gt; ~80K) are rarely collected and should only be used for long-lived items.\n* Ephemeral allocations that never escape the Gen0 seem to not matter that much, though of course should be considered.\n* Don\u0027t try to remove all allocations, and don\u0027t assume copying of large structs is better than allocating a reference type. Measure instead.\nTo analyze memory usage of F# tooling, you have two primary avenues:\n\nTake a process dump on your machine and analyze it\nUse sampling to collect a trace of your system while you perform various tasks in an IDE, ideally for 60 seconds or more.\n\nYou can analyze dumps and take samples with dotMemory or PerfView.\nTo analyze memory usage of the F# compiler itself:\n* extract the compilation arguments out of msbuild output (or in the output pane of Visual Studio)\n* put this content in a \u0022response file\u0022 (a text file listing compiler arguments, one per line)\n* use the memory profiler tool of choice, invoking the compiler (either fsc.exe, or through dotnet path/to/fsc.dll) giving it the argument @name-of-response-file, and setting the directory of the project that is compiled as working directory\nAnalyzing a process dump file\nProcess dump files are extremely information-rich data files that can be used to see the distribution of memory usage across various types. Tools like dotMemory will show these distributions and intelligently group things to help identify the biggest areas worth improving. Additionally, they will notice things like duplicate strings and sparse arrays, which are often great ways to improve memory usage since it means more memory is being used than is necessary.\nAnalyzing a sample trace of IDE usage\nThe other important tool to understand memory and CPU usage for a given sample of IDE usage is a trace file. These are collected and analyzed by tools like PerfView and dotTrace.\nWhen analyzing a trace, there are a few things to look out for:\n\n\nOverall GC statistics for the sample to give an overall picture of what was going on in the IDE for your sample:\na. How much CPU time was spent in the GC as a percentage of total CPU time for the IDE process?\nb. What was the peak working set (total memory usage)?\nc. What was the peak allocations per second?\nd. How many allocations were Gen0? Gen1? Gen2?\n\n\nMemory allocations for the sample, typically also ignoring object deaths:\na. Is LargeObject showing up anywhere prominently? If so, that\u0027s a problem!\nb. Which objects show up highest on the list? Does their presence that high make sense?\nc. For a type such as System.String, which caller allocates it the most? Can that be improved?\n\n\nCPU sampling data, sorted by most CPU time\na. Are any methods showing up that correspond with high memory allocations? Something showing up prominently in both places is often a sign that it needs work!\n\n\nAfter analyzing a trace, you should have a good idea of places that could see improvement. Often times a tuple can be made into a struct tuple, or some convenient string processing could be adjusted to use a ReadonlySpan\u0026lt;\u0027T\u0026gt; or turned into a more verbose loop that avoids allocations.\n","headings":["Compiler Memory Usage","Why memory usage matters","Analyzing compiler memory usage","Analyzing a process dump file","Analyzing a sample trace of IDE usage"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/changing-the-ast.html","title":"Changing the AST","content":"\nChanging the AST\nMaking changes to the AST is a common task when working on new F# compiler features or when working on developer tooling.\nThis document describes the process of making changes to the AST.\nThe easiest way to modify the AST is to start with the type definitions in SyntaxTree.fsi and SyntaxTree.fs and then let the compiler guide you to the places where you need to make changes.\nLet\u0027s look at an example: We want to extend the AST to include the range of the / symbol in a SynRationalConst.Rational.\nThere are two solutions to choose from:\n- Add a new field to the Rational union case\n- Add a dedicated trivia type to the union case which contains the new range and maybe move the existing ranges to the trivia type as well\nThe pros of introducing a dedicated trivia type are:\n- Having the additional information in a separate structure allows it to grow more easily over time. Adding new information to an existing trivia type won\u0027t disrupt most FCS consumers.\n- It is clear that it is information that is not relevant for the compilation.\nThe cons are:\n- It can be a bit excessive to introduce for a single field.\n- The existing AST node might already contain fields that are historically more suited for trivia, but predate the SyntaxTrivia module.\nIn this example, we\u0027ll go with the first solution and add a new field named divRange to the Rational union case as it felt a bit excessive to introduce a new trivia type for a single field.\nBut these are the type of decisions that need to be made when changing the AST.\ntype SynRationalConst =\n\n // ...\n\n | Rational of\n numerator: int32 *\n numeratorRange: range *\n divRange: range * // our new field\n denominator: int32 *\n denominatorRange: range *\n range: range\n \n // ...\n\nAfter modifying SyntaxTree.fsi and SyntaxTree.fs, the compiler will report erros in pars.fsy. If not, the fsy file wasn\u0027t processed by the compilation. In this case, a rebuild of FSharp.Compiler.Service.fsproj should help.\npars.fsy is the parser specification of F#, a list of rules that describe how to parse F# code. Don\u0027t be scared by the size of the file or the unfamiliar content.\nIt\u0027s easier than it looks.\nThe F# compiler uses a parser generator called fsyacc to generate the parser from the specification in pars.fsy.\nLet\u0027s look at the most relevant syntax parts of a .fsy file:\nrationalConstant:\n | INT32 INFIX_STAR_DIV_MOD_OP INT32\n { if $2 \u0026lt;\u0026gt; \u0026quot;/\u0026quot; then reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnexpectedOperatorForUnitOfMeasure())\n if fst $3 = 0 then reportParseErrorAt (rhs parseState 3) (FSComp.SR.parsIllegalDenominatorForMeasureExponent())\n if (snd $1) || (snd $3) then errorR(Error(FSComp.SR.lexOutsideThirtyTwoBitSigned(), lhs parseState))\n SynRationalConst.Rational(fst $1, rhs parseState 1, fst $3, rhs parseState 3, lhs parseState) }\n | // ...\n\nThe first line is the name of the rule, rationalConstant in this case. It\u0027s a so called non-terminal symbol in contrast to a terminal symbol like INT32 or INFIX_STAR_DIV_MOD_OP. The individual cases of the rule are separated by |, they are called productions.\nBy now, you should be able to see the similarities between an fsyacc rule and the pattern matching you know from F#.\nThe code between the curly braces is the code that gets executed when the rule is matched and is real F# code. After compilation, it ends up in\n.\\artifacts\\obj\\FSharp.Compiler.Service\\Debug\\netstandard2.0\\pars.fs, generated by fsyacc.\nThe first three lines do error checking and report errors if the input is invalid.\nThen the code calls the Rational constructor of SynRationalConst and passes some values to it. Here we need to make changes to adjust the parser to our modified type definition.\nThe values or symbols that matched the rule are available as $1, $2, $3 etc. in the code. As you can see, $1 is a tuple, consisting of the parsed number and a boolean indicating whether the number is a valid 32 bit signed integer or not.\nThe code is executed in the context of the parser, so you can use the parseState variable, an instance of IParseState, to access the current state of the parser. There are helper functions defined in ParseHelpers.fs that make it easier to work with it.\nrhs parseState 1 returns the range of the first symbol that matched the rule, here INT32. So, it returns the range of 23 in 23/42.\nrhs is short for right hand side.\nAnother helper is rhs2. Using it like rhs2 parseState 2 3 for example, returns the range covering the symbols from the second to the third symbol that matched the rule. Given 23/42, it would return the range of /42.\nlhs parseState returns the range of the whole rule, 23/42 in our example.\nWhen parser recovery is of concern for a rule, it\u0027s preferred to use rhs2 over lhs.\nCircling back to our original example of adding a new field to SynRationalConst, we need to add a new parameter to the call of the Rational constructor. We want to pass the range of the / symbol, so we need to add rhs parseState 2 as the third parameter to the constructor call:\nSynRationalConst.Rational(fst $1, rhs parseState 1, rhs parseState 2, fst $3, rhs parseState 3, lhs parseState)\n\nThat\u0027s it. Adjusting the other constructor calls of Rational in pars.fsy should be enough to have a working parser again which returns the modified AST.\nWhile fixing the remaining compiler errors outside of pars.fsy, it\u0027s a good idea to use named access to the fields of the SynRationalConst.Rational union case instead of positional access. This way, the compilation won\u0027t fail if aditional fields are added to the union case in the future.\nAfter a successful compilation, you can run the parser tests in SyntaxTreeTests.fs to verify that everything works as expected.\nIt\u0027s likely that you\u0027ll need to update the baseline files as decribed in SyntaxTreeTests.fs.\n","headings":["Changing the AST"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/overview.html","title":"Overview","content":"\nOverview\nThere are several artifacts involved in the development of F#:\n\nFSharp.Compiler.Service (docs, source). Contains all logic for F# compilation - including parsing, syntax tree processing, typechecking, constraint solving, optimizations, IL importing, IL writing, pretty printing of F# constructs, and F# metadata format processing - and the F# compiler APIs for tooling.\nThe F# compiler executable, called fsc, which is called as a console app. It sets the .NET GC into batch mode and then invokes FSharp.Compiler.Service with command-line arguments.\nThe FSharp.Core Library, called FSharp.Core. Contains all primitive F# types and logic for how they interact, core data structures and library functions for operating on them, structured printing logic, units of measure for scientific programming, core numeric functionality, F# quotations, F# type reflection logic, and asynchronous programming types and logic.\nThe F# Interactive tool, called fsi. A REPL for F# that supports execution and pretty-printing of F# code and results, loading F# script files, referencing assemblies, and referencing packages from NuGet.\n\nThe FSharp.Compiler.Service is by far the largest of these components and contains nearly all logic that fsc and fsi use. It is the primary subject of this guide.\nKey compiler data formats and representations\nThe following are the key data formats and internal data representations of the F# compiler code in its various configurations:\n\nInput source files Read as Unicode text, or binary for referenced assemblies.\nInput command-line arguments See CompilerOptions.fs for the full code implementing the arguments table. Command-line arguments are also accepted by the F# Compiler Service API in project specifications, and as optional input to F# Interactive.\nTokens, see pars.fsy, lex.fsl, LexHelpers.fs and related files.\nAbstract Syntax Tree (AST), see SyntaxTree.fs, the untyped syntax tree resulting from parsing.\nTyped Abstract Syntax Tree (Typed Tree), see TypedTree.fs, TypedTreeBasics.fs, TypedTreeOps.fs, and related files. The typed, bound syntax tree including both type/module definitions and their backing expressions, resulting from type checking and the subject of successive phases of optimization and representation change.\nType checking context/state, see for example TcState in ParseAndCheckInputs.fsi and its constituent parts, particularly TcEnv in CheckExpressions.fsi and NameResolutionEnv in NameResolution.fsi. A set of tables representing the available names, assemblies etc. in scope during type checking, plus associated information.\nAbstract IL, the output of code generation, then used for binary generation, and the input format when reading .NET assemblies, see ILModuleDef in il.fsi.\nThe .NET Binary format (with added \u0022pickled\u0022 F# Metadata resource), the final output of fsc.exe, see the ECMA 335 specification and the ilread.fs and ilwrite.fs binary reader/generator implementations. The added F# metadata is stored in a binary resource, see TypedTreePickle.fs.\nThe incrementally emitted .NET reflection assembly, the incremental output of fsi.exe. See ilreflect.fs.\n\nKey constructs and APIs for F# tooling\nThe following are the most relevant parts of the F# compiler tooling, making up the \u0022engine\u0022 and API surface area of FSharp.Compiler.Service.\n\nThe incremental project build engine state in IncrementalBuild.fsi/IncrementalBuild.fs, a part of the F# Compiler Service API.\nThe corresponding APIs wrapping and accessing these structures in the public-facing FSharp.Compiler.Service API and Symbol API.\nThe F# Compiler Service Caches, the various caches maintained by an instance of an FSharpChecker.\n\nKey compiler phases\nThe following is a diagram of how the different phases of the F# compiler work:\nstateDiagram-v2\n state \u0022Compilation phases\u0022 as Flow {\n Lexing: Lexing\n Parsing: Parsing\n Import: Import\n Typechecking: Type checking\n Codegen: Code generation\n Emit: IL emit\n Inputs --\u0026gt; Lexing: Source and signature files\n Inputs --\u0026gt; Import: References\n Lexing --\u0026gt; Parsing\n Parsing --\u0026gt; Typechecking\n Import --\u0026gt; Typechecking\n Typechecking --\u0026gt; Codegen\n Codegen --\u0026gt; Emit\n state Lexing {\n BasicLexing: Basic Lexing\n WhitespaceSensitiveLexing: Whitespace Sensitive Lexing\n [*] --\u0026gt; BasicLexing\n BasicLexing --\u0026gt; WhitespaceSensitiveLexing: A token stream from input source text.\n WhitespaceSensitiveLexing --\u0026gt; [*]: A token stream, augmented per the F# Language Specification.\n }\n state Parsing {\n Parser: Parsing\n [*] --\u0026gt; Parser\n Parser --\u0026gt; [*]: AST per the grammar in the F# Language Specification.\n }\n state Import {\n Resolving: Resolving references\n ImportNET: Importing .NET references\n ImportFS: Importing F# references\n [*] --\u0026gt; Resolving\n Resolving --\u0026gt; ImportNET\n Resolving --\u0026gt; ImportFS\n ImportNET --\u0026gt; [*]\n ImportFS --\u0026gt; [*]\n }\n state Typechecking {\n SequentialTypechecking: Sequentially type checking files\n PatternMatchCompilation: Pattern match compilation\n ConstraintSolving: Constraint solving\n PostInferenceChecks: Post inference checks\n [*] --\u0026gt; SequentialTypechecking\n SequentialTypechecking --\u0026gt; PatternMatchCompilation\n PatternMatchCompilation --\u0026gt; ConstraintSolving\n ConstraintSolving --\u0026gt; PostInferenceChecks\n PostInferenceChecks --\u0026gt; [*]\n }\n state Codegen {\n QuotationTranslation: Quotation translation\n Optimization: Optimization\n Codegeneration: Code generation\n AbstractILRewrite: Abstract IL rewriting\n [*] --\u0026gt; QuotationTranslation\n QuotationTranslation --\u0026gt; Optimization\n Optimization --\u0026gt; Codegeneration\n Codegeneration --\u0026gt; AbstractILRewrite\n AbstractILRewrite --\u0026gt; [*]\n }\n state Emit {\n Binary: Binary emit\n Reflection: Reflection emit\n Output: Output (assembly, references, PDBs, etc.)\n [*] --\u0026gt; Binary\n [*] --\u0026gt; Reflection\n Binary --\u0026gt; Output\n Reflection --\u0026gt; Output\n }\n }\n\nThe following are the key phases and high-level logical operations of the F# compiler code in its various configurations:\n\nBasic lexing. Produces a token stream from input source file text. F# uses the FsLex tool to process a declarative specification of the tokenizer in lex.fsl. This compiles the tokenizer specification to a number of tables which are then interpreted by the code in prim-lexing.fs (see also prim-lexing.fsi.\nWhite-space sensitive lexing. Accepts and produces a token stream, augmenting per the F# Language Specification.\nParsing. Accepts a token stream and produces an AST per the grammar in the F# Language Specification. F# uses the FsYacc tool to process a declarative specification of the parser in pars.fsy. This compiles the grammar to a number of tables which are then interpreted by the code in prim-parsing.fs (see also prim-parsing.fsi.\n\nResolving references. For .NET SDK generally references are resolved explicitly by external tooling.\nThere is a legacy aspect to this if references use old .NET Framework references including for\nscripting. See ReferenceResolver.fs for the abstract definition of compiler reference resolution. See LegacyMSBuildReferenceResolver.fs for reference resolution used by the .NET Framework F# compiler when running on .NET Framework. See SimulatedMSBuildReferenceResolver.fs when not using the .NET Framework F# compiler.\nSee DependencyManager for reference resolution and package management used in fsi.\n\nImporting referenced .NET binaries, see import.fsi/import.fs. Accepts file references and produces a Typed Tree node for each referenced assembly, including information about its type definitions (and type forwarders if any).\nImporting referenced F# binaries and optimization information as Typed Tree data structures, see TypedTreePickle.fs. Accepts binary data and produces Typed Tree nodes for each referenced assembly, including information about its type/module/function/member definitions.\n\nSequentially type checking files, see CheckDeclarations.fsi/CheckDeclarations.fs. Accepts an AST plus a type checking context/state and produces new Typed Tree nodes\nincorporated into an updated type checking state, plus additional Typed Tree Expression nodes used during code generation. A key part of this is\nchecking syntactic types and expressions, see CheckExpressions.fsi/CheckExpressions.fs including the state held across the checking of a file (see TcFileState) and the\nenvironment active as we traverse declarations and expressions (see TcEnv).\n\nPattern match compilation, see PatternMatchCompilation.fsi/PatternMatchCompilation.fs. Accepts a subset of checked Typed Tree nodes representing F# pattern matching and produces Typed Tree expressions implementing the pattern matching. Called during type checking as each construct involving pattern matching is processed.\nConstraint solving, see ConstraintSolver.fsi/ConstraintSolver.fs. A constraint solver state is maintained during type checking of a single file, and constraints are progressively asserted (i.e. added to this state). Fresh inference variables are generated and variables are eliminated (solved). Variables are also generalized at various language constructs, or explicitly declared, making them \u0022rigid\u0022. Called during type checking as each construct is processed.\nPost-inference type checks, see PostInferenceChecks.fsi/PostInferenceChecks.fs. Called at the end of type checking/inference for each file. A range of checks that can only be enforced after type checking on a file is complete, such as analysis when using byref\u0026lt;\u0027T\u0026gt; or other IsByRefLike structs.\nQuotation translation, see QuotationTranslator.fsi/QuotationTranslator.fs/QuotationPickler.fsi/QuotationPickler.fs. Generates the stored information for F# quotation nodes, generated from the Typed Tree expression structures of the F# compiler. Quotations are ultimately stored as binary data plus some added type references. \u0022ReflectedDefinition\u0022 quotations are collected and stored in a single blob.\nOptimization phases, primarily the \u0022Optimize\u0022 (peephole/inlining) and \u0022Top Level Representation\u0022 (lambda lifting) phases, see Optimizer.fsi/Optimizer.fs and InnerLambdasToTopLevelFuncs.fsi/InnerLambdasToTopLevelFuncs.fs and LowerCalls.fs. Each of these takes Typed Tree nodes for types and expressions and either modifies the nodes in place or produces new Typed Tree nodes. These phases are orchestrated in CompilerOptions.fs\nCode generation, see IlxGen.fsi/IlxGen.fs. Accepts Typed Tree nodes and produces Abstract IL nodes, sometimes applying optimizations.\n\nAbstract IL code rewriting, see EraseClosures.fs and\nEraseUnions.fs. Eliminates some constructs by rewriting Abstract IL nodes.\n\nBinary emit, see ilwrite.fsi/ilwrite.fs.\nReflection-Emit, see ilreflect.fs.\n\nThese and transformations used to build the following:\n\nThe F# Compiler Service API, see the Symbol API and Service API\nThe F# Interactive Shell, see fsi.fs.\nThe F# Compiler Shell, see fsc.fs and fscmain.fs.\n\nBootstrapping\nThe F# compiler is bootstrapped. That is, an existing F# compiler is used to build a \u0022proto\u0022 compiler from the current source code. That \u0022proto\u0022 compiler is then used to compile itself, producing a \u0022final\u0022 compiler. This ensures the final compiler is compiled with all relevant optimizations and fixes.\nFSharp.Build\nFSharp.Build.dll and Microsoft.FSharp.targets give MSBuild support for F# projects (.fsproj) and contain the targets. Although not strictly part of the F# compiler, they are essential for using F# in all contexts for .NET, aside from some more targeted scripting scenarios. The targets expose things like the CoreCompile and Fsc tasks called by MSBuild.\n","headings":["Overview","Key compiler data formats and representations","Key constructs and APIs for F# tooling","Key compiler phases","Bootstrapping","FSharp.Build"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/running-documentation-locally.html","title":"Running the documentation locally","content":"\nRunning the documentation locally\nThe source of this documentation website is hosted on https://github.com/fsharp/fsharp-compiler-docs.\nYou can follow this guide to see the results of your document changes rendered in the browser.\nSetup\nfsharp/fsharp-compiler-docs will clone the dotnet/fsharp repository first to generate the documentation.\nYou can however, easily run the documentation locally and modify the docs from dotnet/fsharp.\n\nClone fsharp/fsharp-compiler-docs at the same level as your local dotnet/fsharp repository:\n\ngit clone https://github.com/fsharp/fsharp-compiler-docs.git\n\n\nRestore the FSharp.Compiler.Service project in fsharp-compiler-docs:\n\ncd fsharp-compiler-docs/FSharp.Compiler.Service\ndotnet restore\n\n\nRestore the local tools in fsharp-compiler-docs:\n\ncd ..\ndotnet tool restore\n\n\nRun the documentation tool using your dotnet/fsharp fork as input.\n\ndotnet fsdocs watch --eval --sourcefolder ../fsharp/ --input ../fsharp/docs/\n\nRelease notes caveat\nThe release notes pages from docs/release-notes are composed from the MarkDown files in subfolders.\nChanging any of these files, won\u0027t regenerate the served webpage. Only the changes to the .fsx will trigger the tool. This is a known limitation.\n","headings":["Running the documentation locally","Setup","Release notes caveat"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/compiler-startup-performance.html","title":"Startup Performance","content":"\nCompiler Startup Performance\nCompiler startup performance is a key factor affecting happiness of F# users. If the compiler took 10sec to start up, then far fewer people would use F#.\nOn all platforms, the following factors affect startup performance:\n\nTime to load compiler binaries. This depends on the size of the generated binaries, whether they are pre-compiled (for example, using NGEN or CrossGen), and the way the .NET implementation loads them.\nTime to open referenced assemblies (for example, mscorlib.dll, FSharp.Core.dll) and analyze them for the types and namespaces defined. This depends particularly on whether this is correctly done in an on-demand way.\nTime to process \u0022open\u0022 declarations at the top of each file. Processing these declarations have been observed to take time in some cases of F# compilation.\nFactors specific to the specific files being compiled.\n\nOn Windows, the compiler delivered with Visual Studio currently uses NGEN to pre-compile fsc, fsi, and some assemblies used in Visual Studio tooling. For .NET Core, the CrossGen tool is used to accomplish the same thing. Visual Studio will use delayed NGEN, meaning that it does not run NGEN on every binary up front. This means that F# compilation through Visual Studio may be slow for a few times before it gets NGENed.\n","headings":["Compiler Startup Performance"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/diagnostics.html","title":"Diagnostics","content":"\nDiagnostics\nThe key types are:\n\nErrorLogger\nFSharpDiagnosticSeverity\nFSharpDiagnostic\nDiagnosticWithText\n\nand functions\n\nwarning - emit a warning\nerrorR - emit an error and continue\nerror - emit an error and throw an exception\nerrorRecovery - recover from an exception\n\nFor the compiler, a key file is https://github.com/dotnet/fsharp/blob/main/src/Compiler/FSComp.txt holding most of the messages. There are also a few other similar files including some old error messages in FSStrings.resx.\nAdding Diagnostics\nAdding or adjusting diagnostics emitted by the compiler is usually straightforward (though it can sometimes imply deeper compiler work). Here\u0027s the general process:\n\nReproduce the compiler error or warning with the latest F# compiler built from the F# compiler repository.\nFind the error code (such as FS0020) in the message.\nUse a search tool and search for a part of the message. You should find it in FSComp.fs with a title, such as parsMissingTypeArgs.\nUse another search tool or a tool like Find All References / Find Usages to see where it\u0027s used in the compiler source code.\nSet a breakpoint at the location in source you found. If you debug the compiler with the same steps, it should trigger the breakpoint you set. This verifies that the location you found is the one that emits the error or warning you want to improve.\n\nFrom here, you can either simply update the error text, or you can use some of the information at the point in the source code you identified to see if there is more information to include in the error message. For example, if the error message doesn\u0027t contain information about the identifier the user is using incorrectly, you may be able to include the name of the identifier based on data the compiler has available at that stage of compilation.\nIf you\u0027re including data from user code in an error message, it\u0027s important to also write a test that verifies the exact error message for a given string of F# code.\nFormatting Typed Tree items in Diagnostics\nDiagnostics must often format TAST items as user text. When formatting these, you normally use either\n\nThe functions in the NicePrint module such as NicePrint.outputTyconRef. These take a DisplayEnv that records the context in which a type was referenced, for example, the open namespaces. Opened namespaces are not shown in the displayed output.\nThe DisplayName properties on the relevant object. This drops the \u0027n text that .NET adds to the compiled name of a type, and uses the F#-facing name for a type rather than the compiled name for a type (for example, the name given in a CompiledName attribute).\n\nWhen formatting \u0022info\u0022 objects, see the functions in the NicePrint module.\nNotes on displaying types\nDiagnostics must often format types.\n\nWhen displaying a type, you will normally want to \u0022prettify\u0022 the type first. This converts any remaining type inference variables to new, better user-friendly type variables with names like \u0027a. Various functions prettify types prior to display, for example, NicePrint.layoutPrettifiedTypes and others.\nWhen displaying multiple types in a comparative way, for example, two types that didn\u0027t match, you will want to display the minimal amount of infomation to convey the fact that the two types are different, for example, NicePrint.minimalStringsOfTwoTypes.\nWhen displaying a type, you have the option of displaying the constraints implied by any type variables mentioned in the types, appended as when .... For example, NicePrint.layoutPrettifiedTypeAndConstraints.\n\nLocalization\nThe file FSComp.txt contains the canonical listing of diagnostic messages, but there are also .xlf localization files for various languages.\nSee the DEVGUIDE for more details.\nEnabling a warning or error by default\nThe file CompilerDiagnostics.fs contains the function IsWarningOrInfoEnabled, which determines whether a given diagnostic is emitted.\n","headings":["Diagnostics","Adding Diagnostics","Formatting Typed Tree items in Diagnostics","Notes on displaying types","Localization","Enabling a warning or error by default"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/builder-caches.html","title":"IncrementalBuilder caches","content":"\nIncrementalBuilder SyntaxTree cache\nIncremental builder keeps in a cache at most one ParsedInput for each file it parses.\nThis behavior can be toggled with useSyntaxTreeCache parameter.\nMemory impact of this feature can be in range of tens of MB for larger solutions. This can be inspected in memory profilng tools by searching for ParsedInput instances.\nWhen partial checking is enabled, implementation files backed by signature will not be parsed or cached, as expected.\n","headings":["IncrementalBuilder SyntaxTree cache"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/project-builds.html","title":"Project builds","content":"\nProject builds\nThe compiler is generally built to compile one assembly: the assumption that the compiler is compiling one assembly is baked into several aspects of the design of the Typed Tree. In contrast, FCS supports compiling a graph of projects, each for a different assembly, each undergoing incremental change.\nProject builds are currently stateful and reliant on I/O to on-disk assemblies. This causes many problems and we have a plan for how to fix this core issue in the F# Language Service implementation. See Plan: Modernizing F# Analysis. Please read this carefully if you plan to work on any of service.fs, IncrementalBuild.fs or FSharpCheckerResults.fs.\nKey data structures:\n\n\nIncrementalBuilder manages an incremental build graph for the build of an F# project.\n\nSee also Plan: Modernizing F# Analysis for how this will evolve to FSharpProject.\n\n\n\nFSharpParseFileResults - represents the enrichment (e.g. breakpoint validation) available from the parse tree of a file. The enrichment is made up of several pieces such as:\n\nSyntaxTree/ParsedInput\ndiagnostics from the parsing\n\n\n\nFSharpCheckFileResults - represents the enrichment (e.g. tooltips) available after checking a file. The enrichment is made up of several pieces such as\n\nTcGlobals - the globals for the compilation, also used in command-line build\nTcConfig - the compiler configuration for the compilation, also used in command-line build\nTcImports - the table of imports for the compilation\nCcuThunk - the thunk of the assembly being compiled\nTcState - the state of the compilation up to this point\nTcResolutions - name environments across the file, ultimately from NameResolution.fs\nTcSymbolUses - resolutions of symbols across the file\nLoadClosure - the #load closure of a script\nTypedImplFile - the TAST expression results of compilation, may be thrown away if keepAssemblyContents is not true\n\n\n\nFSharpCheckProjectResults - represents the enrichment (e.g. find-all symbol uses) available after checking a project\n\nTcGlobals - the globals for the compilation, also used in command-line build\nTcConfig - the compiler configuration for the compilation, also used in command-line build\nTcImports - the table of imports for the compilation\nCcuThunk - the thunk of the assembly being compiled\nTcState - the final state of the compilation\n\n\n\nMulti-project builds and cross-project references\nIn FCS, there is no single abstraction for a \u0022solution build\u0022 and instead you have multiple project builds. These are all essentially independent, in the sense they each logically represent an invocation of the F# compiler. That is, the Typed Tree (TAST), TcState etc. nodes are not shared between different project compilations.\nIf you want to understand why this invariant is important, some key things to understand are:\n\nThe RawFSharpAssemblyData is the data blob that would normally be stuffed in the F# resource in the generated DLL in a normal compilation. That\u0027s the \u0022output\u0022 of checking each project.\nThis is used as \u0022input\u0022 for the assembly reference of each consuming project (instead of an on-disk DLL)\nWithin each consuming project that blob is then resurrected to Typed Tree nodes in TypedTreePickle.fs.\n\nCould the compiler share this data across projects? In theory, yes. In practice, it\u0027s very tricky business. From a correctness point of view: the process of generating this blob (TypedTreePickle p_XYZ) and resurrecting it (TypedTreePickle u_*) does some transformations to the Typed Tree that are necessary for correctness of compilation, for example, in TypedTreePickle. Basically, the Typed Tree nodes from the compilation of one assembly are not valid when compiling a different assembly.\nThe Typed Tree nodes include CcuData nodes, which have access to a number of callbacks into the TcImports compilation context for the assembly being compiled. TypedTree nodes are effectively tied to a particular compilation of a particular assembly due to this. There isn\u0027t any way to share this data without losing correctness and invalidating many invariants held in the current design. From a lifetime point of view: the Typed Tree nodes are tied together in a graph, so sharing one or two of them might drag across the entire graph and extend lifetimes of that graph. None of these interrelated nodes were designed to be shared across assemblies.\n","headings":["Project builds","Multi-project builds and cross-project references"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/debug-emit.html","title":"Debug emit","content":"\nDebug emit\nThe F# compiler code base emits debug information and attributes. This article documents what we do, how it is implemented and the problem areas in our implementation.\nThere are mistakes and missing pieces to our debug information. Small improvements can make a major difference. Please help us fix mistakes and get things right.\nThe file tests\\walkthroughs\\DebugStepping\\TheBigFileOfDebugStepping.fsx is crucial for testing the stepping experience for a range of constructs.\nUser experiences\nDebugging information affects numerous user experiences:\n\nCall stacks during debugging\nBreakpoint placement before and during debugging\nLocals during debugging\nJust my code debugging (which limits the view of debug code to exclude libraries)\nException debugging (e.g. \u0022first chance\u0022 debugging when exceptions occur)\nStepping debugging\nWatch window\nProfiling results\nCode coverage results\n\nSome experiences are un-implemented by F# including:\n\nAutos during debugging\nEdit and Continue\nHot reload\n\nEmitted information\nEmitted debug information includes:\n\nThe names of methods in .NET IL\n\nThe PDB file/information (embedded or in PDB file) which contains\n\nDebug \u0022sequence\u0022 points for IL code\nNames of locals and the IL code scopes over which those names are active\n\n\nThe attributes on IL methods such as CompilerGeneratedAttribute and DebuggerNonUserCodeAttribute, see below\nWe add some codegen to give better debug experiences, see below.\n\nWe almost always now emit the Portable PDB format.\nDesign-time services\nIDE tooling performs queries into the F# language service, notably:\n\nValidateBreakpointLocation is called to validate every breakpoint before debugging is launched. This operates on syntax trees. See notes below.\n\nDebugging and optimization\nNearly all optimizations are off when debug code is being generated.\n\nThe optimizer is run for forced inlining only\nList and array expressions do generate collector code\nState machines are generated for tasks and sequences\n\u0022let mutable\u0022 --\u0026gt; \u0022ref\u0022 promotion happens for captured local mutables\nTailcalls are off by default and not emitted in IlxGen.\n\nOtherwise, what comes out of the type checker is pretty much what goes into IlxGen.fs.\nDebug points\nTerminology\nWe use the terms \u0022sequence point\u0022 and \u0022debug point\u0022 interchangeably. The word \u0022sequence\u0022 has too many meanings in the F# compiler so in the actual code you\u0027ll see \u0022DebugPoint\u0022 more often, though for abbreviations you may see spFoo or mFoo.\nHow breakpoints work (high level)\nBreakpoints have two existences which must give matching behavior:\n\nAt design-time, before debugging is launched, ValidateBreakpointLocation is called to validate every breakpoint. This operates on the SyntaxTree and forms a kind of \u0022gold-standard\u0022 about the exact places where break points are valid.\nAt run-time, breakpoints are \u0022mapped\u0022 by the .NET runtime to actual sequence points found in the PDB data for .NET methods. The runtime searches all methods with debug points for the relevant document and determines where to \u0022bind\u0022 the actual breakpoint to. A typical debugger can bind a breakpoint to multiple locations.\n\nThis means there is an invariant that ValidateBreakpointLocation and the emitted IL debug points correspond.\n\nNOTE: The IL code can and does contain extra debug points that don\u0027t pass ValidateBreakpointLocation. It won\u0027t be possible to set a breakpoint for these, but they will appear in stepping.\n\nIntended debug points based on syntax\nThe intended debug points for constructs are determined by syntax as follows. Processing depends on whether a construct is being processed as \u0022control-flow\u0022 or not. This means at least one debug point will be placed, either over the whole expression or some of its parts.\n\nThe bodies of functions, methods, lambdas and initialization code for top-level-bindings are all processed as control flow\nEach Upper-Cased EXPR below is processed as control-flow (the bodies of loops, conditionals etc.)\nLeaf expressions are the other composite expressions like applications that are not covered by the other constructs.\nThe sub-expressions of leaf expressions are not processed as control-flow.\n\n\n\n\nConstruct\nDebug points\n\n\n\n\nlet x = leaf-expr in BODY-EXPR\nDebug point over let x = leaf-expr.\n\n\nlet x = NON-LEAF-EXPR in BODY-EXPR\n\n\n\nlet f x = BODY-EXPR in BODY-EXPR\n\n\n\nlet rec f x = BODY-EXPR and g x = BODY-EXPR in BODY-EXPR\n\n\n\nif guard-expr then THEN-EXPR\nDebug point over if guard-expr then\n\n\nif guard-expr then THEN-EXPR else ELSE-EXPR\nDebug point over if .. then\n\n\nmatch .. with ...\nDebug point over match .. with\n\n\n... -\u0026gt; TARGET-EXPR\n\n\n\n... when WHEN-EXPR -\u0026gt; TARGET-EXPR\n\n\n\nwhile .. do BODY-EXPR\nDebug point over while .. do\n\n\nfor .. in collection-expr do BODY-EXPR\nDebug points over for, in and collection-expr\n\n\ntry TRY-EXPR with .. -\u0026gt; HANDLER-EXPR\nDebug points over try and with\n\n\ntry TRY-EXPR finally .. -\u0026gt; FINALLY-EXPR\nDebug points try and finally\n\n\nuse x = leaf-expr in BODY-EXPR\nDebug point over use x = leaf-expr.\n\n\nuse x = NON-LEAF-EXPR in BODY-EXPR\n\n\n\nEXPR; EXPR\n\n\n\n(fun .. -\u0026gt; BODY-EXPR)\nNot a leaf, do not produce a debug point on outer expression, but include them on BODY-EXPR\n\n\n{ new C(args) with member ... = BODY-EXPR }\n\n\n\nPipe EXPR1 \u0026amp;amp;\u0026amp;amp; EXPR2\n\n\n\nPipe EXPR1 \u0026amp;#124;\u0026amp;#124; EXPR2\n\n\n\nPipe EXPR1 \u0026amp;#124;\u0026gt; EXPR2\n\n\n\nPipe (EXPR1, EXPR2) \u0026amp;#124;\u0026amp;#124;\u0026gt; EXPR3\n\n\n\nPipe (EXPR1, EXPR2, EXPR3) \u0026amp;#124;\u0026amp;#124;\u0026amp;#124;\u0026gt; EXPR4\n\n\n\nyield leaf-expr\nDebug point over \u0027yield expr\u0027\n\n\nyield! leaf-expr\nDebug point over \u0027yield! expr\u0027\n\n\nreturn leaf-expr\nDebug point over \u0027return expr\u0027\n\n\nreturn! leaf-expr\nDebug point over \u0027return! expr\u0027\n\n\n[ BODY ]\nSee notes below. If a computed list expression with yields (explicit or implicit) then process as control-flow. Otherwise treat as leaf\n\n\n[| BODY |]\nSee notes below. If a computed list expression with yields (explicit or implicit) then process as control-flow. Otherwise treat as leaf\n\n\nseq { BODY }\nSee notes below\n\n\nbuilder { BODY }\nSee notes below\n\n\nf expr, new C(args), constants or other leaf\nDebug point when being processed as control-flow. The sub-expressions are processed as non-control-flow.\n\n\n\n\nIntended debug points for let-bindings\nSimple let bindings get debug points that extend over the let (if the thing is not a function and the implementation is a leaf expression):\nlet f () =\n let x = 1 // debug point for whole of \u0060let x = 1\u0060\n let f x = 1 // no debug point on \u0060let f x =\u0060, debug point on \u00601\u0060\n let x = if today then 1 else tomorrow // no debug point on \u0060let x =\u0060, debug point on \u0060if today then\u0060 and \u00601\u0060 and \u0060tomorrow\u0060\n let x = let y = 1 in y \u002B y // no debug point on \u0060let x =\u0060, debug point on \u0060let y = 1\u0060 and \u0060y \u002B y\u0060\n ...\n\nIntended debug points for nested control-flow\nDebug points are not generally emitted for constituent parts of non-leaf constructs, in particular function applications, e.g. consider:\nlet h1 x = g (f x)\nlet h2 x = x |\u0026gt; f |\u0026gt; g\n\nHere g (f x) gets one debug point covering the whole expression. The corresponding pipelining gets three debug points.\nIf however a nested expression is control-flow, then debug points start being emitted again e.g.\nlet h3 x = f (if today then 1 else 2)\n\nHere debug points are at if today then and 1 and 2 and all of f (if today then 1 else 2)\n\nNOTE: these debug points are overlapping. That\u0027s life.\n\nIntended debug points for [...], [| ... |] code\nThe intended debug points for computed list and array expressions are the same as for the expressions inside the constructs. For example\nlet x = [ for i in 1 .. 10 do yield 1 ]\n\nThis will have debug points on for i in 1 .. 10 do and yield 1.\nIntended debug points for seq { .. } and task { .. } code\nThe intended debug points for tasks is the same as for the expressions inside the constructs. For example\nlet f() = task { for i in 1 .. 10 do printfn \u0026quot;hello\u0026quot; }\n\nThis will have debug points on for i in 1 .. 10 do and printfn \u0022hello\u0022.\n\nNOTE: there are glitches, see further below\n\nIntended debug points for other computation expressions\nOther computation expressions such as async { .. } or builder { ... } get debug points as follows:\n\nA debug point for builder prior to the evaluation of the expression\n\nIn the de-sugaring of the computation expression, each point a lambda is created implicitly, then the body of that\nlambda as specified by the F# language spec is treated as control-flow and debug points added per the earlier spec.\n\nFor every builder.Bind, builder.BindReturn and similar call that corresponds to a let where there would be a debug point, a debug point is added immediately prior to the call.\nFor every builder.For call, a debug point covering the for keyword is added immediately prior to the call. No debug point is added for the builder.For call itself even if used in statement position.\nFor every builder.While call, a debug point covering the while keyword plus guard expression is added immediately prior to the execution of the guard within the guard lambda expression. No debug point is added for the builder.While call itself even if used in statement position.\nFor every builder.TryFinally call, a debug point covering the try keyword is added immediately within the body lambda expression. A debug point covering the finally keyword is added immediately within the finally lambda expression. No debug point is added for the builder.TryFinally call itself even if used in statement position.\nFor every builder.Yield, builder.Return, builder.YieldFrom or builder.ReturnFrom call, debug points are placed on the expression as if it were control flow. For example yield 1 will place a debug point on 1 and yield! printfn \u0022hello\u0022; [2] will place two debug points.\nNo debug point is added for the builder.Run, builder.Run or builder.Delay calls at the entrance to the computation expression, nor the builder.Delay calls implied by try/with or try/finally or sequential Combine calls.\n\nThe computations are often \u0022cold-start\u0022 anyway, leading to a two-phase debug problem.\nThe \u0022step-into\u0022 and \u0022step-over\u0022 behaviour for computation expressions is often buggy because it is performed with respect to the de-sugaring and inlining rather than the original source.\nFor example, a \u0022step over\u0022 on a \u0022while\u0022 with a non-inlined builder.While will step over the whole call, when the user expects it to step the loop.\nOne approach is to inline the builder.While method, and apply [\u0026lt;InlineIfLambda\u0026gt;] to the body function. This however has only limited success\nas at some points inlining fails to fully flatten. Builders implemented with resumable code tend to be much better in this regards as\nmore complete inlining and code-flattening is applied.\nIntended debug points for implicit constructors\n\nThe let and do bindings of an implicit constructor generally gets debug points as if it were a function.\ninherits SubClass(expr) gets a debug point. If there is no inherits, an initial debug point is placed over the text of the arguments.\n\ne.g.\ntype C(args) = \n let x = 1\u002B1 // debug point over \u0060let x = 1\u002B1\u0060 as the only side effect\n let f x = x \u002B 1\n member _.P = x \u002B f 4\n\ntype C(args) = \n do printfn \u0026quot;hello\u0026quot; // debug point over \u0060printfn \u0026quot;hello\u0026quot;\u0060 as side effect\n static do printfn \u0026quot;hello\u0026quot; // debug point over \u0060printfn \u0026quot;hello\u0026quot;\u0060 as side effect for static init\n let f x = x \u002B 1\n member _.P = x \u002B f 4\n\ntype C(args) = // debug point over \u0060(args)\u0060 since there\u0026#39;s no other place to stop on object construction\n let f x = x \u002B 1\n member _.P = 4\n\nInternal implementation of debug points in the compiler\nMost (but not all) debug points are noted by the parser by adding DebugPointAtTry, DebugPointAtWith, DebugPointAtFinally, DebugPointAtFor, DebugPointAtWhile, DebugPointAtBinding or DebugPointAtLeaf.\nThese are then used by ValidateBreakpointLocation. These same values are also propagated unchanged all the way through to IlxGen.fs for actual code generation, and used for IL emit, e.g. a simple case like this:\n match spTry with\n | DebugPointAtTry.Yes m -\u0026gt; CG.EmitDebugPoint cgbuf m ... \n | DebugPointAtTry.No -\u0026gt; ...\n ...\n\nFor many constructs this is adequate. However, in practice the situation is far more complicated.\nInternals: Debug points for [...], [| ... |]\nThe internal implementation of debug points for list and array expressions is conceptually simple but a little complex.\nConceptually the task is easy, e.g. [ while check() do yield x \u002B x ] is lowered to code like this:\nlet $collector = ListCollector\u0026lt;int\u0026gt;()\nwhile check() do\n $collector.Add(x\u002Bx)\n$collector.Close()\n\nNote the while loop is still a while loop - no magic here - and the debug points for the while loop can also apply to the actual generated for loop.\nHowever, the actual implementation is more complicated because there is a TypedTree representation of the code in-between that at first seems to bear little resemblance to what comes in.\nSyntaxTree --[CheckComputationExpressions.fs]--\u0026gt; TypedTree --\u0026gt; IlxGen --\u0026gt;[LowerComputedListOrArrayExpr.fs]--\u0026gt; IlxGen\n\nThe TypedTree is a functional encoding into Seq.toList, Seq.singleton and so on. How do the debug points get propagated?\n\nIn CheckComputationExpressions.fs we \u0022note\u0022 the debug point for the For loop and attach it to one of the lambdas generated in the TypedTreeForm\nIn LowerSequences.fs we \u0022recover\u0022 the debug point from precisely that lambda.\nIn IlxGen.fs this becomes an actual debug point in the actual generated \u0022while\u0022 loop.\n\nThis then gives accurate debug points for these constructs.\nInternals: debug points for seq { .. .} code\nDebug points for seq { .. } compiling to state machines poses similar problems.\n\nThe de-sugaring is as for list and array expressions\nThe debug points are recovered in the state machine generation\n\nInternals: debug points for task { .. .} code\nDebug points for task { .. } poses much harder problems. We use \u0022while\u0022 loops as an example:\n\nThe de-sugaring is for computation expressions, and in CheckComputationExpressions.fs places a debug point for while directly before the evaluation of the guard\nThe code is then checked and optimized, and all the resumable code is inlined, and this debug point is preserved throughout this process.\n\nInternals: debug points for other computation expressions\nAs mentioned above, other computation expressions such as async { .. } have significant problems with their debug points.\nThe main problem is stepping: even after inlining the code for computation expressions is rarely \u0022flattened\u0022 enough, so, for example, a \u0022step-into\u0022 is required to get into the second part of an expr1; expr2 construct (i.e. an async.Combine(..., async.Delay(fun () -\u0026gt; ...))) where the user expects to press \u0022step-over\u0022.\nBreakpoints tend to be less problematic.\n\nNOTE: A systematic solution for quality debugging of computation expressions code is still elusive, and especially for async { ... }. Extensive use of inlining and InlineIfLambda can succeed in flattening most simple computation expression code. This is however not yet fully applied to async programming.\nNOTE: The use of library code to implement \u0022async\u0022 and similar computation expressions also interacts badly with \u0022Just My Code\u0022 debugging, see https://github.com/dotnet/fsharp/issues/5539 for example.\nNOTE: As mentioned, the use of many functions to implement \u0022async\u0022 and friends implements badly with \u0022Step Into\u0022 and \u0022Step Over\u0022 and related attributes, see for example https://github.com/dotnet/fsharp/issues/3359\n\nFeeFee and F00F00 debug points (Hidden and JustMyCodeWithNoSource)\nSome fragments of code use constructs generate calls and other IL code that should not have debug points and not participate in \u0022Step Into\u0022, for example. These are generated in IlxGen as \u0022FeeFee\u0022 debug points. See the the Portable PDB spec linked here.\n\nTODO: There is also the future prospect of generating JustMyCodeWithNoSource (0xF00F00) debug points but these are not yet emitted by F#. We should check what this is and when the C# compiler emits these.\nNOTE: We always make space for a debug point at the head of each method by emitting a FeeFee debug sequence point. This may be immediately replaced by a \u0022real\u0022 debug point here.\n\nGenerated code\nThe F# compiler generates entire IL classes and methods for constructs such as records, closures, state machines and so on. Each time code is generated we must carefully consider what attributes and debug points are generated.\nGenerated \u0022augment\u0022 methods for records, unions and structs\nGenerated methods for equality, hash and comparison on records, unions and structs do not get debug points at all.\n\nNOTE: Methods without debug points (or with only 0xFEEFEE debug points) are shown as \u0022no code available\u0022 in Visual Studio - or in Just My Code they are hidden altogether - and are removed from profiling traces (in profiling, their costs are added to the cost of the calling method).\nTODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing, however the absence of debug points should be sufficient to exclude these.\n\nGenerated \u0022New*\u0022, \u0022Is*\u0022, \u0022Tag\u0022 etc. for unions\nDiscriminated unions generate NewXYZ, IsXYZ, Tag etc. members. These do not get debug points at all.\nThese methods also get CompilerGeneratedAttribute, and DebuggerNonUserCodeAttribute.\n\nTODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing, however the absence of debug points should be sufficient to exclude these.\nTODO: the NewABC methods are missing CompilerGeneratedAttribute, and DebuggerNonUserCodeAttribute. However, the absence of debug points should be sufficient to exclude these from code coverage and profiling.\n\nGenerated closures for lambdas\nThe debug codegen involved in closures is as follows:\n\n\n\nSource\nConstruct\nDebug Points\nAttributes\n\n\n\n\n(fun x -\u0026gt; ...)\nClosure class\n\n\n\n\n\n.ctor method\nnone\nCompilerGenerated, DebuggerNonUserCode\n\n\n\nInvoke method\nfrom body of closure\n\n\n\ngeneric local defn\nClosure class\n\n\n\n\n\n.ctor method\nnone\nCompilerGenerated, DebuggerNonUserCode\n\n\n\nSpecialize method\nfrom body of closure\n\n\n\nIntermediate closure classes\nFor long curried closures fun a b c d e f -\u0026gt; ....\n\nCompilerGenerated, DebuggerNonUserCode\n\n\n\n\nGenerated intermediate closure methods do not get debug points, and are labelled CompilerGenerated and DebuggerNonUserCode.\n\nTODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing\n\nGenerated state machines for seq { .. }\nSequence expressions generate class implementations which resemble closures.\nThe debug points recovered for the generated state machine code for seq { ... } is covered up above. The other codegen is as follows:\n\n\n\nSource\nConstruct\nDebug Points\nAttributes\n\n\n\n\nseq { ... }\nState machine class\n\n\u0022Closure\u0022\n\n\n\n.ctor method\nnone\nnone\n\n\n\nGetFreshEnumerator\nnone\nCompilerGenerated, DebuggerNonUserCode\n\n\n\nLastGenerated\nnone\nCompilerGenerated, DebuggerNonUserCode\n\n\n\nClose\nnone\nnone\n\n\n\nget_CheckClose\nnone\nnone\n\n\n\nGenerateNext\nfrom desugaring\nnone\n\n\n\n\n\nNOTE: it appears from the code that extraneous debug points are not being generated, which is good, though should be checked\nTODO: we should likely be generating CompilerGeneratedAttribute and DebuggerNonUserCodeAttribute attributes for the Close and get_CheckClose and .ctor methods\nTODO: we should also consider emitting ExcludeFromCodeCoverageAttribute, being assessed at time of writing\n\nGenerated state machines for task { .. }\nResumable state machines used for task { .. } also generate struct implementations which resemble closures.\nThe debug points recovered for the generated state machine code for seq { ... } is covered up above. The other codegen is as follows:\n\n\n\nSource\nConstruct\nDebug Points\nAttributes\nNotes\n\n\n\n\ntask { ... }\nState machine struct\n\n\u0022Closure\u0022\n\n\n\n\n.ctor method\nnone\nnone\n\n\n\n\nTBD\n\n\n\n\n\n\n\n\nTODO: we should be generating attributes for some of these\nTODO: we should assess that only the \u0022MoveNext\u0022 method gets any debug points at all\nTODO: Currently stepping into a task-returning method needs a second step-into to get into the MoveNext method of the state machine. We should emit the StateMachineMethod and StateMachineHoistedLocalScopes tables into the PDB to get better debugging into task methods. See https://github.com/dotnet/fsharp/issues/12000.\n\nGenerated code for delegate constructions Func\u0026lt;int,int,int\u0026gt;(fun x y -\u0026gt; x \u002B y)\nA closure class is generated. Consider the code\nopen System\nlet d = Func\u0026lt;int,int,int\u0026gt;(fun x y -\u0026gt; x \u002B y)\n\nThere is one debug point over all of Func\u0026lt;int,int,int\u0026gt;(fun x y -\u0026gt; x \u002B y) and one over x\u002By.\nGenerated code for constant-sized array and list expressions\nThese are not generally problematic for debug.\nGenerated code for large constant arrays\nThese are not generally problematic for debug.\nGenerated code for pattern matching\nThe implementation is a little gnarly and complicated and has historically had glitches.\nGenerated code for conditionals and boolean logic\nGenerally straight-forward. See for example this proposed feature improvement\nCapture and closures\nCaptured locals are available via the this pointer of the immediate closure. Un-captured locals are not available as things stand. See for example this proposed feature improvement.\nConsider this code:\nlet F() =\n let x = 1\n let y = 2\n (fun () -\u0026gt; x \u002B y)\n\nHere x and y become closure fields of the closure class generated for the final lambda. When inspecting locals in the inner closure, the C# expression evaluator we rely on for Visual Studio takes local names like x and y and is happy to look them up via this. This means hovering over x correctly produces the value stored in this.x.\nFor nested closures, values are implicitly re-captured, and again the captured locals will be available.\nHowever this doesn\u0027t work with \u0022capture\u0022 from a class-defined \u0022let\u0022 context. Consider the following variation:\ntype C() =\n let x = 1\n member _.M() = \n let y = 2\n (fun () -\u0026gt; x \u002B y)\n\nHere the implicitly captured local is y, but x is not captured, instead it is implicitly rewritten by the F# compiler to c.x where c is the captured outer \u0022this\u0022 pointer of the invocation of M(). This means that hovering over x does not produce a value. See issue 3759.\nProvided code\nCode provided by erasing type providers has all debugging points removed. It isn\u0027t possible to step into such code or if there are implicit debug points they will be the same range as the construct that was macro-expanded by the code erasure.\n\nFor example, a provided if/then/else expression has no debug point\n\nAdded code generation for better debugging\nWe do some \u0022extra\u0022 code gen to improve debugging. It is likely much of this could be removed if we had an expression evaluator for F#.\n\u0027this\u0027 value\nFor member x.Foo() = ... the implementation of the member adds a local variable x containing the this pointer from ldarg.0. This means hovering over x in the method produces the right value, as does x.Property etc.\nPipeline debugging\nFor pipeline debugging we emit extra locals for each stage of a pipe and debug points at each stage.\nSee pipeline debugging mini-spec.\nShadowed locals\nFor shadowed locals we change the name of a local for the scope for which it is shadowed.\nSee shadowed locals mini-spec.\nDiscriminated union debug display text\nFor discriminated union types and all implied subtypes we emit a DebuggerDisplayAttrubte and a private __DebugDisplay() method that uses sprintf \u0022%\u002B0.8A\u0022 obj to format the object.\nMissing debug emit\nMissing debug emit for PDBs\nOur PDB emit is missing considerable information:\n\nNot emitted: LocalConstants table\nNot emitted: Compilation options table\nNot emitted: Dynamic local variables table\nNot emitted: StateMachineMethod table and StateMachineHoistedLocalScopes table\nNot emitted: ImportScopes table\n\nThese are major holes in the F# experience. Some are required for things like hot-reload.\nMissing design-time services\nSome design-time services are un-implemented by F#:\n\nUnimplemented: F# expression evaluator\nUnimplemented: Proximity expressions (for Autos window)\n\nThese are major holes in the F# experience and should be implemented.\n","headings":["Debug emit","User experiences","Emitted information","Design-time services","Debugging and optimization","Debug points","Terminology","How breakpoints work (high level)","Intended debug points based on syntax","Intended debug points for let-bindings","Intended debug points for nested control-flow","Intended debug points for other computation expressions","Intended debug points for implicit constructors","Internal implementation of debug points in the compiler","Internals: debug points for other computation expressions","FeeFee and F00F00 debug points (Hidden and JustMyCodeWithNoSource)","Generated code","Generated \u0022augment\u0022 methods for records, unions and structs","Generated \u0022New*\u0022, \u0022Is*\u0022, \u0022Tag\u0022 etc. for unions","Generated closures for lambdas","Generated code for constant-sized array and list expressions","Generated code for large constant arrays","Generated code for pattern matching","Generated code for conditionals and boolean logic","Capture and closures","Provided code","Added code generation for better debugging","\u0027this\u0027 value","Pipeline debugging","Shadowed locals","Discriminated union debug display text","Missing debug emit","Missing debug emit for PDBs","Missing design-time services"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/optimizations.html","title":"Optimizations","content":"\nCode Optimizations\nCode optimizations are in Compiler/Optimize/*.\nSome of the optimizations performed in Optimizer.fs are:\n\nPropagation of known values (constants, x = y, lambdas, tuples/records/union-cases of known values)\nInlining of known lambda values\nEliminating unused bindings\nEliminating sequential code when there is no side-effect\nEliminating switches when we determine definite success or failure of pattern matching\nEliminating getting fields from an immutable record/tuple/union-case of known value\nExpansion of tuple bindings \u0022let v = (x1,...x3)\u0022 to avoid allocations if it\u0027s not used as a first class value\nSplitting large functions into multiple methods, especially at match cases, to avoid massive methods that take a long time to JIT\nRemoving tailcalls when it is determined that no code in the transitive closure does a tailcall nor recurses\n\nIn DetupleArgs.fs, tuples at call sites are eliminated if possible. Concretely, functions that accept a tuple at all call sites are replaced by functions that accept each of the tuple\u0027s arguments individually. This may require inlining to activate.\nConsidering the following example:\nlet max3 t =\n let (x, y, z) = t\n max x (max y z)\n\nmax3 (1, 2, 3)\n\nThe max3 function gets rewritten to simply accept three arguments, and depending on how it gets called it will either get inlined at the call site or called with 3 arguments instead of a new tuple. In either case, the tuple allocation is eliminated.\nHowever, sometimes this optimization is not applied unless a function is marked inline. Consider a more complicated case:\nlet rec runWithTuple t offset times =\n let offsetValues x y z offset =\n (x \u002B offset, y \u002B offset, z \u002B offset)\n if times \u0026lt;= 0 then\n t\n else\n let (x, y, z) = t\n let r = offsetValues x y z offset\n runWithTuple r offset (times - 1)\n\nThe inner function offsetValues will allocate a new tuple when called. However, if offsetValues is marked as inline then it will no longer allocate a tuple.\nCurrently, these optimizations are not applied to struct tuples or explicit ValueTuples passed to a function. In most cases, this doesn\u0027t matter because the handling of ValueTuple is well-optimized and may be erased at runtime. However, in the previous runWithTuple function, the overhead of allocating a ValueTuple each call ends up being higher than the previous example with inline applied to offsetValues. This may be addressed in the future.\nIn InnerLambdasToTopLevelFuncs.fs, inner functions and lambdas are analyzed and, if possible, rewritten into separate methods that do not require an FSharpFunc allocation.\nConsider the following implementation of sumBy on an F# list:\nlet sumBy f xs =\n let rec loop xs acc =\n match xs with\n | [] -\u0026gt; acc\n | x :: t -\u0026gt; loop t (f x \u002B acc)\n loop xs 0\n\nThe inner loop function is emitted as a separate static method named loop@2 and incurs no overhead involved with allocating an FSharpFunc at runtime.\nIn LowerCalls.fs:\n\nPerforms eta-expansion on under-applied values applied to lambda expressions and does a beta-reduction to bind any known arguments\n\nIn LowerSequences.fs:\n\nAnalyzes a sequence expression and translates it into a state machine so that operating on sequences doesn\u0027t incur significant closure overhead\n\nPotential future optimizations: Better Inlining\nConsider the following example:\nlet inline f k = (fun x -\u0026gt; k (x \u002B 1))\nlet inline g k = (fun x -\u0026gt; k (x \u002B 2))\n\nlet res = (f \u0026lt;\u0026lt; g) id 1 // 4\n\nIntermediate values that inherit from FSharpFunc are allocated at the call set of res to support function composition, even if the functions are marked as inline. Currently, if this overhead needs removal, you need to rewrite the code to be more like this:\nlet f x = x \u002B 1\nlet g x = x \u002B 2\n\nlet res = id 1 |\u0026gt; g |\u0026gt; f // 4\n\nThe downside of course being that the id function can\u0027t propagate to composed functions, meaning the code is now different despite yielding the same result.\nMore generally, any time a first-order function is passed as an argument to a second-order function, the first-order function is not inlined even if everything is marked as inline. This results in a performance penalty.\n","headings":["Code Optimizations","Potential future optimizations: Better Inlining"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/perf-discussions-archive.html","title":"Comparisons\n","content":"This is just a typed version of these notes, generated during perf discussions on summer of 2023. Can be used as a reference point.\n\nComparisons\n\nOCaml\nScala\nC#\nRust\n\nUnderlying problems\n\nLOH allocations\nBuild does too much for deltas\nGC Gen 2\n\nMajor problems\n\nScript start up CLI\nBuild on Linux \u0026amp; Mac\nGlitches in test discovery\nEdit \u0026amp; test workflow\nEdit \u0026amp; run workflow\nEdit \u0026amp; check workflow\nUnnecessary rebuilds\n\nHosted compiler problems\n\nStamp overflow\nNon-deterministic\nMemory leaks\nInfinite loops\nStay resident compiler\nPermission elevation\n\nMinor problems\n\nBenchmarking\nSquigglies\nColorization\nDebug\nPress dot\n\nIncremental phases\n\nIncremental parsing file\nIncremental checking file\nIncremental optimization for deltas\nCascading DLL builds\nIncremental DLL builds\nIncremental ILxGen for deltas\nIncremental assembly generation\nIncremental PDB generation for deltas\n\nCommunity guidelines\n\nCommunity leadership\nCommunity enablement for tool performance\nPerformance acceptance criteria\nPerformance running\nDocs for tooling performance\n\n","headings":["Comparisons","Underlying problems","Major problems","Hosted compiler problems","Minor problems","Incremental phases","Community guidelines"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/names.html","title":"Display names, logical names and compiled names","content":"\nNames of entities and values in the F# Compiler\nThe F# tooling distinguishes between the following concepts of \u0022name\u0022 for values, union cases, class/record fields and entities:\n\n\nDisplay names as they appear in code\nCharacteristics:\n\nFor most identifiers, have double backticks, e.g. \u0060\u0060Module name with spaces\u0060\u0060\nFor operator names, are short and parenthesized, e.g. (\u002B) for the logical name op_Addition\nFor active patterns, are parenthesized, e.g. (|A|_|)\n\netc., see exact specification below\nUsed in:\n\nCode outputs, e.g. signature files\n\nDiagnostics (BUG: not consistently the case today)\nCurrent aliases in code:\n\nvref.DisplayName\nentity.DisplayName\nentity.DisplayNameWithStaticParameters\nentity.DisplayNameWithStaticParametersAndUnderscoreTypars\nminfo.DisplayName\npinfo.DisplayName\neinfo.DisplayName\netc.\n\n\n\nDisplay names as they appear in declaration lists, navigation etc.\nCharacteristics:\n\n\nSame as above without the double backticks or parentheses\nCurrent aliases in code:\n\nvref.DisplayNameCore\nentity.DisplayNameCore\nminfo.DisplayNameCore\npinfo.DisplayNameCore\neinfo.DisplayNameCore\netc.\n\n\n\nLogical names\nCharacteristics:\n\nAre used in TypedTree, often \u0022canonical\u0022\n\nSometimes require extra flags to qualify the meaning of the name\nCurrent aliases in code:\n\nvref.LogicalName\nentity.LogicalName\nminfo.LogicalName\npinfo.PropertyName\neinfo.EventName\netc.\n\n\n\nCompiled names\nCharacterists:\n\n\nMark the names that appear in the .NET IL\nCurrent aliases in code:\n\nvref.CompiledName\nentity.CompiledName\netc.\n\n\n\nSpecification of all logical names\nThe following tables loosely characterise the variations in logical names, how\nthey correspond to F# source constructs and the SyntaxTree/TypedTree metadata for these.\nEntities:\n\n\n\nDisplay name in code\nLogical name\nNotes\n\n\n\n\nC\nC\ntype definition\n\n\nC\nC\u00601\ne.g. generic type, see notes below for variations of display names\n\n\nM\nM\nmodule definition\n\n\nM\nMModule\n\u0022ModuleSuffix\u0022 attribute for F# modules, now somewhat legacy, rarely used, but still allowed; also where \u0022ModuleSuffix\u0022 is implied because type and module have the same name\n\n\nJsonProvider\nJsonProvider,Schema=\\\u0022xyz\\\u0022\nstatic parameters, see notes below for variations of display names\n\n\n\n\nValues:\n\n\n\nDisplay name in code\nRelation\nLogical name\nNotes\n\n\n\n\n(\u002B)\n\nop_Addition\n\n\n\n(\u002B )\n--\u0026gt;\nop_Addition\nnot reversed\n\n\nop_Addition\n--\u0026gt;\nop_Addition\nnot reversed\n\n\n(*)\n\nop_Multiply\n\n\n\n( * )\n--\u0026gt;\nop_Multiply\nnot reversed\n\n\nop_Multiply\n--\u0026gt;\nop_Multiply\nnot reversed\n\n\n( *\u002B )\n\nop_MultiplyPlus\n\n\n\n( *\u002B )\n--\u0026gt;\nop_MultiplyPlus\nnot reversed\n\n\nop_MultiplyPlus\n--\u0026gt;\nop_MultiplyPlus\nnot reversed\n\n\n(\u002B\u002B\u002B)\n\nop_PlusPlusPlus\n\n\n\nop_PlusPlusPlus\n--\u0026gt;\nop_PlusPlusPlus\nnot reversed\n\n\n(%)\n\nop_Modulus\n\n\n\nop_Modulus\n--\u0026gt;\nop_Modulus\n\n\n\n(?)\n\nop_Dynamic\nnot defined by default, for x?SomeThing\n\n\n(?\u0026lt;-)\n\nop_DynamicAssignment\nnot defined by default, for x?SomeThing \u0026lt;- \u0022a\u0022\n\n\n(..)\n\nop_Range\nfor \u00223 .. 5\u0022\n\n\n(.. ..)\n\nop_RangeStep\nfor \u00225 .. -1 .. 3\u0022\n\n\nor\n\nor\n\n\n\nmod\n\nmod\n\n\n\nlet\n\nlet\nthis is a keyword, in code it appears as let\n\n\ntype\n\ntype\nthis is a keyword, in code it appears as type\n\n\nbase\n\nbase\nfor IsBaseVal=true only. Base is a keyword, this is a special base val\n\n\nbase\n\nbase\nfor IsBaseVal=false only. Base is a keyword, this is not a special base val\n\n\nSomeClass\n\n.ctor\nIsConstructor=true\n\n\n.ctor\n\n.ctor\nIsConstructor=false, this is only allowed for let-definitions, e.g. let .ctor x = 1\n\n\n\n\n.cctor\nIsClassConstructor=true, should never really appear in diagnostics or user-facing output\n\n\n.cctor\n\n.cctor\nIsClassConstructor=false, this is only allowed for let-definitions, e.g. let .cctor x = 1\n\n\n(\\|A\\|_\\|)\n\n\\|A\\|_\\|\n\n\n\n(\\|A \\|_ \\|)\n--\u0026gt;\n\\|A\\|_\\|\nnot reversed\n\n\nP\n\nget_P\nIsPropertyGetterMethod = true\n\n\nP\n\nset_P\nIsPropertySetterMethod = true\n\n\n\n\nOther Val constructs less problematic for naming are:\n\n\n\nDisplay name in code\nRelation\nLogical name\nNotes\n\n\n\n\nthis\n\nthis\nIsCtorThisVal = true; From type C() as this; Can have any name, not particularly special with regard to names; This has a \u0027ref\u0027 type for initialization checks\n\n\nthis\n\nthis\nIsMemberThisVal = true; From member this.M() = ...; This can have a \u0027ref\u0027 type for initialization checks; Can have any name, not particularly special with regard to names\n\n\n\\\n\nSystem.IDisposable.Dispose\nImplementedSlotSigs is non-empty, i.e. length 1, should never really appear in diagnostics or user-facing output\n\n\n\n\nUnion cases:\n\n\n\nDisplay name in code\nRelation\nLogical name\nNotes\n\n\n\n\n\n\nSomeCase | | SomeCase\n\u0060\u0060Case with space\u0060\u0060 | | Case with space\n\u0060\u0060type\u0060\u0060 | | type | This is a keyword\n(::) | | op_ColonColon | This is the logical name for the cons union case on FSharpList only\n[] | | op_Nil | This is the logical name for the nil case on FSharpList only\nClass and record fields, enum cases, active pattern cases, anonymous record fields:\n\n\n\nDisplay name in code\nRelation\nLogical name\nNotes\n\n\n\n\n\n\nSomeField | | SomeField\n\u0060\u0060Field with space\u0060\u0060| | Field with space\n\u0060\u0060type\u0060\u0060 | | type | This is a keyword\nGeneric parameters:\n\n\n\nDisplay name in code\nRelation\nLogical name\nNotes\n\n\n\n\n\n\n\u0027T | | T\n\u0027\u0060\u0060T T T\u0060\u0060 | | T T T | BUG: the backticks are not currently added\n\u0027\u0060\u0060type\u0060\u0060 | | type | This is a keyword, BUG: the backticks are not currently added\nVariations on display names\nIn different display settings, Entities/Types/Modules can have some variations on display names. For example, when showing some kinds of output we may set shortTypeNames=true which will never show full names.\n\n\nSomeTypeProvider\n\nUsed for omitting static parameters\nAlias in code: entity.CompiledName\n\n\n\nSomeTypeProvider\u0026lt;...\u0026gt;\n\nUsed for eliding static parameters\n\n\n\nSomeTypeProvider\u0026lt;\u0022foo.json\u0022\u0026gt;\n\nUsed for showing static parameters. These can be very large, e.g. entire connection strings, so better to elide or omit.\nAlias in code: entity.DisplayNameWithStaticParameters\n\n\n\nList\u0026lt;_\u0026gt;\n\nUsed with underscore typars\nAlias in code: entity.DisplayNameWithStaticParametersAndUnderscoreTypars\n\n\n\nDictionary\u0026lt;\u0027TKey,\u0027TResult\u0026gt;\n\nUsed with general typars\n\n\nFull name\n\nExamples:\n- SomeNamespace.OtherNamespace.SomeType\n- \u0060\u0060Some Namespace With Spaces\u0060\u0060.SomeType \u003C-- BUG: not double-ticks today\n- \u0060SomeEnclosingType.SomeStaticMethod\u0060 \u0026lt;-- BUG: the mangled generic type counts are shown today\nCompiled names\nThe name that appears in the .NET IL.\nAffected by:\n- CompiledName attribute\n- some heuristics for generic type parameters\nAlso the name from signature is generally preferred; if there is any difference, a warning is emitted.\nExample of how signature affects compiled names\nFoo.fsi \n\n val SomeFunction: x: int -\u0026gt; y: int -\u0026gt; int \n\nFoo.fs\n\n let SomeFunction a b = a \u002B b // compiled name of parameters is x, y - warning emitted\n\n","headings":["Names of entities and values in the F# Compiler","Specification of all logical names","Variations on display names","Compiled names"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/index.html","title":"F# compiler guide\n","content":"F# compiler guide\nWelcome to the F# compiler and tools repository! This guide discusses the F# compiler source code and implementation from a technical point of view.\nDocumentation Topics\n\nOverview\nCoding Standards\nCompiler Startup Performance\nDebug Emit\nDiagnostics\nNotes on FSharp.Core\nF# Interactive Code Emit\nLarge inputs and stack overflows\nMemory usage\nOptimizations\nProject builds\nTooling features\n\nEdit the source for these docs. The docs are published automatically daily fsharp.github.io/fsharp-compiler-docs/ by this repo.\nKey Folders\n\nsrc/Compiler/Utilities - various utilities, largely independent of the compiler\nsrc/Compiler/Facilities - various items of functionality specific to the compiler\nsrc/Compiler/AbstractIL - the Abstract IL library used for .NET IL\nsrc/Compiler/SyntaxTree - the SyntaxTree, parsing and lexing\nsrc/Compiler/TypedTree - the TypedTree, and utilities associated with it\nsrc/Compiler/Checking - checking logic\nsrc/Compiler/Optimize - optimization and \u0022lowering\u0022 logic\nsrc/Compiler/CodeGen - IL code generation logic\nsrc/Compiler/Driver - compiler options, diagnostics and other coordinating functionality\nsrc/Compiler/Symbols - symbols in the public API to the compiler\nsrc/Compiler/Service - the incremental compilation and build logic, plus editor services in the public API to the compiler\nsrc/Compiler/Interactive - the components forming the interactive REPL and core of the notebook engine\nsrc/FSharp.Core - the core library\ntests - the tests\nvsintegration - the Visual Studio integration\n\nResources for learning\n\nChannel: F# Software Foundation compiler sessions\nVideo: Learn me some F# Compiler, an online chat with Vlad and Don\nVideo: Understanding the F# Optimizer, and online chat with Vlad and Don\nVideo: Lexer and Parser, an online chat with Vlad and Don\nVideo: Resumable State Machines, an online chat with Vlad and Don\nVideo: The Typechecker, an online chat with Vlad and Don\nVideo: FSharp.Compiler.Service, an online chat with Vlad and Don\n\nTools to help work with the compiler\n\nsharplab.io can be used to decompile code.\nfantomas-tools can be used to view the Untyped Abstract Syntax Tree.\n\nAttribution\nThis document is based on an original document published in 2015 by the F# Software Foundation. It has since been updated substantially.\n","headings":["F# compiler guide","Documentation Topics","Key Folders","Resources for learning","Tools to help work with the compiler","Attribution"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/tooling-features.html","title":"Overview","content":"\nOverview\nThe F# Language Service (FSharp.Editor, using FSharp.Compiler.Service) is designed to support tooling in Visual Studio and other IDEs. This document gives an overview of the features supported and notes on their technical characteristics.\nKinds of data processed and served in F# tooling\nThe following tables are split into two categories: syntactic and semantic. They contain common kinds of information requested, the kind of data that is involved, and roughly how expensive the operation is in terms of expected memory allocation and CPU processing.\nIDE actions based on syntax\n\n\n\nAction\nData inspected\nData returned\nExpected CPU/Allocations (S/M/L/XL)\n\n\n\n\nSyntactic Classification\nCurrent doc\u0027s source text\nText span and classification type for each token in the document\nS\n\n\nBreakpoint Resolution\nCurrent doc\u0027s syntax tree\nText span representing where breakpoints were resolved\nS\n\n\nDebugging data tip info\nCurrent doc\u0027s source text\nText span representing the token being inspected\nS\n\n\nBrace pair matching\nCurrent doc\u0027s source text\nText spans representing brace pairs that match in the input document\nS\n\n\n\u0022Smart\u0022 indentation\nCurrent doc\u0027s source text\nIndentation location in a document\nS\n\n\nCode fixes operating only on syntax\nCurrent doc\u0027s source text\nSmall text change for document\nS\n\n\nXML doc template generation\nCurrent doc\u0027s syntax tree\nSmall (usually) text change for document\nS\n\n\nBrace pair completion\nCurrent doc\u0027s source text\nAdditional brace pair inserted into source text\nS\n\n\nSouce document navigation\nCurrent doc\u0027s syntax tree\n\u0022Navigation Items\u0022 with optional child navigation items containing ranges in source code\nS\n\n\nCode outlining\nCurrent doc\u0027s source text\nText spans representing blocks of F# code that are collapsable as a group\nS - M\n\n\nEditor formatting\nCurrent doc\u0027s source text\nNew source text for the document\nS - L\n\n\nSyntax diagnostics\nCurrent doc\u0027s source text\nList of diagnostic data including the span of text corresponding to the diagnostic\nS\n\n\nGlobal construct search and navigation\nAll syntax trees for all projects\nAll items that match a user\u0027s search pattern with spans of text that represent where a given item is located\nS-L\n\n\n\n\nYou likely noticed that nearly all of the syntactical operations are marked S. Aside from extreme cases, like files with 50k lines or higher, syntax-only operations typically finish very quickly. In addition to being computationally inexpensive, they are also run asynchronously and free-threaded.\nEditor formatting is a bit of an exception. Most IDEs offer common commands for format an entire document, and although they also offer commands to format a given text selection, users typically choose to format the whole document. This means an entire document has to be inspected and potentially rewritten based on often complex rules. In practice this isn\u0027t bad when working with a document that has already been formatted, but it can be expensive for larger documents with strange stylistic choices.\nMost of the syntax operations require an entire document\u0027s source text or parse tree. It stands to reason that this could be improved by operating on a diff of a parse tree instead of the whole thing. This is likely a very complex thing to implement though, since none of the F# compiler infrastructure works in this way today.\nIDE actions based on semantics\n\n\n\nAction\nData inspected\nData returned\nExpected CPU/Allocations (S/M/L/XL)\n\n\n\n\nMost code fixes\nCurrent document\u0027s typecheck data\nSet (1 or more) of suggested text replacements\nS-M\n\n\nSemantic classification\nCurrent document\u0027s typecheck data\nSpans of text with semantic classification type for all constructs in a document\nS-L\n\n\nCode generation / refactorings\nCurrent document\u0027s typecheck data and/or current resolved symbol/symbols\nText replacement(s)\nS-L\n\n\nCode completion\nCurrent document\u0027s typecheck data and currently-resolved symbol user is typing at\nList of all symbols in scope that are \u0022completable\u0022 based on where completion is invoked\nS-L\n\n\nEditor tooltips\nCurrent document\u0027s typecheck data and resolved symbol where user invoked a tooltip\nF# tooltip data based on inspecting a type and its declarations, then pretty-printing them\nS-XL\n\n\nDiagnostics based on F# semantics\nCurrent document\u0027s typecheck data\nDiagnostic info for each symbol with diagnostics to show, including the range of text associated with the diagnostic\nM-XL\n\n\nSymbol highlighting in a document\nCurrent document\u0027s typecheck data and currently-resolved symbol where user\u0027s caret is located\nRanges of text representing instances of that symbol in the document\nS-M\n\n\nSemantic navigation (for example, Go to Definition)\nCurrent document\u0027s typecheck data and currently-resolved symbol where the user invoked navigation\nLocation of a symbol\u0027s declaration\nS-M\n\n\nRename\nGraph of all projects that use the symbol that rename is triggered on and the typecheck data for each of those projects\nList of all uses of all symbols that are to be renamed\nS-XL\n\n\nFind all references\nGraph of all projects that Find References is triggered on and the typecheck data for each of those projects\nList of all uses of all symbols that are found\nS-XL\n\n\nUnused value/symbol analysis\nTypecheck data for the current document\nList of all symbols that aren\u0027t a public API and are unused\nS-M\n\n\nUnused open analysis\nTypecheck data for the current document and all symbol data brought into scope by each open declaration\nList of open declarations whose symbols it exposes aren\u0027t used in the current document\nS-L\n\n\nMissing open analysis\nTypecheck data for the current document, resolved symbol with an error, and list of available namespaces or modules\nList of candidate namespaces or modules that can be opened\nS-M\n\n\nMisspelled name suggestion analysis\nTypecheck data for the current document and resolved symbol with an error\nList of candidates that are in scope and best match the misspelled name based on a string distance algorithm\nS-M\n\n\nName simplification analysis\nTypecheck data for the current document and all symbol data brought into scope by each open declaration\nList of text changes available for any fully- or partially-qualified symbol that can be simplified\nS-XL\n\n\n\n\nYou likely noticed that every cost associated with an action has a range. This is based on two factors:\n\nIf the semantic data being operated on is cached\nHow much semantic data must be processed for the action to be completed\n\nMost actions are S if they operate on cached data and the compiler determines that no data needs to be re-computed. The size of their range is influenced largely by the kind of semantic operations each action has to do, such as:\n\nTypechecking a single document and processing the resulting data\nTypechecking a document and its containing project and then processing the resulting data\nResolving a single symbol in a document\nResolving the definition of a single symbol in a codebase\nInspecting all symbols brought into scope by a given open declaration\nInspecting all symbols in a document\nInspecting all symbols in all documents contained in a graph of projects\n\nFor example, commands like Find All References and Rename can be cheap if a codebase is small, hence the lower bound being S. But if the symbol in question is used across many documents in a large project graph, they are very expensive because the entire graph must be crawled and all symbols contained in its documents must be inspected.\nIn contrast, actions like highlighting all symbols in a document aren\u0027t terribly expensive even for very large files. That\u0027s because the symbols to be inspected are ultimately only in a single document.\n","headings":["Overview","Kinds of data processed and served in F# tooling","IDE actions based on syntax","IDE actions based on semantics"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/release-notes/About.html","title":"About","content":"\nAbout\nThe release notes for the F# language, FSharp.Core and FSharp.Compiler.Service are based on the Keep a Changelog format.\nThe target audience of these release notes are the respective end-users.\nWriting a changelog entry\nIn order to keep the change logs consistent the following format was proposed for each entry:\n* \u0026lt;Informative description\u0026gt;. ([PR #16106](https://github.com/dotnet/fsharp/pull/16106))\n\nSome tips:\n\nUse valid Markdown.\nUse * as bullet point symbol. We don\u0027t want to mix * and -.\nStart your description with a capital and end the sentence with a dot.\nAlways include a link to your pull request before the closing ), ([PR #16106](https://github.com/dotnet/fsharp/pull/16106)).\nOptionally, include a link to an issue on dotnet/fsharp use Issue #number before the link to the pull request.\n\nExample:\n* Correctly handle assembly imports with public key token of 0 length. ([Issue #16359](https://github.com/dotnet/fsharp/issues/16359), [PR #16363](https://github.com/dotnet/fsharp/pull/16363))\n\n\nOptionally, include a link to a language suggestion from dotnet/fsharp use Language suggestion #number before the link to the pull request.\n\nExample:\n* \u0060while!\u0060 ([Language suggestion #1038](https://github.com/fsharp/fslang-suggestions/issues/1038), [PR #14238](https://github.com/dotnet/fsharp/pull/14238))\n\n\nChoose the right section for your type of change. (## Added, ## Changed, ## Deprecated, ## Removed, ## Fixed or ## Security).\nEnsure your description makes it clear what the change is about. The reader should be informed on a high level without needing to click through the pull request link and find out in the code what actually changed.\nMaintainers or other contributors might rewrite your changelog entry in the future. This might be done when multiple pull requests can be consolidated under the same umbrella.\nRelated pull requests can be listed in the same entry when it makes sense.\n\nExample:\n* Miscellaneous fixes to parentheses analysis. ([PR #16262](https://github.com/dotnet/fsharp/pull/16262), [PR #16391](https://github.com/dotnet/fsharp/pull/16391), [PR #16370](https://github.com/dotnet/fsharp/pull/16370))\n\nThe release process\nGeneral\nHow does it work? Different stages/phases?\nFSharp.Compiler.Service\nPerhaps add some specific info if available?\n","headings":["About","Writing a changelog entry","The release process","General","FSharp.Compiler.Service"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/release-notes/Language.html","title":"F# Language","content":"\nF# Language\nPreviewAdded\n\nBetter generic unmanaged structs handling. (Language suggestion #692, PR #12154)\nBidirectional F#/C# interop for \u0027unmanaged\u0027 constraint. (PR #12154)\nMake .Is* discriminated union properties visible. (Language suggestion #222, PR #16341)\n\nFixed\n\nAllow extension methods without type attribute work for types from imported assemblies. (PR #16368)\n\n\n8.0Added\n\nwhile! (Language suggestion #1038, PR #14238)\n\n\n","headings":["F# Language","Preview","Added","Fixed","8.0","Added"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/release-notes/FSharp.Core.html","title":"FSharp.Core","content":"\nFSharp.Core\n8.0.200 - UnreleasedFixed\n\nMiscellaneous fixes to parentheses analysis. (PR #16262, PR #16391, PR #16370, PR #16395, PR #16372)\nCorrectly handle assembly imports with public key token of 0 length. (Issue #16359, PR #16363)\nRange of SynField (PR #16357)\nLimit a type to 65K methods, introduce a compile-time error if any class has over approx 64K methods in generated IL. (Issue #16398, #PR 16427)\n\nAdded\n\nRaise a new error when interfaces with auto properties are implemented on constructor-less types. (PR #16352)\n\nAllow usage of [\u0026lt;TailCall\u0026gt;] with older FSharp.Core package versions. (PR #16373)\n\nParser recovers on unfinished as patterns. (PR #16404)\n\nAllow type-checking of unfinished object expressions. (PR #16413)\n\nParser recovers on unfinished enum case declarations. (PR #16401)\n\nParser recovers on unfinished record declarations. (PR #16357)\n\nMutableKeyword to SynFieldTrivia (PR #16357)\n\nAdded support for a new parameterless constructor for CustomOperationAttribute, which, when applied, will use method name as keyword for custom operation in computation expression builder. (PR #16475, part of implementation for fslang-suggestions/1250)\n\nParser recovers on complex primary constructor patterns, better tree representation for primary constructor patterns. (PR #16425)\n\n\nChanged\n\nimplicitCtorSynPats in SynTypeDefnSimpleRepr.General is now SynPat option instead of SynSimplePats option. (PR #16425)\nSyntaxVisitorBase\u0026lt;\u0027T\u0026gt;.VisitSimplePats now takes SynPat instead of SynSimplePat list. (PR #16425)\nSpeed up unused opens handling for empty results. (PR #16502)\n\n\n8.0.100 - 2023-11-14Fixed\n\nInclude the get,set keywords in the range of SynMemberDefn.AutoProperty. (PR #15835)\n\n\n","headings":["FSharp.Core","8.0.200 - Unreleased","Fixed","Added","Changed","8.0.100 - 2023-11-14","Fixed"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/release-notes/FSharp.Compiler.Service.html","title":"FSharp.Compiler.Service","content":"\nFSharp.Compiler.Service\n43.8.200 - UnreleasedFixed\n\nMiscellaneous fixes to parentheses analysis. (PR #16262, PR #16391, PR #16370, PR #16395, PR #16372)\nCorrectly handle assembly imports with public key token of 0 length. (Issue #16359, PR #16363)\nRange of SynField (PR #16357)\nLimit a type to 65K methods, introduce a compile-time error if any class has over approx 64K methods in generated IL. (Issue #16398, #PR 16427)\n\nAdded\n\nRaise a new error when interfaces with auto properties are implemented on constructor-less types. (PR #16352)\n\nAllow usage of [\u0026lt;TailCall\u0026gt;] with older FSharp.Core package versions. (PR #16373)\n\nParser recovers on unfinished as patterns. (PR #16404)\n\nAllow type-checking of unfinished object expressions. (PR #16413)\n\nParser recovers on unfinished enum case declarations. (PR #16401)\n\nParser recovers on unfinished record declarations. (PR #16357)\n\nMutableKeyword to SynFieldTrivia (PR #16357)\n\nAdded support for a new parameterless constructor for CustomOperationAttribute, which, when applied, will use method name as keyword for custom operation in computation expression builder. (PR #16475, part of implementation for fslang-suggestions/1250)\n\nParser recovers on complex primary constructor patterns, better tree representation for primary constructor patterns. (PR #16425)\n\n\nChanged\n\nimplicitCtorSynPats in SynTypeDefnSimpleRepr.General is now SynPat option instead of SynSimplePats option. (PR #16425)\nSyntaxVisitorBase\u0026lt;\u0027T\u0026gt;.VisitSimplePats now takes SynPat instead of SynSimplePat list. (PR #16425)\nSpeed up unused opens handling for empty results. (PR #16502)\n\n\n43.8.100 - 2023-11-14Fixed\n\nInclude the get,set keywords in the range of SynMemberDefn.AutoProperty. (PR #15835)\n\n\n","headings":["FSharp.Compiler.Service","43.8.200 - Unreleased","Fixed","Added","Changed","43.8.100 - 2023-11-14","Fixed"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/untypedtree.html","title":"Tutorial: Expressions","content":"\nCompiler Services: Processing SyntaxTree\nThis tutorial demonstrates how to get the SyntaxTree (AST)\nfor F# code and how to walk over the tree. This can be used for creating tools\nsuch as code formatter, basic refactoring or code navigation tools. The untyped\nsyntax tree contains information about the code structure, but does not contain\ntypes and there are some ambiguities that are resolved only later by the type\nchecker. You can also combine the SyntaxTree information with the API available\nfrom editor services.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published\n\nGetting the SyntaxTree\nTo access the untyped AST, you need to create an instance of FSharpChecker.\nThis type represents a context for type checking and parsing and corresponds either\nto a stand-alone F# script file (e.g. opened in Visual Studio) or to a loaded project\nfile with multiple files. Once you have an instance of FSharpChecker, you can\nuse it to perform \u0022untyped parse\u0022 which is the first step of type-checking. The\nsecond phase is \u0022typed parse\u0022 and is used by editor services.\nTo use the interactive checker, reference FSharp.Compiler.Service.dll and open the\nSourceCodeServices namespace:\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\nopen System\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.Text\n\nPerforming untyped parse\nThe untyped parse operation is very fast (compared to type checking, which can\ntake notable amount of time) and so we can perform it synchronously. First, we\nneed to create FSharpChecker - the constructor takes an argument that\ncan be used to notify the checker about file changes (which we ignore).\n// Create an interactive checker instance \nlet checker = FSharpChecker.Create()\n\nTo get the AST, we define a function that takes file name and the source code\n(the file is only used for location information and does not have to exist).\nWe first need to get \u0022interactive checker options\u0022 which represents the context.\nFor simple tasks, you can use GetProjectOptionsFromScriptRoot which infers\nthe context for a script file. Then we use the ParseFile method and\nreturn the ParseTree property:\n/// Get untyped tree for a specified input\nlet getUntypedTree (file, input) = \n // Get compiler options for the \u0026#39;project\u0026#39; implied by a single script file\n let projOptions, diagnostics = \n checker.GetProjectOptionsFromScript(file, input, assumeDotNetFramework=false)\n |\u0026gt; Async.RunSynchronously\n\n let parsingOptions, _errors = checker.GetParsingOptionsFromProjectOptions(projOptions)\n\n // Run the first phase (untyped parsing) of the compiler\n let parseFileResults = \n checker.ParseFile(file, input, parsingOptions) \n |\u0026gt; Async.RunSynchronously\n\n parseFileResults.ParseTree\n \n\nWalking over the AST\nThe abstract syntax tree is defined as a number of discriminated unions that represent\ndifferent syntactical elements (such as expressions, patterns, declarations etc.). The best\nway to understand the AST is to look at the definitions in\nSyntaxTree.fsi\nin the source code.\nThe relevant parts are in the following namespace:\nopen FSharp.Compiler.Syntax\n\nWhen processing the AST, you will typically write a number of mutually recursive functions\nthat pattern match on the different syntactical elements. There is a number of elements\nthat need to be supported - the top-level element is module or namespace declaration,\ncontaining declarations inside a module (let bindings, types etc.). A let declaration inside\na module then contains expressions, which can contain patterns.\nWalking over patterns and expressions\nWe start by looking at functions that walk over expressions and patterns - as we walk,\nwe print information about the visited elements. For patterns, the input is of type\nSynPat and has a number of cases including Wild (for _ pattern), Named (for\n\u0026lt;pat\u0026gt; as name) and LongIdent (for a Foo.Bar name). Note that the parsed pattern\nis occasionally more complex than what is in the source code (in particular, Named is\nused more often):\n/// Walk over a pattern - this is for example used in \n/// let \u0026lt;pat\u0026gt; = \u0026lt;expr\u0026gt; or in the \u0026#39;match\u0026#39; expression\nlet rec visitPattern = function\n | SynPat.Wild _ -\u0026gt; \n printfn \u0026quot; .. underscore pattern\u0026quot;\n | SynPat.Named(ident = SynIdent(ident = name)) -\u0026gt;\n printfn \u0026quot; .. named as \u0026#39;%s\u0026#39;\u0026quot; name.idText\n | SynPat.LongIdent(longDotId = SynLongIdent(id = ident)) -\u0026gt;\n let names = String.concat \u0026quot;.\u0026quot; [ for i in ident -\u0026gt; i.idText ]\n printfn \u0026quot; .. identifier: %s\u0026quot; names\n | pat -\u0026gt; printfn \u0026quot; .. other pattern: %A\u0026quot; pat\n\nThe function is recursive (for nested patterns such as (foo, _) as bar), but it does not\ncall any of the functions defined later (because patterns cannot contain other syntactical\nelements).\nThe next function iterates over expressions - this is where most of the work would be and\nthere are around 20 cases to cover (type SynExpr. and you\u0027ll get completion with other\noptions). In the following, we only show how to handle if .. then .. and let .. = ...:\n/// Walk over an expression - if expression contains two or three \n/// sub-expressions (two if the \u0026#39;else\u0026#39; branch is missing), let expression\n/// contains pattern and two sub-expressions\nlet rec visitExpression e = \n match e with\n | SynExpr.IfThenElse(ifExpr=cond; thenExpr=trueBranch; elseExpr=falseBranchOpt) -\u0026gt;\n // Visit all sub-expressions\n printfn \u0026quot;Conditional:\u0026quot;\n visitExpression cond\n visitExpression trueBranch\n falseBranchOpt |\u0026gt; Option.iter visitExpression \n\n | SynExpr.LetOrUse(_, _, bindings, body, _, _) -\u0026gt;\n // Visit bindings (there may be multiple \n // for \u0026#39;let .. = .. and .. = .. in ...\u0026#39;\n printfn \u0026quot;LetOrUse with the following bindings:\u0026quot;\n for binding in bindings do\n let (SynBinding(headPat = headPat; expr = init)) = binding\n visitPattern headPat\n visitExpression init\n // Visit the body expression\n printfn \u0026quot;And the following body:\u0026quot;\n visitExpression body\n | expr -\u0026gt; printfn \u0026quot; - not supported expression: %A\u0026quot; expr\n\nThe visitExpression function will be called from a function that visits all top-level\ndeclarations inside a module. In this tutorial, we ignore types and members, but that would\nbe another source of calls to visitExpression.\nWalking over declarations\nAs mentioned earlier, the AST of a file contains a number of module or namespace declarations\n(top-level node) that contain declarations inside a module (let bindings or types) or inside\na namespace (just types). The following function walks over declarations - we ignore types,\nnested modules and all other elements and look only at top-level let bindings (values and\nfunctions):\n/// Walk over a list of declarations in a module. This is anything\n/// that you can write as a top-level inside module (let bindings,\n/// nested modules, type declarations etc.)\nlet visitDeclarations decls = \n for declaration in decls do\n match declaration with\n | SynModuleDecl.Let(isRec, bindings, range) -\u0026gt;\n // Let binding as a declaration is similar to let binding\n // as an expression (in visitExpression), but has no body\n for binding in bindings do\n let (SynBinding(headPat = pat; expr = body)) = binding\n visitPattern pat \n visitExpression body \n | _ -\u0026gt; printfn \u0026quot; - not supported declaration: %A\u0026quot; declaration\n\nThe visitDeclarations function will be called from a function that walks over a\nsequence of module or namespace declarations. This corresponds, for example, to a file\nwith multiple namespace Foo declarations:\n/// Walk over all module or namespace declarations \n/// (basically \u0026#39;module Foo =\u0026#39; or \u0026#39;namespace Foo.Bar\u0026#39;)\n/// Note that there is one implicitly, even if the file\n/// does not explicitly define it..\nlet visitModulesAndNamespaces modulesOrNss =\n for moduleOrNs in modulesOrNss do\n let (SynModuleOrNamespace(longId = lid; decls = decls)) = moduleOrNs\n printfn \u0026quot;Namespace or module: %A\u0026quot; lid\n visitDeclarations decls\n\nNow that we have functions that walk over the elements of the AST (starting from declaration,\ndown to expressions and patterns), we can get AST of a sample input and run the above function.\nPutting things together\nAs already discussed, the getUntypedTree function uses FSharpChecker to run the first\nphase (parsing) on the AST and get back the tree. The function requires F# source code together\nwith location of the file. The location does not have to exist (it is used only for location\ninformation) and it can be in both Unix and Windows formats:\n// Sample input for the compiler service\nlet input =\n \u0026quot;\u0026quot;\u0026quot;\n let foo() = \n let msg = \u0026quot;Hello world\u0026quot;\n if true then \n printfn \u0026quot;%s\u0026quot; msg\n \u0026quot;\u0026quot;\u0026quot;\n\n// File name in Unix format\nlet file = \u0026quot;/home/user/Test.fsx\u0026quot;\n\n// Get the AST of sample F# code\nlet tree = getUntypedTree(file, SourceText.ofString input)\n\nWhen you run the code in F# interactive, you can enter tree;; in the interactive console and\nsee a pretty printed representation of the data structure - the tree contains a lot of information,\nso this is not particularly readable, but it gives you a good idea about how the tree looks.\nThe returned tree value is again a discriminated union that can be two different cases - one case\nis ParsedInput.SigFile which represents F# signature file (*.fsi) and the other one is\nParsedInput.ImplFile representing regular source code (*.fsx or *.fs). The implementation\nfile contains a sequence of modules or namespaces that we can pass to the function implemented\nin the previous step:\n// Extract implementation file details\nmatch tree with\n| ParsedInput.ImplFile(implFile) -\u0026gt;\n // Extract declarations and walk over them\n let (ParsedImplFileInput(contents = modules)) = implFile\n visitModulesAndNamespaces modules\n| _ -\u0026gt; failwith \u0026quot;F# Interface file (*.fsi) not supported.\u0026quot;\n\nSummary\nIn this tutorial, we looked at the basics of working with the untyped abstract syntax tree. This is a\ncomprehensive topic, so it is not possible to explain everything in a single article. The\nFantomas project is a good example of a tool based on the untyped\nAST that can help you understand more. In practice, it is also useful to combine the information here\nwith some information you can obtain from the editor services discussed in the next\ntutorial.\n","headings":["Compiler Services: Processing SyntaxTree","Getting the SyntaxTree","Performing untyped parse","Walking over the AST","Walking over patterns and expressions","Walking over declarations","Putting things together","Summary"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/project.html","title":"Tutorial: Project analysis","content":"\nCompiler Services: Project Analysis\nThis tutorial demonstrates how you can analyze a whole project using services provided by the F# compiler.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.\n\nGetting whole-project results\nAs in the previous tutorial (using untyped AST), we start by referencing\nFSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance\nof InteractiveChecker:\n// Reference F# compiler API\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\n\nopen System\nopen System.Collections.Generic\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.Symbols\nopen FSharp.Compiler.Text\n\n// Create an interactive checker instance\nlet checker = FSharpChecker.Create()\n\nHere are our sample inputs:\nmodule Inputs =\n open System.IO\n\n let base1 = Path.GetTempFileName()\n let fileName1 = Path.ChangeExtension(base1, \u0026quot;.fs\u0026quot;)\n let base2 = Path.GetTempFileName()\n let fileName2 = Path.ChangeExtension(base2, \u0026quot;.fs\u0026quot;)\n let dllName = Path.ChangeExtension(base2, \u0026quot;.dll\u0026quot;)\n let projFileName = Path.ChangeExtension(base2, \u0026quot;.fsproj\u0026quot;)\n\n let fileSource1 =\n \u0026quot;\u0026quot;\u0026quot;\nmodule M\n\ntype C() =\n member x.P = 1\n\nlet xxx = 3 \u002B 4\nlet fff () = xxx \u002B xxx\n \u0026quot;\u0026quot;\u0026quot;\n\n File.WriteAllText(fileName1, fileSource1)\n\n let fileSource2 =\n \u0026quot;\u0026quot;\u0026quot;\nmodule N\n\nopen M\n\ntype D1() =\n member x.SomeProperty = M.xxx\n\ntype D2() =\n member x.SomeProperty = M.fff() \u002B D1().P\n\n// Generate a warning\nlet y2 = match 1 with 1 -\u0026gt; M.xxx\n \u0026quot;\u0026quot;\u0026quot;\n\n File.WriteAllText(fileName2, fileSource2)\n\nWe use GetProjectOptionsFromCommandLineArgs to treat two files as a project:\nlet projectOptions =\n let sysLib nm =\n if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then\n // file references only valid on Windows\n System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)\n \u002B @\u0026quot;\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.0\\\u0026quot;\n \u002B nm\n \u002B \u0026quot;.dll\u0026quot;\n else\n let sysDir =\n System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()\n\n let (\u002B\u002B) a b = System.IO.Path.Combine(a, b)\n sysDir \u002B\u002B nm \u002B \u0026quot;.dll\u0026quot;\n\n let fsCore4300 () =\n if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then\n // file references only valid on Windows\n System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)\n \u002B @\u0026quot;\\Reference Assemblies\\Microsoft\\FSharp\\.NETFramework\\v4.0\\4.3.0.0\\FSharp.Core.dll\u0026quot;\n else\n sysLib \u0026quot;FSharp.Core\u0026quot;\n\n checker.GetProjectOptionsFromCommandLineArgs(\n Inputs.projFileName,\n [| yield \u0026quot;--simpleresolution\u0026quot;\n yield \u0026quot;--noframework\u0026quot;\n yield \u0026quot;--debug:full\u0026quot;\n yield \u0026quot;--define:DEBUG\u0026quot;\n yield \u0026quot;--optimize-\u0026quot;\n yield \u0026quot;--out:\u0026quot; \u002B Inputs.dllName\n yield \u0026quot;--doc:test.xml\u0026quot;\n yield \u0026quot;--warn:3\u0026quot;\n yield \u0026quot;--fullpaths\u0026quot;\n yield \u0026quot;--flaterrors\u0026quot;\n yield \u0026quot;--target:library\u0026quot;\n yield Inputs.fileName1\n yield Inputs.fileName2\n let references =\n [ sysLib \u0026quot;mscorlib\u0026quot;\n sysLib \u0026quot;System\u0026quot;\n sysLib \u0026quot;System.Core\u0026quot;\n fsCore4300 () ]\n\n for r in references do\n yield \u0026quot;-r:\u0026quot; \u002B r |]\n )\n\nNow check the entire project (using the files saved on disk):\nlet wholeProjectResults =\n checker.ParseAndCheckProject(projectOptions)\n |\u0026gt; Async.RunSynchronously\n\nNow look at the errors and warnings:\nwholeProjectResults.Diagnostics.Length // 1\n\nwholeProjectResults.Diagnostics.[0]\n .Message.Contains(\u0026quot;Incomplete pattern matches on this expression\u0026quot;) // yes it does\n\nwholeProjectResults.Diagnostics.[0].StartLine\nwholeProjectResults.Diagnostics.[0].EndLine\nwholeProjectResults.Diagnostics.[0].StartColumn\nwholeProjectResults.Diagnostics.[0].EndColumn\n\nNow look at the inferred signature for the project:\n[ for x in wholeProjectResults.AssemblySignature.Entities -\u0026gt; x.DisplayName ] // [\u0026quot;N\u0026quot;; \u0026quot;M\u0026quot;]\n\n[ for x in\n wholeProjectResults.AssemblySignature.Entities.[0]\n .NestedEntities -\u0026gt; x.DisplayName ] // [\u0026quot;D1\u0026quot;; \u0026quot;D2\u0026quot;]\n\n[ for x in\n wholeProjectResults.AssemblySignature.Entities.[1]\n .NestedEntities -\u0026gt; x.DisplayName ] // [\u0026quot;C\u0026quot;]\n\n[ for x in\n wholeProjectResults.AssemblySignature.Entities.[0]\n .MembersFunctionsAndValues -\u0026gt; x.DisplayName ] // [\u0026quot;y\u0026quot;; \u0026quot;y2\u0026quot;]\n\nYou can also get all symbols in the project:\nlet rec allSymbolsInEntities (entities: IList\u0026lt;FSharpEntity\u0026gt;) =\n [ for e in entities do\n yield (e :\u0026gt; FSharpSymbol)\n\n for x in e.MembersFunctionsAndValues do\n yield (x :\u0026gt; FSharpSymbol)\n\n for x in e.UnionCases do\n yield (x :\u0026gt; FSharpSymbol)\n\n for x in e.FSharpFields do\n yield (x :\u0026gt; FSharpSymbol)\n\n yield! allSymbolsInEntities e.NestedEntities ]\n\nlet allSymbols =\n allSymbolsInEntities wholeProjectResults.AssemblySignature.Entities\n\nAfter checking the whole project, you can access the background results for individual files\nin the project. This will be fast and will not involve any additional checking.\nlet backgroundParseResults1, backgroundTypedParse1 =\n checker.GetBackgroundCheckResultsForFileInProject(Inputs.fileName1, projectOptions)\n |\u0026gt; Async.RunSynchronously\n\nYou can now resolve symbols in each file:\nlet xSymbolUseOpt =\n backgroundTypedParse1.GetSymbolUseAtLocation(9, 9, \u0026quot;\u0026quot;, [ \u0026quot;xxx\u0026quot; ])\n\nlet xSymbolUse = xSymbolUseOpt.Value\n\nlet xSymbol = xSymbolUse.Symbol\n\nYou can find out more about a symbol by doing type checks on various symbol kinds:\nlet xSymbolAsValue =\n match xSymbol with\n | :? FSharpMemberOrFunctionOrValue as xSymbolAsVal -\u0026gt; xSymbolAsVal\n | _ -\u0026gt; failwith \u0026quot;we expected this to be a member, function or value\u0026quot;\n\nFor each symbol, you can look up the references to that symbol:\nlet usesOfXSymbol =\n wholeProjectResults.GetUsesOfSymbol(xSymbol)\n\nYou can iterate all the defined symbols in the inferred signature and find where they are used:\nlet allUsesOfAllSignatureSymbols =\n [ for s in allSymbols do\n let uses = wholeProjectResults.GetUsesOfSymbol(s)\n yield s.ToString(), uses ]\n\nYou can also look at all the symbols uses in the whole project (including uses of symbols with local scope)\nlet allUsesOfAllSymbols =\n wholeProjectResults.GetAllUsesOfAllSymbols()\n\nYou can also request checks of updated versions of files within the project (note that the other files\nin the project are still read from disk, unless you are using the FileSystem API):\nlet parseResults1, checkAnswer1 =\n checker.ParseAndCheckFileInProject(Inputs.fileName1, 0, SourceText.ofString Inputs.fileSource1, projectOptions)\n |\u0026gt; Async.RunSynchronously\n\nlet checkResults1 =\n match checkAnswer1 with\n | FSharpCheckFileAnswer.Succeeded x -\u0026gt; x\n | _ -\u0026gt; failwith \u0026quot;unexpected aborted\u0026quot;\n\nlet parseResults2, checkAnswer2 =\n checker.ParseAndCheckFileInProject(Inputs.fileName2, 0, SourceText.ofString Inputs.fileSource2, projectOptions)\n |\u0026gt; Async.RunSynchronously\n\nlet checkResults2 =\n match checkAnswer2 with\n | FSharpCheckFileAnswer.Succeeded x -\u0026gt; x\n | _ -\u0026gt; failwith \u0026quot;unexpected aborted\u0026quot;\n\nAgain, you can resolve symbols and ask for references:\nlet xSymbolUse2Opt =\n checkResults1.GetSymbolUseAtLocation(9, 9, \u0026quot;\u0026quot;, [ \u0026quot;xxx\u0026quot; ])\n\nlet xSymbolUse2 = xSymbolUse2Opt.Value\n\nlet xSymbol2 = xSymbolUse2.Symbol\n\nlet usesOfXSymbol2 =\n wholeProjectResults.GetUsesOfSymbol(xSymbol2)\n\nOr ask for all the symbols uses in the file (including uses of symbols with local scope)\nlet allUsesOfAllSymbolsInFile1 =\n checkResults1.GetAllUsesOfAllSymbolsInFile()\n\nOr ask for all the uses of one symbol in one file:\nlet allUsesOfXSymbolInFile1 =\n checkResults1.GetUsesOfSymbolInFile(xSymbol2)\n\nlet allUsesOfXSymbolInFile2 =\n checkResults2.GetUsesOfSymbolInFile(xSymbol2)\n\nAnalyzing multiple projects\nIf you have multiple F# projects to analyze which include references from some projects to others,\nthen the simplest way to do this is to build the projects and specify the cross-project references using\na -r:path-to-output-of-project.dll argument in the ProjectOptions. However, this requires the build\nof each project to succeed, producing the DLL file on disk which can be referred to.\nIn some situations, e.g. in an IDE, you may wish to allow references to other F# projects prior to successful compilation to\na DLL. To do this, fill in the ProjectReferences entry in ProjectOptions, which recursively specifies the project\noptions for dependent projects. Each project reference still needs a corresponding -r:path-to-output-of-project.dll\ncommand line argument in ProjectOptions, along with an entry in ProjectReferences.\nThe first element of each tuple in the ProjectReferences entry should be the DLL name, i.e. path-to-output-of-project.dll.\nThis should be the same as the text used in the -r project reference.\nWhen a project reference is used, the analysis will make use of the results of incremental\nanalysis of the referenced F# project from source files, without requiring the compilation of these files to DLLs.\nTo efficiently analyze a set of F# projects which include cross-references, you should populate the ProjectReferences\ncorrectly and then analyze each project in turn.\n\nNOTE: Project references are disabled if the assembly being referred to contains type provider components -\nspecifying the project reference will have no effect beyond forcing the analysis of the project, and the DLL will\nstill be required on disk.\n\nSummary\nAs you have seen, the ParseAndCheckProject lets you access results of project-wide analysis\nsuch as symbol references. To learn more about working with symbols, see Symbols.\nUsing the FSharpChecker component in multi-project, incremental and interactive editing situations may involve\nknowledge of the FSharpChecker operations queue and the FSharpChecker caches.\n","headings":["Compiler Services: Project Analysis","Getting whole-project results","Analyzing multiple projects","Summary"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/syntax-visitor.html","title":"Tutorial: SyntaxVisitorBase","content":"\nCompiler Services: Using the SyntaxVisitorBase\nSyntax tree traversal is a common topic when interacting with the FSharp.Compiler.Service.\nAs established in Tutorial: Expressions, the ParsedInput can be traversed by a set of recursive functions.\nIt can be tedious to always construct these functions from scratch.\nAs an alternative, a SyntaxVisitorBase can be used to traverse the syntax tree.\nConsider, the following code sample:\nlet codeSample = \u0026quot;\u0026quot;\u0026quot;\nmodule Lib\n\nlet myFunction paramOne paramTwo =\n ()\n\u0026quot;\u0026quot;\u0026quot;\n\nImagine we wish to grab the myFunction name from the headPat in the SynBinding.\nLet\u0027s introduce a helper function to construct the AST:\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.Text\nopen FSharp.Compiler.Syntax\n\nlet checker = FSharpChecker.Create()\n\n/// Helper to construct an ParsedInput from a code snippet.\nlet mkTree codeSample =\n let parseFileResults =\n checker.ParseFile(\n \u0026quot;FileName.fs\u0026quot;,\n SourceText.ofString codeSample,\n { FSharpParsingOptions.Default with SourceFiles = [| \u0026quot;FileName.fs\u0026quot; |] }\n )\n |\u0026gt; Async.RunSynchronously\n\n parseFileResults.ParseTree\n\nAnd create a visitor to traverse the tree:\nlet visitor =\n { new SyntaxVisitorBase\u0026lt;string\u0026gt;() with\n override this.VisitPat(path, defaultTraverse, synPat) =\n // First check if the pattern is what we are looking for.\n match synPat with\n | SynPat.LongIdent(longDotId = SynLongIdent(id = [ ident ])) -\u0026gt;\n // Next we can check if the current path of visited nodes, matches our expectations.\n // The path will contain all the ancestors of the current node.\n match path with\n // The parent node of \u0060synPat\u0060 should be a \u0060SynBinding\u0060.\n | SyntaxNode.SynBinding _ :: _ -\u0026gt;\n // We return a \u0060Some\u0060 option to indicate we found what we are looking for.\n Some ident.idText\n // If the parent is something else, we can skip it here.\n | _ -\u0026gt; None\n | _ -\u0026gt; None }\n\nlet result = SyntaxTraversal.Traverse(Position.pos0, mkTree codeSample, visitor) // Some \u0026quot;myFunction\u0026quot;\n\nInstead of traversing manually from ParsedInput to SynModuleOrNamespace to SynModuleDecl.Let to SynBinding to SynPat, we leverage the default navigation that happens in SyntaxTraversal.Traverse.\nA SyntaxVisitorBase will shortcut all other code paths once a single VisitXYZ override has found anything.\nOur code sample of course only had one let binding and thus we didn\u0027t need to specify any further logic whether to differentiate between multiple bindings.\nLet\u0027s consider a second example where we know the user\u0027s cursor inside an IDE is placed after c and we are interested in the body expression of the let binding.\nlet secondCodeSample = \u0026quot;\u0026quot;\u0026quot;\nmodule X\n\nlet a = 0\nlet b = 1\nlet c = 2\n\u0026quot;\u0026quot;\u0026quot;\n\nlet secondVisitor =\n { new SyntaxVisitorBase\u0026lt;SynExpr\u0026gt;() with\n override this.VisitBinding(path, defaultTraverse, binding) =\n match binding with\n | SynBinding(expr = e) -\u0026gt; Some e }\n\nlet cursorPos = Position.mkPos 6 5\n\nlet secondResult =\n SyntaxTraversal.Traverse(cursorPos, mkTree secondCodeSample, secondVisitor) // Some (Const (Int32 2, (6,8--6,9)))\n\nDue to our passed cursor position, we did not need to write any code to exclude the expressions of the other let bindings.\nSyntaxTraversal.Traverse will check whether the current position is inside any syntax node before drilling deeper.\nLastly, some VisitXYZ overrides can contain a defaultTraverse. This helper allows you to continue the default traversal when you currently hit a node that is not of interest.\nConsider 1 \u002B 2 \u002B 3 \u002B 4, this will be reflected in a nested infix application expression.\nIf the cursor is at the end of the entire expression, we can grab the value of 4 using the following visitor:\nlet thirdCodeSample = \u0026quot;let sum = 1 \u002B 2 \u002B 3 \u002B 4\u0026quot;\n\n(*\nAST will look like:\n\nLet\n (false,\n [SynBinding\n (None, Normal, false, false, [],\n PreXmlDoc ((1,0), Fantomas.FCS.Xml.XmlDocCollector),\n SynValData\n (None, SynValInfo ([], SynArgInfo ([], false, None)), None,\n None),\n Named (SynIdent (sum, None), false, None, (1,4--1,7)), None,\n App\n (NonAtomic, false,\n App\n (NonAtomic, true,\n LongIdent\n (false,\n SynLongIdent\n ([op_Addition], [], [Some (OriginalNotation \u0026quot;\u002B\u0026quot;)]),\n None, (1,20--1,21)),\n App\n (NonAtomic, false,\n App\n (NonAtomic, true,\n LongIdent\n (false,\n SynLongIdent\n ([op_Addition], [],\n [Some (OriginalNotation \u0026quot;\u002B\u0026quot;)]), None,\n (1,16--1,17)),\n App\n (NonAtomic, false,\n App\n (NonAtomic, true,\n LongIdent\n (false,\n SynLongIdent\n ([op_Addition], [],\n [Some (OriginalNotation \u0026quot;\u002B\u0026quot;)]), None,\n (1,12--1,13)),\n Const (Int32 1, (1,10--1,11)), (1,10--1,13)),\n Const (Int32 2, (1,14--1,15)), (1,10--1,15)),\n (1,10--1,17)), Const (Int32 3, (1,18--1,19)),\n (1,10--1,19)), (1,10--1,21)),\n Const (Int32 4, (1,22--1,23)), (1,10--1,23)), (1,4--1,7),\n Yes (1,0--1,23), { LeadingKeyword = Let (1,0--1,3)\n InlineKeyword = None\n EqualsRange = Some (1,8--1,9) })\n*)\n\nlet thirdCursorPos = Position.mkPos 1 22\n\nlet thirdVisitor =\n { new SyntaxVisitorBase\u0026lt;int\u0026gt;() with\n override this.VisitExpr(path, traverseSynExpr, defaultTraverse, synExpr) =\n match synExpr with\n | SynExpr.Const (constant = SynConst.Int32 v) -\u0026gt; Some v\n // We do want to continue to traverse when nodes like \u0060SynExpr.App\u0060 are found.\n | otherExpr -\u0026gt; defaultTraverse otherExpr }\n\nlet thirdResult =\n SyntaxTraversal.Traverse(cursorPos, mkTree thirdCodeSample, thirdVisitor) // Some 4\n\ndefaultTraverse is especially useful when you do not know upfront what syntax tree you will be walking.\nThis is a common case when dealing with IDE tooling. You won\u0027t know what actual code the end-user is currently processing.\nNote: SyntaxVisitorBase is designed to find a single value inside a tree!\nThis is not an ideal solution when you are interested in all nodes of certain shape.\nIt will always verify if the given cursor position is still matching the range of the node.\nAs a fallback the first branch will be explored when you pass Position.pos0.\nBy design, it is meant to find a single result.\n","headings":["Compiler Services: Using the SyntaxVisitorBase"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/typedtree.html","title":"Tutorial: Expressions","content":"\nCompiler Services: Processing typed expression tree\nThis tutorial demonstrates how to get the checked, typed expressions tree (TAST)\nfor F# code and how to walk over the tree.\nThis can be used for creating tools such as source code analyzers and refactoring tools.\nYou can also combine the information with the API available\nfrom symbols.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published\n\nGetting checked expressions\nTo access the type-checked, resolved expressions, you need to create an instance of InteractiveChecker.\nTo use the interactive checker, reference FSharp.Compiler.Service.dll and open the\nrelevant namespaces:\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\nopen System\nopen System.IO\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.EditorServices\nopen FSharp.Compiler.Symbols\nopen FSharp.Compiler.Text\n\nChecking code\nWe first parse and check some code as in the symbols tutorial.\nOne difference is that we set keepAssemblyContents to true.\n// Create an interactive checker instance \nlet checker = FSharpChecker.Create(keepAssemblyContents=true)\n\nlet parseAndCheckSingleFile (input) = \n let file = Path.ChangeExtension(System.IO.Path.GetTempFileName(), \u0026quot;fsx\u0026quot;) \n File.WriteAllText(file, input)\n // Get context representing a stand-alone (script) file\n let projOptions, _errors = \n checker.GetProjectOptionsFromScript(file, SourceText.ofString input, assumeDotNetFramework=false)\n |\u0026gt; Async.RunSynchronously\n\n checker.ParseAndCheckProject(projOptions) \n |\u0026gt; Async.RunSynchronously\n\nGetting the expressions\nAfter type checking a file, you can access the declarations and contents of the assembly, including expressions:\nlet input2 = \n \u0026quot;\u0026quot;\u0026quot;\nmodule MyLibrary \n\nopen System\n\nlet foo(x, y) = \n let msg = String.Concat(\u0026quot;Hello\u0026quot;, \u0026quot; \u0026quot;, \u0026quot;world\u0026quot;)\n if msg.Length \u0026gt; 10 then \n 10 \n else \n 20\n\ntype MyClass() = \n member x.MyMethod() = 1\n \u0026quot;\u0026quot;\u0026quot;\nlet checkProjectResults = \n parseAndCheckSingleFile(input2)\n\ncheckProjectResults.Diagnostics // should be empty\n\nChecked assemblies are made up of a series of checked implementation files. The \u0022file\u0022 granularity\nmatters in F# because initialization actions are triggered at the granularity of files.\nIn this case there is only one implementation file in the project:\nlet checkedFile = checkProjectResults.AssemblyContents.ImplementationFiles.[0]\n\nChecked assemblies are made up of a series of checked implementation files. The \u0022file\u0022 granularity\nmatters in F# because initialization actions are triggered at the granularity of files.\nIn this case there is only one implementation file in the project:\nlet rec printDecl prefix d = \n match d with \n | FSharpImplementationFileDeclaration.Entity (e, subDecls) -\u0026gt; \n printfn \u0026quot;%sEntity %s was declared and contains %d sub-declarations\u0026quot; prefix e.CompiledName subDecls.Length\n for subDecl in subDecls do \n printDecl (prefix\u002B\u0026quot; \u0026quot;) subDecl\n | FSharpImplementationFileDeclaration.MemberOrFunctionOrValue(v, vs, e) -\u0026gt; \n printfn \u0026quot;%sMember or value %s was declared\u0026quot; prefix v.CompiledName\n | FSharpImplementationFileDeclaration.InitAction(e) -\u0026gt; \n printfn \u0026quot;%sA top-level expression was declared\u0026quot; prefix \n\n\nfor d in checkedFile.Declarations do \n printDecl \u0026quot;\u0026quot; d\n\n// Entity MyLibrary was declared and contains 4 sub-declarations\n// Member or value foo was declared\n// Entity MyClass was declared and contains 0 sub-declarations\n// Member or value .ctor was declared\n// Member or value MyMethod was declared\n\nAs can be seen, the only declaration in the implementation file is that of the module MyLibrary, which\ncontains fours sub-declarations.\n\nAs an aside, one peculiarity here is that the member declarations (e.g. the \u0022MyMethod\u0022 member) are returned as part of the containing module entity, not as part of their class.\nNote that the class constructor is returned as a separate declaration. The class type definition has been \u0022split\u0022 into a constructor and the other declarations.\n\nlet myLibraryEntity, myLibraryDecls = \n match checkedFile.Declarations.[0] with \n | FSharpImplementationFileDeclaration.Entity (e, subDecls) -\u0026gt; (e, subDecls)\n | _ -\u0026gt; failwith \u0026quot;unexpected\u0026quot;\n\nWhat about the expressions, for example the body of function \u0022foo\u0022? Let\u0027s find it:\nlet (fooSymbol, fooArgs, fooExpression) = \n match myLibraryDecls.[0] with \n | FSharpImplementationFileDeclaration.MemberOrFunctionOrValue(v, vs, e) -\u0026gt; (v, vs, e)\n | _ -\u0026gt; failwith \u0026quot;unexpected\u0026quot;\n\nHere \u0027fooSymbol\u0027 is a symbol associated with the declaration of \u0027foo\u0027,\n\u0027fooArgs\u0027 represents the formal arguments to the \u0027foo\u0027 function, and \u0027fooExpression\u0027\nis an expression for the implementation of the \u0027foo\u0027 function.\nOnce you have an expression, you can work with it much like an F# quotation. For example,\nyou can find its declaration range and its type:\nfooExpression.Type // shows that the return type of the body expression is \u0026#39;int\u0026#39;\nfooExpression.Range // shows the declaration range of the expression implementing \u0026#39;foo\u0026#39;\n\nWalking over expressions\nExpressions are analyzed using active patterns, much like F# quotations.\nHere is a generic expression visitor:\nlet rec visitExpr f (e:FSharpExpr) = \n f e\n match e with \n | FSharpExprPatterns.AddressOf(lvalueExpr) -\u0026gt; \n visitExpr f lvalueExpr\n | FSharpExprPatterns.AddressSet(lvalueExpr, rvalueExpr) -\u0026gt; \n visitExpr f lvalueExpr; visitExpr f rvalueExpr\n | FSharpExprPatterns.Application(funcExpr, typeArgs, argExprs) -\u0026gt; \n visitExpr f funcExpr; visitExprs f argExprs\n | FSharpExprPatterns.Call(objExprOpt, memberOrFunc, typeArgs1, typeArgs2, argExprs) -\u0026gt; \n visitObjArg f objExprOpt; visitExprs f argExprs\n | FSharpExprPatterns.Coerce(targetType, inpExpr) -\u0026gt; \n visitExpr f inpExpr\n | FSharpExprPatterns.FastIntegerForLoop(startExpr, limitExpr, consumeExpr, isUp, _, _) -\u0026gt; \n visitExpr f startExpr; visitExpr f limitExpr; visitExpr f consumeExpr\n | FSharpExprPatterns.ILAsm(asmCode, typeArgs, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.ILFieldGet (objExprOpt, fieldType, fieldName) -\u0026gt; \n visitObjArg f objExprOpt\n | FSharpExprPatterns.ILFieldSet (objExprOpt, fieldType, fieldName, valueExpr) -\u0026gt; \n visitObjArg f objExprOpt\n | FSharpExprPatterns.IfThenElse (guardExpr, thenExpr, elseExpr) -\u0026gt; \n visitExpr f guardExpr; visitExpr f thenExpr; visitExpr f elseExpr\n | FSharpExprPatterns.Lambda(lambdaVar, bodyExpr) -\u0026gt; \n visitExpr f bodyExpr\n | FSharpExprPatterns.Let((bindingVar, bindingExpr, dbg), bodyExpr) -\u0026gt; \n visitExpr f bindingExpr; visitExpr f bodyExpr\n | FSharpExprPatterns.LetRec(recursiveBindings, bodyExpr) -\u0026gt;\n for _,bindingExpr,_ in recursiveBindings do visitExpr f bindingExpr\n visitExpr f bodyExpr\n | FSharpExprPatterns.NewArray(arrayType, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.NewDelegate(delegateType, delegateBodyExpr) -\u0026gt; \n visitExpr f delegateBodyExpr\n | FSharpExprPatterns.NewObject(objType, typeArgs, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.NewRecord(recordType, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.NewAnonRecord(recordType, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.NewTuple(tupleType, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.NewUnionCase(unionType, unionCase, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.Quote(quotedExpr) -\u0026gt; \n visitExpr f quotedExpr\n | FSharpExprPatterns.FSharpFieldGet(objExprOpt, recordOrClassType, fieldInfo) -\u0026gt; \n visitObjArg f objExprOpt\n | FSharpExprPatterns.AnonRecordGet(objExpr, recordOrClassType, fieldInfo) -\u0026gt; \n visitExpr f objExpr\n | FSharpExprPatterns.FSharpFieldSet(objExprOpt, recordOrClassType, fieldInfo, argExpr) -\u0026gt; \n visitObjArg f objExprOpt; visitExpr f argExpr\n | FSharpExprPatterns.Sequential(firstExpr, secondExpr) -\u0026gt; \n visitExpr f firstExpr; visitExpr f secondExpr\n | FSharpExprPatterns.TryFinally(bodyExpr, finalizeExpr, dbgTry, dbgFinally) -\u0026gt; \n visitExpr f bodyExpr; visitExpr f finalizeExpr\n | FSharpExprPatterns.TryWith(bodyExpr, _, _, catchVar, catchExpr, dbgTry, dbgWith) -\u0026gt; \n visitExpr f bodyExpr; visitExpr f catchExpr\n | FSharpExprPatterns.TupleGet(tupleType, tupleElemIndex, tupleExpr) -\u0026gt; \n visitExpr f tupleExpr\n | FSharpExprPatterns.DecisionTree(decisionExpr, decisionTargets) -\u0026gt; \n visitExpr f decisionExpr; List.iter (snd \u0026gt;\u0026gt; visitExpr f) decisionTargets\n | FSharpExprPatterns.DecisionTreeSuccess (decisionTargetIdx, decisionTargetExprs) -\u0026gt; \n visitExprs f decisionTargetExprs\n | FSharpExprPatterns.TypeLambda(genericParam, bodyExpr) -\u0026gt; \n visitExpr f bodyExpr\n | FSharpExprPatterns.TypeTest(ty, inpExpr) -\u0026gt; \n visitExpr f inpExpr\n | FSharpExprPatterns.UnionCaseSet(unionExpr, unionType, unionCase, unionCaseField, valueExpr) -\u0026gt; \n visitExpr f unionExpr; visitExpr f valueExpr\n | FSharpExprPatterns.UnionCaseGet(unionExpr, unionType, unionCase, unionCaseField) -\u0026gt; \n visitExpr f unionExpr\n | FSharpExprPatterns.UnionCaseTest(unionExpr, unionType, unionCase) -\u0026gt; \n visitExpr f unionExpr\n | FSharpExprPatterns.UnionCaseTag(unionExpr, unionType) -\u0026gt; \n visitExpr f unionExpr\n | FSharpExprPatterns.ObjectExpr(objType, baseCallExpr, overrides, interfaceImplementations) -\u0026gt; \n visitExpr f baseCallExpr\n List.iter (visitObjMember f) overrides\n List.iter (snd \u0026gt;\u0026gt; List.iter (visitObjMember f)) interfaceImplementations\n | FSharpExprPatterns.TraitCall(sourceTypes, traitName, typeArgs, typeInstantiation, argTypes, argExprs) -\u0026gt; \n visitExprs f argExprs\n | FSharpExprPatterns.ValueSet(valToSet, valueExpr) -\u0026gt; \n visitExpr f valueExpr\n | FSharpExprPatterns.WhileLoop(guardExpr, bodyExpr, dbg) -\u0026gt; \n visitExpr f guardExpr; visitExpr f bodyExpr\n | FSharpExprPatterns.BaseValue baseType -\u0026gt; ()\n | FSharpExprPatterns.DefaultValue defaultType -\u0026gt; ()\n | FSharpExprPatterns.ThisValue thisType -\u0026gt; ()\n | FSharpExprPatterns.Const(constValueObj, constType) -\u0026gt; ()\n | FSharpExprPatterns.Value(valueToGet) -\u0026gt; ()\n | _ -\u0026gt; failwith (sprintf \u0026quot;unrecognized %\u002BA\u0026quot; e)\n\nand visitExprs f exprs = \n List.iter (visitExpr f) exprs\n\nand visitObjArg f objOpt = \n Option.iter (visitExpr f) objOpt\n\nand visitObjMember f memb = \n visitExpr f memb.Body\n\nLet\u0027s use this expresssion walker:\nfooExpression |\u0026gt; visitExpr (fun e -\u0026gt; printfn \u0026quot;Visiting %A\u0026quot; e)\n\n// Prints:\n//\n// Visiting Let...\n// Visiting Call...\n// Visiting Const (\u0026quot;Hello\u0026quot;, ...)\n// Visiting Const (\u0026quot; \u0026quot;, ...)\n// Visiting Const (\u0026quot;world\u0026quot;, ...)\n// Visiting IfThenElse...\n// Visiting Call...\n// Visiting Call...\n// Visiting Value ...\n// Visiting Const ...\n// Visiting Const ...\n// Visiting Const ...\n\nNote that\n\nThe visitExpr function is recursive (for nested expressions).\nPattern matching is removed from the tree, into a form called \u0027decision trees\u0027.\n\nSummary\nIn this tutorial, we looked at the basics of working with checked declarations and expressions.\nIn practice, it is also useful to combine the information here\nwith some information you can obtain from the symbols\ntutorial.\n","headings":["Compiler Services: Processing typed expression tree","Getting checked expressions","Checking code","Getting the expressions","Walking over expressions","Summary"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/interactive.html","title":"Tutorial: Hosted execution","content":"\nInteractive Service: Embedding F# Interactive\nThis tutorial demonstrates how to embed F# interactive in your application. F# interactive\nis an interactive scripting environment that compiles F# code into highly efficient IL code\nand executes it on the fly. The F# interactive service allows you to embed F# evaluation in\nyour application.\n\nNOTE: There is a number of options for embedding F# Interactive. The easiest one is to use the\nfsi.exe process and communicate with it using standard input and standard output. In this\ntutorial, we look at calling F# Interactive directly through .NET API. However, if you have\nno control over the input, it is a good idea to run F# interactive in a separate process.\nOne reason is that there is no way to handle StackOverflowException and so a poorly written\nscript can terminate the host process. Remember that while calling F# Interactive through .NET API,\n--shadowcopyreferences option will be ignored. For detailed discussion, please take a look at\nthis thread.\nNOTE: If FsiEvaluationSession.Create fails with an error saying that FSharp.Core.dll cannot be found,\nadd the FSharp.Core.sigdata and FSharp.Core.optdata files. More info here.\n\nHowever, the F# interactive service is still useful, because you might want to wrap it in your\nown executable that is then executed (and communicates with the rest of your application), or\nif you only need to execute a limited subset of F# code (e.g. generated by your own DSL).\nStarting the F# interactive\nFirst, we need to reference the libraries that contain the F# interactive service:\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\n\nopen FSharp.Compiler.Interactive.Shell\nopen FSharp.Compiler.Tokenization\n\nTo communicate with F# interactive, we need to create streams that represent input and\noutput. We will use those later to read the output printed as a result of evaluating some\nF# code that prints:\nopen System\nopen System.IO\nopen System.Text\n\n// Initialize output and input streams\nlet sbOut = new StringBuilder()\nlet sbErr = new StringBuilder()\nlet inStream = new StringReader(\u0026quot;\u0026quot;)\nlet outStream = new StringWriter(sbOut)\nlet errStream = new StringWriter(sbErr)\n\n// Build command line arguments \u0026amp; start FSI session\nlet argv = [| \u0026quot;C:\\\\fsi.exe\u0026quot; |]\n\nlet allArgs =\n Array.append argv [| \u0026quot;--noninteractive\u0026quot; |]\n\nlet fsiConfig =\n FsiEvaluationSession.GetDefaultConfiguration()\n\nlet fsiSession =\n FsiEvaluationSession.Create(fsiConfig, allArgs, inStream, outStream, errStream)\n\nEvaluating and executing code\nThe F# interactive service exposes several methods that can be used for evaluation. The first\nis EvalExpression which evaluates an expression and returns its result. The result contains\nthe returned value (as obj) and the statically inferred type of the value:\n/// Evaluate expression \u0026amp; return the result\nlet evalExpression text =\n match fsiSession.EvalExpression(text) with\n | Some value -\u0026gt; printfn \u0026quot;%A\u0026quot; value.ReflectionValue\n | None -\u0026gt; printfn \u0026quot;Got no result!\u0026quot;\n\nThis takes a string as an argument and evaluates (i.e. executes) it as F# code.\nevalExpression \u0026quot;42\u002B1\u0026quot; // prints \u0026#39;43\u0026#39;\n\nThis can be used in a strongly typed way as follows:\n/// Evaluate expression \u0026amp; return the result, strongly typed\nlet evalExpressionTyped\u0026lt;\u0026#39;T\u0026gt; (text) =\n match fsiSession.EvalExpression(text) with\n | Some value -\u0026gt; value.ReflectionValue |\u0026gt; unbox\u0026lt;\u0026#39;T\u0026gt;\n | None -\u0026gt; failwith \u0026quot;Got no result!\u0026quot;\n\nevalExpressionTyped\u0026lt;int\u0026gt; \u0026quot;42\u002B1\u0026quot; // gives \u0026#39;43\u0026#39;\n\nThe EvalInteraction method can be used to evaluate side-effectful operations\nsuch as printing, declarations, or other interactions that are not valid F# expressions, but can be entered in\nthe F# Interactive console. Such commands include #time \u0022on\u0022 (and other directives), open System\nall declarations and other top-level statements. The code\ndoes not require ;; at the end. Just enter the code that you want to execute:\nfsiSession.EvalInteraction \u0026quot;printfn \\\u0026quot;bye\\\u0026quot;\u0026quot;\n\nThe EvalScript method allows to evaluate a complete .fsx script.\nFile.WriteAllText(\u0026quot;sample.fsx\u0026quot;, \u0026quot;let twenty = 10 \u002B 10\u0026quot;)\nfsiSession.EvalScript \u0026quot;sample.fsx\u0026quot;\n\nCatching errors\nEvalExpression, EvalInteraction and EvalScript are awkward if the\ncode has type checking warnings or errors, or if evaluation fails with an exception.\nIn these cases you can use EvalExpressionNonThrowing, EvalInteractionNonThrowing\nand EvalScriptNonThrowing. These return a tuple of a result and an array of FSharpDiagnostic values.\nThese represent the errors and warnings. The result part is a Choice\u0026lt;_,_\u0026gt; between an actual\nresult and an exception.\nThe result part of EvalExpression and EvalExpressionNonThrowing is an optional FSharpValue.\nIf that value is not present then it just indicates that the expression didn\u0027t have a tangible\nresult that could be represented as a .NET object. This situation shouldn\u0027t actually\noccur for any normal input expressions, and only for primitives used in libraries.\nFile.WriteAllText(\u0026quot;sample.fsx\u0026quot;, \u0026quot;let twenty = \u0026#39;a\u0026#39; \u002B 10.0\u0026quot;)\n\nlet result, warnings =\n fsiSession.EvalScriptNonThrowing \u0026quot;sample.fsx\u0026quot;\n\n// show the result\nmatch result with\n| Choice1Of2 () -\u0026gt; printfn \u0026quot;checked and executed ok\u0026quot;\n| Choice2Of2 exn -\u0026gt; printfn \u0026quot;execution exception: %s\u0026quot; exn.Message\n\nGives:\nexecution exception: Operation could not be completed due to earlier error\n\n// show the errors and warnings\nfor w in warnings do\n printfn \u0026quot;Warning %s at %d,%d\u0026quot; w.Message w.StartLine w.StartColumn\n\nGives:\nWarning The type \u0026#39;float\u0026#39; does not match the type \u0026#39;char\u0026#39; at 1,19\nWarning The type \u0026#39;float\u0026#39; does not match the type \u0026#39;char\u0026#39; at 1,17\n\nFor expressions:\nlet evalExpressionTyped2\u0026lt;\u0026#39;T\u0026gt; text =\n let res, warnings =\n fsiSession.EvalExpressionNonThrowing(text)\n\n for w in warnings do\n printfn \u0026quot;Warning %s at %d,%d\u0026quot; w.Message w.StartLine w.StartColumn\n\n match res with\n | Choice1Of2 (Some value) -\u0026gt; value.ReflectionValue |\u0026gt; unbox\u0026lt;\u0026#39;T\u0026gt;\n | Choice1Of2 None -\u0026gt; failwith \u0026quot;null or no result\u0026quot;\n | Choice2Of2 (exn: exn) -\u0026gt; failwith (sprintf \u0026quot;exception %s\u0026quot; exn.Message)\n\nevalExpressionTyped2\u0026lt;int\u0026gt; \u0026quot;42\u002B1\u0026quot; // gives \u0026#39;43\u0026#39;\n\nExecuting in parallel\nBy default the code passed to EvalExpression is executed immediately. To execute in parallel, submit a computation that starts a task:\nopen System.Threading.Tasks\n\nlet sampleLongRunningExpr =\n \u0026quot;\u0026quot;\u0026quot;\nasync {\n // The code of what you want to run\n do System.Threading.Thread.Sleep 5000\n return 10\n}\n |\u0026gt; Async.StartAsTask\u0026quot;\u0026quot;\u0026quot;\n\nlet task1 =\n evalExpressionTyped\u0026lt;Task\u0026lt;int\u0026gt;\u0026gt; (sampleLongRunningExpr)\n\nlet task2 =\n evalExpressionTyped\u0026lt;Task\u0026lt;int\u0026gt;\u0026gt; (sampleLongRunningExpr)\n\nBoth computations have now started. You can now fetch the results:\ntask1.Result // gives the result after completion (up to 5 seconds)\ntask2.Result // gives the result after completion (up to 5 seconds)\n\nType checking in the evaluation context\nLet\u0027s assume you have a situation where you would like to typecheck code\nin the context of the F# Interactive scripting session. For example, you first\nevaluate a declaration:\nfsiSession.EvalInteraction \u0026quot;let xxx = 1 \u002B 1\u0026quot;\n\nNow you want to typecheck the partially complete code xxx \u002B xx\nlet parseResults, checkResults, checkProjectResults =\n fsiSession.ParseAndCheckInteraction(\u0026quot;xxx \u002B xx\u0026quot;)\n\nThe parseResults and checkResults have types ParseFileResults and CheckFileResults\nexplained in Editor. You can, for example, look at the type errors in the code:\ncheckResults.Diagnostics.Length // 1\n\nThe code is checked with respect to the logical type context available in the F# interactive session\nbased on the declarations executed so far.\nYou can also request declaration list information, tooltip text and symbol resolution:\n// get a tooltip\ncheckResults.GetToolTip(1, 2, \u0026quot;xxx \u002B xx\u0026quot;, [ \u0026quot;xxx\u0026quot; ], FSharpTokenTag.IDENT)\n\ncheckResults.GetSymbolUseAtLocation(1, 2, \u0026quot;xxx \u002B xx\u0026quot;, [ \u0026quot;xxx\u0026quot; ]) // symbol xxx\n\nThe \u0027fsi\u0027 object\nIf you want your scripting code to be able to access the \u0027fsi\u0027 object, you should pass in an implementation of this object explicitly.\nNormally the one from FSharp.Compiler.Interactive.Settings.dll is used.\nlet fsiConfig2 =\n FsiEvaluationSession.GetDefaultConfiguration(fsiSession)\n\nCollectible code generation\nEvaluating code in using FsiEvaluationSession generates a .NET dynamic assembly and uses other resources.\nYou can make generated code collectible by passing collectible=true. However, code will only\nbe collected if there are no outstanding object references involving types, for example\nFsiValue objects returned by EvalExpression, and you must have disposed the FsiEvaluationSession.\nSee also Restrictions on Collectible Assemblies.\nThe example below shows the creation of 200 evaluation sessions. Note that collectible=true and\nuse session = ... are both used.\nIf collectible code is working correctly,\noverall resource usage will not increase linearly as the evaluation progresses.\nlet collectionTest () =\n\n for i in 1 .. 200 do\n let defaultArgs =\n [| \u0026quot;fsi.exe\u0026quot;\n \u0026quot;--noninteractive\u0026quot;\n \u0026quot;--nologo\u0026quot;\n \u0026quot;--gui-\u0026quot; |]\n\n use inStream = new StringReader(\u0026quot;\u0026quot;)\n use outStream = new StringWriter()\n use errStream = new StringWriter()\n\n let fsiConfig =\n FsiEvaluationSession.GetDefaultConfiguration()\n\n use session =\n FsiEvaluationSession.Create(fsiConfig, defaultArgs, inStream, outStream, errStream, collectible = true)\n\n session.EvalInteraction(sprintf \u0026quot;type D = { v : int }\u0026quot;)\n\n let v =\n session.EvalExpression(sprintf \u0026quot;{ v = 42 * %d }\u0026quot; i)\n\n printfn \u0026quot;iteration %d, result = %A\u0026quot; i v.Value.ReflectionValue\n\n// collectionTest() \u0026lt;-- run the test like this\n\n","headings":["Interactive Service: Embedding F# Interactive","Starting the F# interactive","Evaluating and executing code","Catching errors","Executing in parallel","Type checking in the evaluation context","The \u0027fsi\u0027 object","Collectible code generation"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/caches.html","title":"FSharpChecker caches","content":"\nCompiler Services: Notes on the FSharpChecker caches\nThis is a design note on the FSharpChecker component and its caches. See also the notes on the FSharpChecker operations queue\nEach FSharpChecker object maintains a set of caches. These are\n\n\nscriptClosureCache - an MRU cache of default size projectCacheSize that caches the\ncomputation of GetProjectOptionsFromScript. This computation can be lengthy as it can involve processing the transitive closure\nof all #load directives, which in turn can mean parsing an unbounded number of script files.\n\n\nincrementalBuildersCache - an MRU cache of projects where a handle is being kept to their incremental checking state,\nof default size projectCacheSize (= 3 unless explicitly set as a parameter).\nThe \u0022current background project\u0022 (see the FSharpChecker operations queue)\nwill be one of these projects. When analyzing large collections of projects, this cache usually occupies by far the most memory.\nIncreasing the size of this cache can dramatically decrease incremental computation of project-wide checking, or of checking\nindividual files within a project, but can very greatly increase memory usage.\n\nbraceMatchCache - an MRU cache of size braceMatchCacheSize (default = 5) keeping the results of calls to MatchBraces, keyed by filename, source and project options.\n\nparseFileCache - an MRU cache of size parseFileCacheSize (default = 2) keeping the results of ParseFile,\nkeyed by filename, source and project options.\n\n\ncheckFileInProjectCache - an MRU cache of size incrementalTypeCheckCacheSize (default = 5) keeping the results of\nParseAndCheckFileInProject, CheckFileInProject and/or CheckFileInProjectIfReady. This is keyed by filename, file source\nand project options. The results held in this cache are only returned if they would reflect an accurate parse and check of the\nfile.\n\ngetToolTipTextCache - an aged lookup cache of strong size getToolTipTextSize (default = 5) computing the results of GetToolTipText.\n\nilModuleReaderCache - an aged lookup of weak references to \u0022readers\u0022 for references .NET binaries. Because these\nare all weak references, you can generally ignore this cache, since its entries will be automatically collected.\nStrong references to binary readers will be kept by other FCS data structures, e.g. any project checkers, symbols or project checking results.\nIn more detail, the bytes for referenced .NET binaries are read into memory all at once, eagerly. Files are not left\nopen or memory-mapped when using FSharpChecker (as opposed to FsiEvaluationSession, which loads assemblies using reflection).\nThe purpose of this cache is mainly to ensure that while setting up compilation, the reads of mscorlib, FSharp.Core and so on\namortize cracking the DLLs.\n\n\nframeworkTcImportsCache - an aged lookup of strong size 8 which caches the process of setting up type checking against a set of system\ncomponents (e.g. a particular version of mscorlib, FSharp.Core and other system DLLs). These resources are automatically shared between multiple\nproject checkers which happen to reference the same set of system assemblies.\n\n\nProfiling the memory used by the various caches can be done by looking for the corresponding static roots in memory profiling traces.\nThe sizes of some of these caches can be adjusted by giving parameters to FSharpChecker. Unless otherwise noted,\nthe cache sizes above indicate the \u0022strong\u0022 size of the cache, where memory is held regardless of the memory\npressure on the system. Some of the caches can also hold \u0022weak\u0022 references which can be collected at will by the GC.\n\nNote: Because of these caches, you should generally use one global, shared FSharpChecker for everything in an IDE application.\n\nLow-Memory Condition\nVersion 1.4.0.8 added a \u0022maximum memory\u0022 limit specified by the MaxMemory property on FSharpChecker (in MB). If an FCS project operation\nis performed (see CheckMaxMemoryReached in service.fs) and System.GC.GetTotalMemory(false) reports a figure greater than this, then\nthe strong sizes of all FCS caches are reduced to either 0 or 1. This happens for the remainder of the lifetime of the FSharpChecker object.\nIn practice this will still make tools like the Visual Studio F# Power Tools usable, but some operations like renaming across multiple\nprojects may take substantially longer.\nBy default the maximum memory trigger is disabled, see maxMBDefault in service.fs.\nReducing the FCS strong cache sizes does not guarantee there will be enough memory to continue operations - even holding one project\nstrongly may exceed a process memory budget. It just means FCS may hold less memory strongly.\nIf you do not want the maximum memory limit to apply then set MaxMemory to System.Int32.MaxValue.\nSummary\nIn this design note, you learned that the FSharpChecker component keeps a set of caches in order to support common\nincremental analysis scenarios reasonably efficiently. They correspond roughly to the original caches and sizes\nused by the Visual F# Tools, from which the FSharpChecker component derives.\nIn long running, highly interactive, multi-project scenarios you should carefully\nconsider the cache sizes you are using and the tradeoffs involved between incremental multi-project checking and memory usage.\n","headings":["Compiler Services: Notes on the FSharpChecker caches","Low-Memory Condition","Summary"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/tokenizer.html","title":"Tutorial: Tokenizing","content":"\nCompiler Services: Using the F# tokenizer\nThis tutorial demonstrates how to call the F# language tokenizer. Given F#\nsource code, the tokenizer generates a list of source code lines that contain\ninformation about tokens on each line. For each token, you can get the type\nof the token, exact location as well as color kind of the token (keyword,\nidentifier, number, operator, etc.).\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published\n\nCreating the tokenizer\nTo use the tokenizer, reference FSharp.Compiler.Service.dll and open the\nFSharp.Compiler.Tokenization namespace:\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\nopen FSharp.Compiler.Tokenization\n\nNow you can create an instance of FSharpSourceTokenizer. The class takes two\narguments - the first is the list of defined symbols and the second is the\nfile name of the source code. The defined symbols are required because the\ntokenizer handles #if directives. The file name is required only to specify\nlocations of the source code (and it does not have to exist):\nlet sourceTok = FSharpSourceTokenizer([], Some \u0026quot;C:\\\\test.fsx\u0026quot;, Some \u0026quot;PREVIEW\u0026quot;, None)\n\nUsing the sourceTok object, we can now (repeatedly) tokenize lines of\nF# source code.\nTokenizing F# code\nThe tokenizer operates on individual lines rather than on the entire source\nfile. After getting a token, the tokenizer also returns new state (as int64 value).\nThis can be used to tokenize F# code more efficiently. When source code changes,\nyou do not need to re-tokenize the entire file - only the parts that have changed.\nTokenizing single line\nTo tokenize a single line, we create a FSharpLineTokenizer by calling CreateLineTokenizer\non the FSharpSourceTokenizer object that we created earlier:\nlet tokenizer = sourceTok.CreateLineTokenizer(\u0026quot;let answer=42\u0026quot;)\n\nNow, we can write a simple recursive function that calls ScanToken on the tokenizer\nuntil it returns None (indicating the end of line). When the function succeeds, it\nreturns an FSharpTokenInfo object with all the interesting details:\n/// Tokenize a single line of F# code\nlet rec tokenizeLine (tokenizer:FSharpLineTokenizer) state =\n match tokenizer.ScanToken(state) with\n | Some tok, state -\u0026gt;\n // Print token name\n printf \u0026quot;%s \u0026quot; tok.TokenName\n // Tokenize the rest, in the new state\n tokenizeLine tokenizer state\n | None, state -\u0026gt; state\n\nThe function returns the new state, which is needed if you need to tokenize multiple lines\nand an earlier line ends with a multi-line comment. As an initial state, we can use 0L:\ntokenizeLine tokenizer FSharpTokenizerLexState.Initial\n\nThe result is a sequence of tokens with names LET, WHITESPACE, IDENT, EQUALS and INT32.\nThere is a number of interesting properties on FSharpTokenInfo including:\n\n\nCharClass and ColorClass return information about the token category that\ncan be used for colorizing F# code.\n\nLeftColumn and RightColumn return the location of the token inside the line.\nTokenName is the name of the token (as defined in the F# lexer)\n\nNote that the tokenizer is stateful - if you want to tokenize single line multiple times,\nyou need to call CreateLineTokenizer again.\nTokenizing sample code\nTo run the tokenizer on a longer sample code or an entire file, you need to read the\nsample input as a collection of string values:\nlet lines = \u0026quot;\u0026quot;\u0026quot;\n // Hello world\n let hello() =\n printfn \u0026quot;Hello world!\u0026quot; \u0026quot;\u0026quot;\u0026quot;.Split(\u0026#39;\\r\u0026#39;,\u0026#39;\\n\u0026#39;)\n\nTo tokenize multi-line input, we again need a recursive function that keeps the current\nstate. The following function takes the lines as a list of strings (together with line number\nand the current state). We create a new tokenizer for each line and call tokenizeLine\nusing the state from the end of the previous line:\n/// Print token names for multiple lines of code\nlet rec tokenizeLines state count lines = \n match lines with\n | line::lines -\u0026gt;\n // Create tokenizer \u0026amp; tokenize single line\n printfn \u0026quot;\\nLine %d\u0026quot; count\n let tokenizer = sourceTok.CreateLineTokenizer(line)\n let state = tokenizeLine tokenizer state\n // Tokenize the rest using new state\n tokenizeLines state (count\u002B1) lines\n | [] -\u0026gt; ()\n\nThe function simply calls tokenizeLine (defined earlier) to print the names of all\nthe tokens on each line. We can call it on the previous input with 0L as the initial\nstate and 1 as the number of the first line:\nlines\n|\u0026gt; List.ofSeq\n|\u0026gt; tokenizeLines FSharpTokenizerLexState.Initial 1\n\nIgnoring some unimportant details (like whitespace at the beginning of each line and\nthe first line which is just whitespace), the code generates the following output:\nLine 1\n LINE_COMMENT LINE_COMMENT (...) LINE_COMMENT \nLine 2\n LET WHITESPACE IDENT LPAREN RPAREN WHITESPACE EQUALS \nLine 3\n IDENT WHITESPACE STRING_TEXT (...) STRING_TEXT STRING \n\nIt is worth noting that the tokenizer yields multiple LINE_COMMENT tokens and multiple\nSTRING_TEXT tokens for each single comment or string (roughly, one for each word), so\nif you want to get the entire text of a comment/string, you need to concatenate the\ntokens.\n","headings":["Compiler Services: Using the F# tokenizer","Creating the tokenizer","Tokenizing F# code","Tokenizing single line","Tokenizing sample code"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/react.html","title":"Incrementality","content":"\nSnapshots, incrementality and reacting to changes\nFCS is an incremental execution engine. The aim is to make it Roslyn-like. We\u0027re not quite there.\nThere are two dimensions of incrementality:\n\nThe inputs change, e.g. the source files are edited or a referenced assembly changes, appears or disappears\nThe results of analysis on the inputs (e.g. a parse tree) are further enriched with information (e.g. symbol uses are requested) and this information is held, i.e. not re-computed, perhaps by a returned object.\n\nThe logical results of all \u0022Check\u0022 routines (ParseAndCheckFileInProject, GetBackgroundCheckResultsForFileInProject,\nTryGetRecentTypeCheckResultsForFile, ParseAndCheckProject) depend on results reported by the file system,\nespecially the IFileSystem implementation described in the tutorial on project wide analysis.\nLogically speaking, these results would be different if file system changes occur. For example,\nreferenced DLLs may change on disk, or referenced files may change.\nThere is work-in-progress to make all parsing and checking deliver results based on immutable snapshots of inputs.\n","headings":["Snapshots, incrementality and reacting to changes"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/editor.html","title":"Tutorial: Editor services","content":"\nCompiler Services: Editor services\nThis tutorial demonstrates how to use the editor services provided by the F# compiler.\nThis API is used to provide auto-complete, tool-tips, parameter info help, matching of\nbrackets and other functions in F# editors including Visual Studio, Xamarin Studio and Emacs\n(see fsharpbindings project for more information).\nSimilarly to the tutorial on using untyped AST, we start by\ngetting the InteractiveChecker object.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published\n\nType checking sample source code\nAs in the previous tutorial (using untyped AST), we start by referencing\nFSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance\nof InteractiveChecker:\n// Reference F# compiler API\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\n\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.EditorServices\nopen FSharp.Compiler.Text\nopen FSharp.Compiler.Tokenization\n\n// Create an interactive checker instance\nlet checker = FSharpChecker.Create()\n\nAs previously, we use GetProjectOptionsFromScriptRoot to get a context\nwhere the specified input is the only file passed to the compiler (and it is treated as a\nscript file or stand-alone F# source code).\n// Sample input as a multi-line string\nlet input =\n \u0026quot;\u0026quot;\u0026quot;\n open System\n\n let foo() =\n let msg = String.Concat(\u0026quot;Hello\u0026quot;,\u0026quot; \u0026quot;,\u0026quot;world\u0026quot;)\n if true then\n printfn \u0026quot;%s\u0026quot; msg.\n \u0026quot;\u0026quot;\u0026quot;\n// Split the input \u0026amp; define file name\nlet inputLines = input.Split(\u0026#39;\\n\u0026#39;)\nlet file = \u0026quot;/home/user/Test.fsx\u0026quot;\n\nlet projOptions, _diagnostics =\n checker.GetProjectOptionsFromScript(file, SourceText.ofString input, assumeDotNetFramework=false)\n |\u0026gt; Async.RunSynchronously\n\nlet parsingOptions, _diagnostics2 =\n checker.GetParsingOptionsFromProjectOptions(projOptions)\n\nTo perform type checking, we first need to parse the input using\nParseFile, which gives us access to the untyped AST. However,\nthen we need to call CheckFileInProject to perform the full type checking. This function\nalso requires the result of ParseFileInProject, so the two functions are often called\ntogether.\n// Perform parsing\n\nlet parseFileResults =\n checker.ParseFile(file, SourceText.ofString input, parsingOptions)\n |\u0026gt; Async.RunSynchronously\n\nBefore we look at the interesting operations provided by TypeCheckResults, we\nneed to run the type checker on a sample input. On F# code with errors, you would get some type checking\nresult (but it may contain incorrectly \u0022guessed\u0022 results).\n// Perform type checking\nlet checkFileAnswer =\n checker.CheckFileInProject(parseFileResults, file, 0, SourceText.ofString input, projOptions)\n |\u0026gt; Async.RunSynchronously\n\nAlternatively you can use ParseAndCheckFileInProject to check both in one step:\nlet parseResults2, checkFileAnswer2 =\n checker.ParseAndCheckFileInProject(file, 0, SourceText.ofString input, projOptions)\n |\u0026gt; Async.RunSynchronously\n\nThe function returns both the untyped parse result (which we do not use in this\ntutorial), but also a CheckFileAnswer value, which gives us access to all\nthe interesting functionality...\nlet checkFileResults =\n match checkFileAnswer with\n | FSharpCheckFileAnswer.Succeeded (res) -\u0026gt; res\n | res -\u0026gt; failwithf \u0026quot;Parsing did not finish... (%A)\u0026quot; res\n\nHere, we type check a simple function that (conditionally) prints \u0022Hello world\u0022.\nOn the last line, we leave an additional dot in msg. so that we can get the\ncompletion list on the msg value (we expect to see various methods on the string\ntype there).\nUsing type checking results\nLet\u0027s now look at some of the API that is exposed by the TypeCheckResults type. In general,\nthis is the type that lets you implement most of the interesting F# source code editor services.\nGetting a tool tip\nTo get a tool tip, you can use the GetToolTip method. The method takes a line number and character\noffset. Both of the numbers are zero-based. In the sample code, we want to get a tooltip for the foo\nfunction that is defined on line 3 (line 0 is blank) and the letter f starts at index 7 (the tooltip\nwould work anywhere inside the identifier).\nIn addition, the method takes a tag of token which is typically IDENT, when getting a tooltip for an\nidentifier (the other option lets you get a tooltip with full assembly location when using #r \u0022...\u0022).\n// Get tag of the IDENT token to be used as the last argument\nlet identToken = FSharpTokenTag.Identifier\n\n// Get tool tip at the specified location\nlet tip =\n checkFileResults.GetToolTip(4, 7, inputLines.[1], [ \u0026quot;foo\u0026quot; ], identToken)\n\nprintfn \u0026quot;%A\u0026quot; tip\n\nAside from the location and token kind, the function also requires the current contents of the line\n(useful when the source code changes) and a Names value, which is a list of strings representing\nthe current long name. For example, to get a tooltip for the Random identifier in a long name\nSystem.Random, you would use a location somewhere in the string Random and you would pass\n[\u0022System\u0022; \u0022Random\u0022] as the Names value.\nThe returned value is of type ToolTipText which contains a discriminated union ToolTipElement.\nThe union represents different kinds of tool tips that you can get from the compiler.\nGetting auto-complete lists\nThe next method exposed by TypeCheckResults lets us perform auto-complete on a given location.\nThis can be called on any identifier or in any scope (in which case you get a list of names visible\nin the scope) or immediately after . to get a list of members of some object. Here, we get a\nlist of members of the string value msg.\nTo do this, we call GetDeclarationListInfo with the location of the . symbol on the last line\n(ending with printfn \u0022%s\u0022 msg.). The offsets are one-based, so the location is 7, 23.\nWe also need to specify a function that says that the text has not changed and the current identifier\nwhere we need to perform the completion.\n// Get declarations (autocomplete) for a location\nlet decls =\n checkFileResults.GetDeclarationListInfo(\n Some parseFileResults,\n 7,\n inputLines.[6],\n PartialLongName.Empty 23,\n (fun () -\u0026gt; [])\n )\n\n// Print the names of available items\nfor item in decls.Items do\n printfn \u0026quot; - %s\u0026quot; item.NameInList\n\n\nNOTE: v is an alternative name for the old GetDeclarations. The old GetDeclarations was\ndeprecated because it accepted zero-based line numbers. At some point it will be removed, and GetDeclarationListInfo will be renamed back to GetDeclarations.\n\nWhen you run the code, you should get a list containing the usual string methods such as\nSubstring, ToUpper, ToLower etc. The fourth argument of GetDeclarations, here ([], \u0022msg\u0022),\nspecifies the context for the auto-completion. Here, we want a completion on a complete name\nmsg, but you could for example use ([\u0022System\u0022; \u0022Collections\u0022], \u0022Generic\u0022) to get a completion list\nfor a fully qualified namespace.\nGetting parameter information\nThe next common feature of editors is to provide information about overloads of a method. In our\nsample code, we use String.Concat which has a number of overloads. We can get the list using\nGetMethods operation. As previously, this takes the zero-indexed offset of the location that we are\ninterested in (here, right at the end of the String.Concat identifier) and we also need to provide\nthe identifier again (so that the compiler can provide up-to-date information when the source code\nchanges):\n// Get overloads of the String.Concat method\nlet methods =\n checkFileResults.GetMethods(5, 27, inputLines.[4], Some [ \u0026quot;String\u0026quot;; \u0026quot;Concat\u0026quot; ])\n\n// Print concatenated parameter lists\nfor mi in methods.Methods do\n [ for p in mi.Parameters do\n for tt in p.Display do\n yield tt.Text ]\n |\u0026gt; String.concat \u0026quot;, \u0026quot;\n |\u0026gt; printfn \u0026quot;%s(%s)\u0026quot; methods.MethodName\n\nThe code uses the Display property to get the annotation for each parameter. This returns information\nsuch as arg0: obj or params args: obj[] or str0: string, str1: string. We concatenate the parameters\nand print a type annotation with the method name.\nAsynchronous and immediate operations\nYou may have noticed that CheckFileInProject is an asynchronous operation.\nThis indicates that type checking of F# code can take some time.\nThe F# compiler performs the work in the background (automatically) and when\nwe call the CheckFileInProject method, it returns an asynchronous operation.\nThere is also the CheckFileInProjectIfReady method. This returns immediately if the\ntype checking operation can\u0027t be started immediately, e.g. if other files in the project\nare not yet type-checked. In this case, a background worker might choose to do other\nwork in the meantime, or give up on type checking the file until the FileTypeCheckStateIsDirty event\nis raised.\n\nThe fsharpbinding project has a more advanced\nexample of handling the background work where all requests are sent through an F# agent.\nThis may be more appropriate for implementing editor support.\n\nSummary\nThe CheckFileAnswer object contains other useful methods that were not covered in this tutorial. You\ncan use it to get location of a declaration for a given identifier, additional colorization information\n(the F# 3.1 colorizes computation builder identifiers \u0026amp; query operators) and others.\nUsing the FSharpChecker component in multi-project, incremental and interactive editing situations may involve\nknowledge of the FSharpChecker operations queue and the FSharpChecker caches.\nFinally, if you are implementing an editor support for an editor that cannot directly call the .NET API,\nyou can call many of the methods discussed here via a command line interface that is available in the\nFSharp.AutoComplete project.\n","headings":["Compiler Services: Editor services","Type checking sample source code","Using type checking results","Getting a tool tip","Getting auto-complete lists","Getting parameter information","Asynchronous and immediate operations","Summary"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/corelib.html","title":"Notes on FSharp.Core","content":"\nCompiler Services: Notes on FSharp.Core.dll\nVersions of FSharp.Core involved in the operation of FSharp.Compiler.Service\nThere are three versions of FSharp.Core relevant to the operation of FSharp.Compiler.Service:\n\n\nThe FSharp.Compiler.Service.dll static reference to FSharp.Core - The FCS DLL and nuget have a static minbound dependency on FSharp.Core.\nThis is just a normal .NET dependency like any other, it expresses the minimum surface area of FSharp.Core that the implementation of FSharp.Compiler.Service (and any components that depend on it) needs. It could be a reference to a reference assembly if we supported that. In theory this could be very low and all is cool - if we could implement FCS in terms of FSharp.Core 2.0.0.0 then that could be the minbound (indeed in theory we could implement FCS pretty almost without any use of FSharp.Core functionality at all, though obviously we don\u0027t).\nIn practice this is 0-2 versions behind latest FSharp.Core.\n\n\nThe runtime reference to FSharp.Core in a tool, application or test suite that includes FSharp.Compiler.Service - This is the actual version of FSharp.Core used when, say, fsc.exe or devenv.exe or fsi.exe or fsdocs.exe runs.\nThis must be at least as high as (1) and is usually the very latest FSharp.Core available (in or out of repo tree). This is important to the operation of the FCS-based tool because it is used for execution of scripts, and the default compilation reference for scripts. If scripts are going to use a particular language feature then this must be sufficient to support the language feature.\n\n\nThe FSharp.Core reference in a compilation or analysis being processed by FSharp.Compiler.Service.\nThis can be anything - 2.0.0.0, 4.0.0.0 or 5.0.0 or whatever. For script compilation and execution is the same as (2). It must be sufficient to support language features used in the compilation.\n\n\nShipping an FSharp.Core with your application\nWhen building applications or plug-in components which use FSharp.Compiler.Service.dll, you will normally also\ninclude a copy of FSharp.Core.dll as part of your application.\nFor example, if you build a HostedCompiler.exe, you will normally place an FSharp.Core.dll (say 4.3.1.0) alongside\nyour HostedCompiler.exe.\nWhich FSharp.Core and .NET SDK get referenced in compilation?\nThe FSharp.Compiler.Service component can be used to do more or less any sort of F# compilation.\nIn particular you can reference an explicit FSharp.Core and/or framework\nassemblies in the command line arguments (different to the FSharp.Core and a .NET Framework being used to run your tool).\nWhat about if I am using FsiEvaluationSession or GetProjectOptionsFromScript\nIf you do not explicitly reference an FSharp.Core.dll from an SDK location, or if you are processing a script\nusing FsiEvaluationSession or GetProjectOptionsFromScript, then an implicit reference to FSharp.Core will be made\nby the following choice:\n\nThe version of FSharp.Core.dll for the SDK implied by global.json.\nThe version of FSharp.Core.dll statically referenced by the host assembly returned by System.Reflection.Assembly.GetEntryAssembly().\nIf there is no static reference to FSharp.Core in the host assembly, then a default is chosen.\n\n\nNOTE: these may depend on exact flags passed to GetProjectOptionsFromScript\n\n","headings":["Compiler Services: Notes on FSharp.Core.dll","Versions of FSharp.Core involved in the operation of FSharp.Compiler.Service","Shipping an FSharp.Core with your application","Which FSharp.Core and .NET SDK get referenced in compilation?"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/compiler.html","title":"Tutorial: Hosting the compiler","content":"\nHosted Compiler\nThis tutorial demonstrates how to host the F# compiler.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published\n\n\nNOTE: There are several options for hosting the F# compiler. The easiest one is to use the\nfsc.exe process and pass arguments.\n\n\nNOTE: By default compilations using FSharp.Compiler.Service reference FSharp.Core 4.3.0.0 (matching F# 3.0). You can override\nthis choice by passing a reference to FSharp.Core for 4.3.1.0 or later explicitly in your command-line arguments.\n\n\nFirst, we need to reference the libraries that contain F# interactive service:\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\nopen System.IO\nopen FSharp.Compiler.CodeAnalysis\n\n// Create an interactive checker instance \nlet checker = FSharpChecker.Create()\n\nNow write content to a temporary file:\nlet fn = Path.GetTempFileName()\nlet fn2 = Path.ChangeExtension(fn, \u0026quot;.fsx\u0026quot;)\nlet fn3 = Path.ChangeExtension(fn, \u0026quot;.dll\u0026quot;)\n\nFile.WriteAllText(fn2, \u0026quot;\u0026quot;\u0026quot;\nmodule M\n\ntype C() = \n member x.P = 1\n\nlet x = 3 \u002B 4\n\u0026quot;\u0026quot;\u0026quot;)\n\nNow invoke the compiler:\nlet errors1, exitCode1 = \n checker.Compile([| \u0026quot;fsc.exe\u0026quot;; \u0026quot;-o\u0026quot;; fn3; \u0026quot;-a\u0026quot;; fn2 |]) \n |\u0026gt; Async.RunSynchronously\n\nIf errors occur you can see this in the \u0027exitCode\u0027 and the returned array of errors:\nFile.WriteAllText(fn2, \u0026quot;\u0026quot;\u0026quot;\nmodule M\n\nlet x = 1.0 \u002B \u0026quot;\u0026quot; // a type error\n\u0026quot;\u0026quot;\u0026quot;)\n\nlet errors1b, exitCode1b = \n checker.Compile([| \u0026quot;fsc.exe\u0026quot;; \u0026quot;-o\u0026quot;; fn3; \u0026quot;-a\u0026quot;; fn2 |])\n |\u0026gt; Async.RunSynchronously\n\n","headings":["Hosted Compiler"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/filesystem.html","title":"IFileSystem","content":"\nCompiler Services: Virtualized File System\nThe FSharp.Compiler.Service component has a global variable\nrepresenting the file system. By setting this variable you can host the compiler in situations where a file system\nis not available.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.\n\nSetting the FileSystem\nIn the example below, we set the file system to an implementation which reads from disk\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\n\nopen System.IO\nopen System.Text\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.IO\n\nlet defaultFileSystem = FileSystem\n\nlet fileName1 = @\u0026quot;c:\\mycode\\test1.fs\u0026quot; // note, the path doesn\u0026#39;t exist\nlet fileName2 = @\u0026quot;c:\\mycode\\test2.fs\u0026quot; // note, the path doesn\u0026#39;t exist\n\ntype MyFileSystem() =\n let file1 =\n \u0026quot;\u0026quot;\u0026quot;\nmodule File1\n\nlet A = 1\u0026quot;\u0026quot;\u0026quot;\n\n let file2 =\n \u0026quot;\u0026quot;\u0026quot;\nmodule File2\nlet B = File1.A \u002B File1.A\u0026quot;\u0026quot;\u0026quot;\n\n let files =\n dict [ (fileName1, file1)\n (fileName2, file2) ]\n\n interface IFileSystem with\n // Implement the service to open files for reading and writing\n member _.OpenFileForReadShim(fileName, ?useMemoryMappedFile: bool, ?shouldShadowCopy: bool) =\n match files.TryGetValue fileName with\n | true, text -\u0026gt; new MemoryStream(Encoding.UTF8.GetBytes(text)) :\u0026gt; Stream\n | _ -\u0026gt;\n defaultFileSystem.OpenFileForReadShim(\n fileName,\n ?useMemoryMappedFile = useMemoryMappedFile,\n ?shouldShadowCopy = shouldShadowCopy\n )\n\n member _.OpenFileForWriteShim(fileName, ?fileMode: FileMode, ?fileAccess: FileAccess, ?fileShare: FileShare) =\n defaultFileSystem.OpenFileForWriteShim(\n fileName,\n ?fileMode = fileMode,\n ?fileAccess = fileAccess,\n ?fileShare = fileShare\n )\n\n // Implement the service related to file existence and deletion\n member _.FileExistsShim(fileName) =\n files.ContainsKey(fileName)\n || defaultFileSystem.FileExistsShim(fileName)\n\n // Implement the service related to temporary paths and file time stamps\n member _.GetTempPathShim() = defaultFileSystem.GetTempPathShim()\n\n member _.GetLastWriteTimeShim(fileName) =\n defaultFileSystem.GetLastWriteTimeShim(fileName)\n\n member _.GetFullPathShim(fileName) =\n defaultFileSystem.GetFullPathShim(fileName)\n\n member _.IsInvalidPathShim(fileName) =\n defaultFileSystem.IsInvalidPathShim(fileName)\n\n member _.IsPathRootedShim(fileName) =\n defaultFileSystem.IsPathRootedShim(fileName)\n\n member _.FileDeleteShim(fileName) =\n defaultFileSystem.FileDeleteShim(fileName)\n\n member _.AssemblyLoader = defaultFileSystem.AssemblyLoader\n\n member _.GetFullFilePathInDirectoryShim dir fileName =\n defaultFileSystem.GetFullFilePathInDirectoryShim dir fileName\n\n member _.NormalizePathShim(path) =\n defaultFileSystem.NormalizePathShim(path)\n\n member _.GetDirectoryNameShim(path) =\n defaultFileSystem.GetDirectoryNameShim(path)\n\n member _.GetCreationTimeShim(path) =\n defaultFileSystem.GetCreationTimeShim(path)\n\n member _.CopyShim(src, dest, overwrite) =\n defaultFileSystem.CopyShim(src, dest, overwrite)\n\n member _.DirectoryCreateShim(path) =\n defaultFileSystem.DirectoryCreateShim(path)\n\n member _.DirectoryExistsShim(path) =\n defaultFileSystem.DirectoryExistsShim(path)\n\n member _.DirectoryDeleteShim(path) =\n defaultFileSystem.DirectoryDeleteShim(path)\n\n member _.EnumerateFilesShim(path, pattern) =\n defaultFileSystem.EnumerateFilesShim(path, pattern)\n\n member _.EnumerateDirectoriesShim(path) =\n defaultFileSystem.EnumerateDirectoriesShim(path)\n\n member _.IsStableFileHeuristic(path) =\n defaultFileSystem.IsStableFileHeuristic(path)\n\n member this.ChangeExtensionShim(path, extension) =\n defaultFileSystem.ChangeExtensionShim(path, extension)\n\nlet myFileSystem = MyFileSystem()\nFileSystem \u0026lt;- MyFileSystem()\n\nDoing a compilation with the FileSystem\nlet checker = FSharpChecker.Create()\n\nlet projectOptions =\n let sysLib nm =\n if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then // file references only valid on Windows\n System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)\n \u002B @\u0026quot;\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.0\\\u0026quot;\n \u002B nm\n \u002B \u0026quot;.dll\u0026quot;\n else\n let sysDir =\n System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()\n\n let (\u002B\u002B) a b = System.IO.Path.Combine(a, b)\n sysDir \u002B\u002B nm \u002B \u0026quot;.dll\u0026quot;\n\n let fsCore4300 () =\n if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then // file references only valid on Windows\n System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)\n \u002B @\u0026quot;\\Reference Assemblies\\Microsoft\\FSharp\\.NETFramework\\v4.0\\4.3.0.0\\FSharp.Core.dll\u0026quot;\n else\n sysLib \u0026quot;FSharp.Core\u0026quot;\n\n let allFlags =\n [| \u0026quot;--simpleresolution\u0026quot;\n \u0026quot;--noframework\u0026quot;\n \u0026quot;--debug:full\u0026quot;\n \u0026quot;--define:DEBUG\u0026quot;\n \u0026quot;--optimize-\u0026quot;\n \u0026quot;--doc:test.xml\u0026quot;\n \u0026quot;--warn:3\u0026quot;\n \u0026quot;--fullpaths\u0026quot;\n \u0026quot;--flaterrors\u0026quot;\n \u0026quot;--target:library\u0026quot;\n let references =\n [ sysLib \u0026quot;mscorlib\u0026quot;\n sysLib \u0026quot;System\u0026quot;\n sysLib \u0026quot;System.Core\u0026quot;\n fsCore4300 () ]\n\n for r in references do\n \u0026quot;-r:\u0026quot; \u002B r |]\n\n { ProjectFileName = @\u0026quot;c:\\mycode\\compilation.fsproj\u0026quot; // Make a name that is unique in this directory.\n ProjectId = None\n SourceFiles = [| fileName1; fileName2 |]\n OriginalLoadReferences = []\n Stamp = None\n OtherOptions = allFlags\n ReferencedProjects = [||]\n IsIncompleteTypeCheckEnvironment = false\n UseScriptResolutionRules = true\n LoadTime = System.DateTime.Now // Note using \u0026#39;Now\u0026#39; forces reloading\n UnresolvedReferences = None }\n\nlet results =\n checker.ParseAndCheckProject(projectOptions)\n |\u0026gt; Async.RunSynchronously\n\nresults.Diagnostics\nresults.AssemblySignature.Entities.Count //2\n\nresults.AssemblySignature.Entities.[0]\n .MembersFunctionsAndValues\n .Count\n\nresults.AssemblySignature.Entities.[0]\n .MembersFunctionsAndValues.[0]\n .DisplayName\n\nSummary\nIn this tutorial, we\u0027ve seen how to globally customize the view of the file system used by the FSharp.Compiler.Service\ncomponent.\nAt the time of writing, the following System.IO operations are not considered part of the virtualized file system API.\nFuture iterations on the compiler service implementation may add these to the API.\n\nPath.Combine\nPath.DirectorySeparatorChar\nPath.GetDirectoryName\nPath.GetFileName\nPath.GetFileNameWithoutExtension\nPath.HasExtension\nPath.GetRandomFileName (used only in generation compiled win32 resources in assemblies)\n\nNOTE: Several operations in the SourceCodeServices API accept the contents of a file to parse\nor check as a parameter, in addition to a file name. In these cases, the file name is only used for\nerror reporting.\nNOTE: Type provider components do not use the virtualized file system.\nNOTE: The compiler service may use MSBuild for assembly resolutions unless --simpleresolution is\nprovided. When using the FileSystem API you will normally want to specify --simpleresolution as one\nof your compiler flags. Also specify --noframework. You will need to supply explicit resolutions of all\nreferenced .NET assemblies.\n","headings":["Compiler Services: Virtualized File System","Setting the FileSystem","Doing a compilation with the FileSystem","Summary"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/index.html","title":"FSharp.Compiler.Service","content":"\nFSharp.Compiler.Service\nThe FSharp.Compiler.Service package is a component derived from the F# compiler source code that\nexposes additional functionality for implementing F# language bindings, additional\ntools based on the compiler or refactoring tools. The package also includes\ndynamic execution of F# code that can be used for embedding F# scripting into your applications.\nAvailable services\nThe project currently exposes the following services that are tested \u0026amp; documented on this page.\nThe libraries contain additional public API that can be used, but is not documented here.\n\n\nF# Language tokenizer - turns any F# source code into a stream of tokens.\nUseful for implementing source code colorization and basic tools. Correctly handle nested\ncomments, strings etc.\n\n\nProcessing SyntaxTree - allows accessing the syntax tree.\nThis represents parsed F# syntax without type information and can be used to implement code formatting\nand various simple processing tasks.\n\n\nWorking with resolved symbols - many services related to type checking\nreturn resolved symbols, representing inferred types, and the signatures of whole assemblies.\n\n\nWorking with resolved expressions - services related to working with\ntype-checked expressions and declarations, where names have been resolved to symbols.\n\n\nUsing editor services - expose functionality for auto-completion, tool-tips,\nparameter information etc. These functions are useful for implementing F# support for editors\nand for getting some type information for F# code.\n\n\nWorking with project-wide analysis - you can request a check of\nan entire project, and ask for the results of whole-project analyses such as find-all-references.\n\n\nHosting F# interactive - allows calling F# interactive as a .NET library\nfrom your .NET code. You can use this API to embed F# as a scripting language in your projects.\n\nHosting the F# compiler - allows you to embed calls to the F# compiler.\n\nFile system API - the FSharp.Compiler.Service component has a global variable\nrepresenting the file system. By setting this variable you can host the compiler in situations where a file system\nis not available.\n\n\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published\n\nThe Public Surface Area\nWe are in the process of cleaning up the surface area of FCS to allow it to be fully binary compatible going forward.\nThe full current surface area can be seen at: https://fsharp.github.io/fsharp-compiler-docs/reference/index.html\nThe API is generally designed with F#/.NET design conventions (e.g. types in namespaces, not modules, no nesting of modules etc.) and we must continue to iterate to make this so.\nThe parts of the compiler under FSharp.Compiler.AbstractIL.* are \u0022incidental\u0022 and not really designed for public use apart from the hook for JetBrains Rider (Aside: In theory all these other parts could be renamed to FSharp.Compiler though there\u0027s no need to do that right now). These internal parts tend to be implemented with the \u0022module containing lots of stuff in one big file\u0022 approach for layers of the compiler.\nBasics - Syntax, Text and Diagnostics\n\nFSharp.Compiler.Diagnostics\nFSharp.Compiler.IO\nFSharp.Compiler.Syntax\nFSharp.Compiler.Text\n\nTokenization\n\nFSharp.Compiler.Tokenization\n\nSymbols and Code Analysis\n\nFSharp.Compiler.Symbols\nFSharp.Compiler.CodeAnalysis\n\nEditor Services\n\nFSharp.Compiler.EditorServices\n\nInteractive Execution\n\nFSharp.Compiler.Interactive.Shell\n\nInternal extension points\n\nFSharp.Compiler.AbstractIL\n\nProjects using the F# Compiler Services\nSome of the projects using the F# Compiler Services are:\n\nF# in Visual Studio\nF# in Visual Studio for Mac\nFsAutoComplete\nF# in JetBrains Rider\nF# in .NET Interactive Notebooks\nFantomas - Source code formatting for F#\nFSharpLint - Lint tool for F#\nFable - F# to JavaScript Compiler and more\nWebSharper - F# full-stack web framework\n\nOlder things:\n\nFsReveal - FsReveal parses markdown and F# script file and generate reveal.js slides\nElucidate - Visual Studio extension for rich inlined comments using MarkDown\nFSharp.Formatting - F# tools for generating documentation (Markdown processor and F# code formatter)\nFAKE - \u0022FAKE - F# Make\u0022 is a cross platform build automation system\n\nContributing and copyright\nThe F# source code is copyright by Microsoft Corporation and contributors.\n","headings":["FSharp.Compiler.Service","Available services","The Public Surface Area","Basics - Syntax, Text and Diagnostics","Tokenization","Symbols and Code Analysis","Editor Services","Interactive Execution","Internal extension points","Projects using the F# Compiler Services","Contributing and copyright"],"type":"content"},{"uri":"https://fsharp.github.io/fsharp-compiler-docs/fcs/symbols.html","title":"Tutorial: Symbols","content":"\nCompiler Services: Working with symbols\nThis tutorial demonstrates how to work with symbols provided by the F# compiler. See also project wide analysis\nfor information on symbol references.\n\nNOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.\n\nAs usual we start by referencing FSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance\nof FSharpChecker:\n// Reference F# compiler API\n#r \u0026quot;FSharp.Compiler.Service.dll\u0026quot;\n\nopen System\nopen System.IO\nopen FSharp.Compiler.CodeAnalysis\nopen FSharp.Compiler.Symbols\nopen FSharp.Compiler.Text\n\n// Create an interactive checker instance \nlet checker = FSharpChecker.Create()\n\nWe now perform type checking on the specified input:\nlet parseAndTypeCheckSingleFile (file, input) = \n // Get context representing a stand-alone (script) file\n let projOptions, errors = \n checker.GetProjectOptionsFromScript(file, input, assumeDotNetFramework=false)\n |\u0026gt; Async.RunSynchronously\n\n let parseFileResults, checkFileResults = \n checker.ParseAndCheckFileInProject(file, 0, input, projOptions) \n |\u0026gt; Async.RunSynchronously\n\n // Wait until type checking succeeds (or 100 attempts)\n match checkFileResults with\n | FSharpCheckFileAnswer.Succeeded(res) -\u0026gt; parseFileResults, res\n | res -\u0026gt; failwithf \u0026quot;Parsing did not finish... (%A)\u0026quot; res\n\nlet file = \u0026quot;/home/user/Test.fsx\u0026quot;\n\nGetting resolved signature information about the file\nAfter type checking a file, you can access the inferred signature of a project up to and including the\nchecking of the given file through the PartialAssemblySignature property of the TypeCheckResults.\nThe full signature information is available for modules, types, attributes, members, values, functions,\nunion cases, record types, units of measure and other F# language constructs.\nThe typed expression trees are also available, see typed tree tutorial.\nlet input2 = \n \u0026quot;\u0026quot;\u0026quot;\n[\u0026lt;System.CLSCompliant(true)\u0026gt;]\nlet foo(x, y) = \n let msg = String.Concat(\u0026quot;Hello\u0026quot;,\u0026quot; \u0026quot;,\u0026quot;world\u0026quot;)\n if true then \n printfn \u0026quot;x = %d, y = %d\u0026quot; x y \n printfn \u0026quot;%s\u0026quot; msg\n\ntype C() = \n member x.P = 1\n \u0026quot;\u0026quot;\u0026quot;\nlet parseFileResults, checkFileResults = \n parseAndTypeCheckSingleFile(file, SourceText.ofString input2)\n\nNow get the partial assembly signature for the code:\nlet partialAssemblySignature = checkFileResults.PartialAssemblySignature\n \npartialAssemblySignature.Entities.Count = 1 // one entity\n \n\nNow get the entity that corresponds to the module containing the code:\nlet moduleEntity = partialAssemblySignature.Entities.[0]\n\nmoduleEntity.DisplayName = \u0026quot;Test\u0026quot;\n\nNow get the entity that corresponds to the type definition in the code:\nlet classEntity = moduleEntity.NestedEntities.[0]\n\nNow get the value that corresponds to the function defined in the code:\nlet fnVal = moduleEntity.MembersFunctionsAndValues.[0]\n\nNow look around at the properties describing the function value:\nfnVal.Attributes.Count // 1\nfnVal.CurriedParameterGroups.Count // 1\nfnVal.CurriedParameterGroups.[0].Count // 2\nfnVal.CurriedParameterGroups.[0].[0].Name // Some \u0026quot;x\u0026quot;\nfnVal.CurriedParameterGroups.[0].[1].Name // Some \u0026quot;y\u0026quot;\nfnVal.DeclarationLocation.StartLine // 3\nfnVal.DisplayName // \u0026quot;foo\u0026quot;\nfnVal.DeclaringEntity.Value.DisplayName // \u0026quot;Test\u0026quot;\nfnVal.DeclaringEntity.Value.DeclarationLocation.StartLine // 1\nfnVal.GenericParameters.Count // 0\nfnVal.InlineAnnotation // FSharpInlineAnnotation.OptionalInline\nfnVal.IsActivePattern // false\nfnVal.IsCompilerGenerated // false\nfnVal.IsDispatchSlot // false\nfnVal.IsExtensionMember // false\nfnVal.IsPropertyGetterMethod // false\nfnVal.IsImplicitConstructor // false\nfnVal.IsInstanceMember // false\nfnVal.IsMember // false\nfnVal.IsModuleValueOrMember // true\nfnVal.IsMutable // false\nfnVal.IsPropertySetterMethod // false\nfnVal.IsTypeFunction // false\n\nNow look at the type of the function if used as a first class value. (Aside: the CurriedParameterGroups property contains\nmore information like the names of the arguments.)\nfnVal.FullType // int * int -\u0026gt; unit\nfnVal.FullType.IsFunctionType // int * int -\u0026gt; unit\nfnVal.FullType.GenericArguments.[0] // int * int \nfnVal.FullType.GenericArguments.[0].IsTupleType // int * int \nlet argTy1 = fnVal.FullType.GenericArguments.[0].GenericArguments.[0]\n\nargTy1.TypeDefinition.DisplayName // int\n\nOK, so we got an object representation of the type int * int -\u0026gt; unit, and we have seen the first \u0027int\u0027. We can find out more about the\ntype \u0027int\u0027 as follows, determining that it is a named type, which is an F# type abbreviation, type int = int32:\nargTy1.HasTypeDefinition\nargTy1.TypeDefinition.IsFSharpAbbreviation // \u0026quot;int\u0026quot;\n\nWe can now look at the right-hand-side of the type abbreviation, which is the type int32:\nlet argTy1b = argTy1.TypeDefinition.AbbreviatedType\nargTy1b.TypeDefinition.Namespace // Some \u0026quot;Microsoft.FSharp.Core\u0026quot; \nargTy1b.TypeDefinition.CompiledName // \u0026quot;int32\u0026quot; \n\nAgain we can now look through the type abbreviation type int32 = System.Int32 to get the\nfull information about the type:\nlet argTy1c = argTy1b.TypeDefinition.AbbreviatedType\nargTy1c.TypeDefinition.Namespace // Some \u0026quot;SystemCore\u0026quot; \nargTy1c.TypeDefinition.CompiledName // \u0026quot;Int32\u0026quot; \n\nThe type checking results for a file also contain information extracted from the project (or script) options\nused in the compilation, called the ProjectContext:\nlet projectContext = checkFileResults.ProjectContext\n \nfor assembly in projectContext.GetReferencedAssemblies() do\n match assembly.FileName with \n | None -\u0026gt; printfn \u0026quot;compilation referenced an assembly without a file\u0026quot; \n | Some s -\u0026gt; printfn \u0026quot;compilation references assembly \u0026#39;%s\u0026#39;\u0026quot; s\n \n\nNotes:\n\nIf incomplete code is present, some or all of the attributes may not be quite as expected.\n\nIf some assembly references are missing (which is actually very, very common), then \u0027IsUnresolved\u0027 may\nbe true on values, members and/or entities related to external assemblies. You should be sure to make your\ncode robust against IsUnresolved exceptions.\n\n\nGetting symbolic information about whole projects\nTo check whole projects, create a checker, then call parseAndCheckScript. In this case, we just check\nthe project for a single script. By specifying a different \u0022projOptions\u0022 you can create\na specification of a larger project.\nlet parseAndCheckScript (file, input) = \n let projOptions, errors = \n checker.GetProjectOptionsFromScript(file, input, assumeDotNetFramework=false)\n |\u0026gt; Async.RunSynchronously\n\n checker.ParseAndCheckProject(projOptions) |\u0026gt; Async.RunSynchronously\n\nNow do it for a particular input:\nlet tmpFile = Path.ChangeExtension(System.IO.Path.GetTempFileName() , \u0026quot;fs\u0026quot;)\nFile.WriteAllText(tmpFile, input2)\n\nlet projectResults = parseAndCheckScript(tmpFile, SourceText.ofString input2)\n\nNow look at the results:\nlet assemblySig = projectResults.AssemblySignature\n \nprintfn $\u0026quot;#entities = {assemblySig.Entities.Count}\u0026quot; // 1\nprintfn $\u0026quot;namespace = {assemblySig.Entities.[0].Namespace}\u0026quot; // one entity\nprintfn $\u0026quot;entity name = {assemblySig.Entities.[0].DisplayName}\u0026quot; // \u0026quot;Tmp28D0\u0026quot;\nprintfn $\u0026quot;#members = {assemblySig.Entities.[0].MembersFunctionsAndValues.Count}\u0026quot; // 1 \nprintfn $\u0026quot;member name = {assemblySig.Entities.[0].MembersFunctionsAndValues.[0].DisplayName}\u0026quot; // \u0026quot;foo\u0026quot; \n \n\n","headings":["Compiler Services: Working with symbols","Getting resolved signature information about the file","Getting symbolic information about whole projects"],"type":"content"}] \ No newline at end of file diff --git a/large-inputs-and-stack-overflows.html b/large-inputs-and-stack-overflows.html new file mode 100644 index 0000000000..139212a135 --- /dev/null +++ b/large-inputs-and-stack-overflows.html @@ -0,0 +1,611 @@ + + + + + + + + + + + + + + + + + + Large inputs | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Processing large inputs without stack overflows

+

The compiler accepts large inputs such as:

+ +

The compiler performs constant folding for large constants so there are no costs to using them at runtime. However, this is subject to a machine's stack size when compiling, leading to StackOverflow exceptions if those constants are very large. The same can be observed for certain kinds of array, list, or sequence expressions. This appears to be more prominent when compiling on macOS because macOS has a smaller stack size.

+

Many sources of StackOverflow exceptions prior to F# 4.7 when processing these kinds of constructs were resolved by processing them on the heap via continuation passing techniques. This avoids filling data on the stack and appears to have negligible effects on overall throughput or memory usage of the compiler.

+

There are two techniques to deal with this

+
    +
  1. Linearizing processing of specific input shapes, keeping stacks small
    2. +
  2. Using stack guards to simply temporarily move to a new thread when a certain threshold is reached.
    3. +
+

Linearizing processing if certain inputs

+

Aside from array expressions, most of the previously-listed inputs are called "linear" expressions. This means that there is a single linear hole in the shape of expressions. For example:

+ +

Processing these constructs with continuation passing is more difficult than a more "natural" approach that would use the stack.

+

For example, consider the following contrived example:

+
and remapLinearExpr g compgen tmenv expr contf =
+    match expr with
+    | Expr.Let (bind, bodyExpr, m, _) ->
+        ...
+        // tailcall for the linear position
+        remapLinearExpr g compgen tmenvinner bodyExpr (contf << (fun bodyExpr' ->
+            ...))
+
+    | Expr.Sequential (expr1, expr2, dir, spSeq, m)  ->
+        ...
+        // tailcall for the linear position
+        remapLinearExpr g compgen tmenv expr2 (contf << (fun expr2' ->
+            ...))
+
+    | LinearMatchExpr (spBind, exprm, dtree, tg1, expr2, sp2, m2, ty) ->
+        ...
+        // tailcall for the linear position
+        remapLinearExpr g compgen tmenv expr2 (contf << (fun expr2' ->  ...))
+
+    | LinearOpExpr (op, tyargs, argsFront, argLast, m) ->
+        ...
+        // tailcall for the linear position
+        remapLinearExpr g compgen tmenv argLast (contf << (fun argLast' -> ...))
+
+    | _ -> contf (remapExpr g compgen tmenv e)
+
+and remapExpr (g: TcGlobals) (compgen:ValCopyFlag) (tmenv:Remap) expr =
+    match expr with
+    ...
+    | LinearOpExpr _
+    | LinearMatchExpr _
+    | Expr.Sequential _
+    | Expr.Let _ -> remapLinearExpr g compgen tmenv expr (fun x -> x)
+
+

The remapExpr operation becomes two functions, remapExpr (for non-linear cases) and remapLinearExpr (for linear cases). remapLinearExpr uses tailcalls for constructs in the HOLE positions mentioned previously, passing the result to the continuation.

+

Some common aspects of this style of programming are:

+ +

The previous example is considered incomplete, because arbitrary combinations of let and sequential expressions aren't going to be dealt with in a tail-recursive way. The compiler generally tries to do these combinations as well.

+

Stack Guards

+

The StackGuard type is used to count synchronous recursive processing and move to a new thread if a limit is reached. Compilation globals are re-installed. Sample:

+
let TcStackGuardDepth = StackGuard.GetDepthOption "Tc"
+
+...
+   stackGuard = StackGuard(TcMaxStackGuardDepth)
+
+let rec ....
+
+and TcExpr cenv ty (env: TcEnv) tpenv (expr: SynExpr) =
+
+    // Guard the stack for deeply nested expressions
+    cenv.stackGuard.Guard <| fun () ->
+
+    ...
+
+

Note stack guarding doesn't result in a tailcall so will appear in recursive stack frames, because a counter must be decremented after the call. This is used systematically for recursive processing of:

+ +

We don't use it for other inputs.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/memory-usage.html b/memory-usage.html new file mode 100644 index 0000000000..83e5363881 --- /dev/null +++ b/memory-usage.html @@ -0,0 +1,579 @@ + + + + + + + + + + + + + + + + + + Memory usage | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Compiler Memory Usage

+

Overall memory usage is a primary determinant of the usability of the F# compiler and instances of the F# compiler service.

+

Why memory usage matters

+

Overly high memory usage results in poor throughput (particularly due to increased GC times) and low user interface responsivity in tools such as Visual Studio or other editing environments. In some extreme cases, it can lead to Visual Studio crashing or another IDE becoming unusable due to constant paging from absurdly high memory usage. Luckily, these extreme cases are very rare.

+

When you do a single compilation to produce a binary, memory usage typically doesn't matter much. It's often fine to allocate a lot of memory because it will just be reclaimed after compilation is over.

+

However, the F# compiler is not simply a batch process that accepts source code as input and produces an assembly as output. When you consider the needs of editor and project tooling in IDEs, the F# compiler is:

+ +

Thinking about the F# compiler in these ways makes performance far more complicated than just throughput of a batch compilation process.

+

Analyzing compiler memory usage

+

In general, the F# compiler allocates a lot of memory. More than it needs to. However, most of the "easy" sources of allocations have been squashed out and what remains are many smaller sources of allocations. The remaining "big" pieces allocate as a result of their current architecture, so it isn't straightforward to address them.

+

Some allocations are much more than others +* Large Object Heap (LOH) allocations (> ~80K) are rarely collected and should only be used for long-lived items. +* Ephemeral allocations that never escape the Gen0 seem to not matter that much, though of course should be considered. +* Don't try to remove all allocations, and don't assume copying of large structs is better than allocating a reference type. Measure instead.

+

To analyze memory usage of F# tooling, you have two primary avenues:

+
    +
  1. Take a process dump on your machine and analyze it
    2. +
  2. Use sampling to collect a trace of your system while you perform various tasks in an IDE, ideally for 60 seconds or more.
    3. +
+

You can analyze dumps and take samples with dotMemory or PerfView.

+

To analyze memory usage of the F# compiler itself: +* extract the compilation arguments out of msbuild output (or in the output pane of Visual Studio) +* put this content in a "response file" (a text file listing compiler arguments, one per line) +* use the memory profiler tool of choice, invoking the compiler (either fsc.exe, or through dotnet path/to/fsc.dll) giving it the argument @name-of-response-file, and setting the directory of the project that is compiled as working directory

+

Analyzing a process dump file

+

Process dump files are extremely information-rich data files that can be used to see the distribution of memory usage across various types. Tools like dotMemory will show these distributions and intelligently group things to help identify the biggest areas worth improving. Additionally, they will notice things like duplicate strings and sparse arrays, which are often great ways to improve memory usage since it means more memory is being used than is necessary.

+

Analyzing a sample trace of IDE usage

+

The other important tool to understand memory and CPU usage for a given sample of IDE usage is a trace file. These are collected and analyzed by tools like PerfView and dotTrace.

+

When analyzing a trace, there are a few things to look out for:

+
    +
  1. +Overall GC statistics for the sample to give an overall picture of what was going on in the IDE for your sample: +a. How much CPU time was spent in the GC as a percentage of total CPU time for the IDE process? +b. What was the peak working set (total memory usage)? +c. What was the peak allocations per second? +d. How many allocations were Gen0? Gen1? Gen2? +
    2. +
  2. +Memory allocations for the sample, typically also ignoring object deaths: +a. Is LargeObject showing up anywhere prominently? If so, that's a problem! +b. Which objects show up highest on the list? Does their presence that high make sense? +c. For a type such as System.String, which caller allocates it the most? Can that be improved? +
    3. +
  3. +CPU sampling data, sorted by most CPU time +a. Are any methods showing up that correspond with high memory allocations? Something showing up prominently in both places is often a sign that it needs work! +
    4. +
+

After analyzing a trace, you should have a good idea of places that could see improvement. Often times a tuple can be made into a struct tuple, or some convenient string processing could be adjusted to use a ReadonlySpan<'T> or turned into a more verbose loop that avoids allocations.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/names.html b/names.html new file mode 100644 index 0000000000..19d0c5296a --- /dev/null +++ b/names.html @@ -0,0 +1,982 @@ + + + + + + + + + + + + + + + + + + Display names, logical names and compiled names | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Names of entities and values in the F# Compiler

+

The F# tooling distinguishes between the following concepts of "name" for values, union cases, class/record fields and entities:

+ +

Specification of all logical names

+

The following tables loosely characterise the variations in logical names, how +they correspond to F# source constructs and the SyntaxTree/TypedTree metadata for these.

+

Entities:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Display name in code

Logical name

Notes

C

C

type definition

C

C`1

e.g. generic type, see notes below for variations of display names

M

M

module definition

M

MModule

"ModuleSuffix" attribute for F# modules, now somewhat legacy, rarely used, but still allowed; also where "ModuleSuffix" is implied because type and module have the same name

JsonProvider<"foo.json">

JsonProvider,Schema=\"xyz\"

static parameters, see notes below for variations of display names

+ +

Values:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Display name in code

Relation

Logical name

Notes

(+)

<-->

op_Addition

(+ )

-->

op_Addition

not reversed

op_Addition

-->

op_Addition

not reversed

(*)

<-->

op_Multiply

( * )

-->

op_Multiply

not reversed

op_Multiply

-->

op_Multiply

not reversed

( *+ )

<-->

op_MultiplyPlus

( *+ )

-->

op_MultiplyPlus

not reversed

op_MultiplyPlus

-->

op_MultiplyPlus

not reversed

(+++)

<-->

op_PlusPlusPlus

op_PlusPlusPlus

-->

op_PlusPlusPlus

not reversed

(%)

<-->

op_Modulus

op_Modulus

-->

op_Modulus

(?)

<-->

op_Dynamic

not defined by default, for x?SomeThing

(?<-)

<-->

op_DynamicAssignment

not defined by default, for x?SomeThing <- "a"

(..)

<-->

op_Range

for "3 .. 5"

(.. ..)

<-->

op_RangeStep

for "5 .. -1 .. 3"

or

<-->

or

mod

<-->

mod

let

<-->

let

this is a keyword, in code it appears as let

type

<-->

type

this is a keyword, in code it appears as type

base

<-->

base

for IsBaseVal=true only. Base is a keyword, this is a special base val

base

<-->

base

for IsBaseVal=false only. Base is a keyword, this is not a special base val

SomeClass

<-->

.ctor

IsConstructor=true

.ctor

<-->

.ctor

IsConstructor=false, this is only allowed for let-definitions, e.g. let .ctor x = 1

<-->

.cctor

IsClassConstructor=true, should never really appear in diagnostics or user-facing output

.cctor

<-->

.cctor

IsClassConstructor=false, this is only allowed for let-definitions, e.g. let .cctor x = 1

(\|A\|_\|)

<-->

\|A\|_\|

(\|A \|_ \|)

-->

\|A\|_\|

not reversed

P

<-->

get_P

IsPropertyGetterMethod = true

P

<-->

set_P

IsPropertySetterMethod = true

+ +

Other Val constructs less problematic for naming are:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Display name in code

Relation

Logical name

Notes

this

<-->

this

IsCtorThisVal = true; From type C() as this; Can have any name, not particularly special with regard to names; This has a 'ref' type for initialization checks

this

<-->

this

IsMemberThisVal = true; From member this.M() = ...; This can have a 'ref' type for initialization checks; Can have any name, not particularly special with regard to names

\

<-->

System.IDisposable.Dispose

ImplementedSlotSigs is non-empty, i.e. length 1, should never really appear in diagnostics or user-facing output

+ +

Union cases:

+ + + + + + + + + + + +

Display name in code

Relation

Logical name

Notes

+ +

SomeCase | <--> | SomeCase +``Case with space`` | <--> | Case with space +``type`` | <--> | type | This is a keyword +(::) | <--> | op_ColonColon | This is the logical name for the cons union case on FSharpList only +[] | <--> | op_Nil | This is the logical name for the nil case on FSharpList only

+

Class and record fields, enum cases, active pattern cases, anonymous record fields:

+ + + + + + + + + + + +

Display name in code

Relation

Logical name

Notes

+ +

SomeField | <--> | SomeField +``Field with space``| <--> | Field with space +``type`` | <--> | type | This is a keyword

+

Generic parameters:

+ + + + + + + + + + + +

Display name in code

Relation

Logical name

Notes

+ +

'T | <--> | T +'``T T T`` | <--> | T T T | BUG: the backticks are not currently added +'``type`` | <--> | type | This is a keyword, BUG: the backticks are not currently added

+

Variations on display names

+

In different display settings, Entities/Types/Modules can have some variations on display names. For example, when showing some kinds of output we may set shortTypeNames=true which will never show full names.

+ +

Examples: +- SomeNamespace.OtherNamespace.SomeType +- ``Some Namespace With Spaces``.SomeType <-- BUG: not double-ticks today +- `SomeEnclosingType<_>.SomeStaticMethod` <-- BUG: the mangled generic type counts are shown today

+

Compiled names

+

The name that appears in the .NET IL.

+

Affected by: +- CompiledName attribute +- some heuristics for generic type parameters

+

Also the name from signature is generally preferred; if there is any difference, a warning is emitted.

+

Example of how signature affects compiled names

+
Foo.fsi 
+
+  val SomeFunction: x: int -> y: int -> int 
+
+Foo.fs
+
+  let SomeFunction a b = a + b // compiled name of parameters is x, y - warning emitted
+
+ +
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/optimizations.html b/optimizations.html new file mode 100644 index 0000000000..8c16e91c4b --- /dev/null +++ b/optimizations.html @@ -0,0 +1,609 @@ + + + + + + + + + + + + + + + + + + Optimizations | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Code Optimizations

+

Code optimizations are in Compiler/Optimize/*.

+

Some of the optimizations performed in Optimizer.fs are:

+ +

In DetupleArgs.fs, tuples at call sites are eliminated if possible. Concretely, functions that accept a tuple at all call sites are replaced by functions that accept each of the tuple's arguments individually. This may require inlining to activate.

+

Considering the following example:

+
let max3 t =
+    let (x, y, z) = t
+    max x (max y z)
+
+max3 (1, 2, 3)
+
+

The max3 function gets rewritten to simply accept three arguments, and depending on how it gets called it will either get inlined at the call site or called with 3 arguments instead of a new tuple. In either case, the tuple allocation is eliminated.

+

However, sometimes this optimization is not applied unless a function is marked inline. Consider a more complicated case:

+
let rec runWithTuple t offset times =
+    let offsetValues x y z offset =
+        (x + offset, y + offset, z + offset)
+    if times <= 0 then
+        t
+    else
+        let (x, y, z) = t
+        let r = offsetValues x y z offset
+        runWithTuple r offset (times - 1)
+
+

The inner function offsetValues will allocate a new tuple when called. However, if offsetValues is marked as inline then it will no longer allocate a tuple.

+

Currently, these optimizations are not applied to struct tuples or explicit ValueTuples passed to a function. In most cases, this doesn't matter because the handling of ValueTuple is well-optimized and may be erased at runtime. However, in the previous runWithTuple function, the overhead of allocating a ValueTuple each call ends up being higher than the previous example with inline applied to offsetValues. This may be addressed in the future.

+

In InnerLambdasToTopLevelFuncs.fs, inner functions and lambdas are analyzed and, if possible, rewritten into separate methods that do not require an FSharpFunc allocation.

+

Consider the following implementation of sumBy on an F# list:

+
let sumBy f xs =
+    let rec loop xs acc =
+        match xs with
+        | [] -> acc
+        | x :: t -> loop t (f x + acc)
+    loop xs 0
+
+

The inner loop function is emitted as a separate static method named loop@2 and incurs no overhead involved with allocating an FSharpFunc at runtime.

+

In LowerCalls.fs:

+ +

In LowerSequences.fs:

+ +

Potential future optimizations: Better Inlining

+

Consider the following example:

+
let inline f k = (fun x -> k (x + 1))
+let inline g k = (fun x -> k (x + 2))
+
+let res = (f << g) id 1 // 4
+
+

Intermediate values that inherit from FSharpFunc are allocated at the call set of res to support function composition, even if the functions are marked as inline. Currently, if this overhead needs removal, you need to rewrite the code to be more like this:

+
let f x = x + 1
+let g x = x + 2
+
+let res = id 1 |> g |> f // 4
+
+

The downside of course being that the id function can't propagate to composed functions, meaning the code is now different despite yielding the same result.

+

More generally, any time a first-order function is passed as an argument to a second-order function, the first-order function is not inlined even if everything is marked as inline. This results in a performance penalty.

+ +
val max3: 'a * 'a * 'a -> 'a (requires comparison)
+
val t: 'a * 'a * 'a (requires comparison)
+
val x: 'a (requires comparison)
+
val y: 'a (requires comparison)
+
val z: 'a (requires comparison)
+
val max: e1: 'T -> e2: 'T -> 'T (requires comparison)
+
val runWithTuple: int * int * int -> offset: int -> times: int -> int * int * int
+
val t: int * int * int
+
val offset: int
+
val times: int
+
val offsetValues: x: int -> y: int -> z: int -> offset: int -> int * int * int
+
val x: int
+
val y: int
+
val z: int
+
val r: int * int * int
+
val sumBy: f: ('a -> int) -> xs: 'a list -> int
+
val f: ('a -> int)
+
val xs: 'a list
+
val loop: xs: 'a list -> acc: int -> int
+
val acc: int
+
val x: 'a
+
val t: 'a list
+
val f: k: (int -> 'a) -> x: int -> 'a
+
val k: (int -> 'a)
+
val g: k: (int -> 'a) -> x: int -> 'a
+
val res: int
+
val id: x: 'T -> 'T
+
val f: x: int -> int
+
val g: x: int -> int
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/overview.html b/overview.html new file mode 100644 index 0000000000..9afec4cec0 --- /dev/null +++ b/overview.html @@ -0,0 +1,674 @@ + + + + + + + + + + + + + + + + + + Overview | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Overview

+

There are several artifacts involved in the development of F#:

+ +

The FSharp.Compiler.Service is by far the largest of these components and contains nearly all logic that fsc and fsi use. It is the primary subject of this guide.

+

Key compiler data formats and representations

+

The following are the key data formats and internal data representations of the F# compiler code in its various configurations:

+ +

Key constructs and APIs for F# tooling

+

The following are the most relevant parts of the F# compiler tooling, making up the "engine" and API surface area of FSharp.Compiler.Service.

+ +

Key compiler phases

+

The following is a diagram of how the different phases of the F# compiler work:

+
stateDiagram-v2
+    state "Compilation phases" as Flow {
+      Lexing: Lexing
+      Parsing: Parsing
+      Import: Import
+      Typechecking: Type checking
+      Codegen: Code generation
+      Emit: IL emit
+      Inputs --> Lexing: Source and signature files
+      Inputs --> Import: References
+      Lexing --> Parsing
+      Parsing --> Typechecking
+      Import --> Typechecking
+      Typechecking --> Codegen
+      Codegen --> Emit
+      state Lexing {
+          BasicLexing: Basic Lexing
+          WhitespaceSensitiveLexing: Whitespace Sensitive Lexing
+          [*] --> BasicLexing
+          BasicLexing --> WhitespaceSensitiveLexing: A token stream from input source text.
+          WhitespaceSensitiveLexing --> [*]: A token stream, augmented per the F# Language Specification.
+      }
+      state Parsing {
+          Parser: Parsing
+          [*] --> Parser
+          Parser --> [*]: AST per the grammar in the F# Language Specification.
+      }
+      state Import {
+          Resolving: Resolving references
+          ImportNET: Importing .NET references
+          ImportFS: Importing F# references
+          [*] --> Resolving
+          Resolving --> ImportNET
+          Resolving --> ImportFS
+          ImportNET --> [*]
+          ImportFS --> [*]
+      }
+      state Typechecking {
+          SequentialTypechecking: Sequentially type checking files
+          PatternMatchCompilation: Pattern match compilation
+          ConstraintSolving: Constraint solving
+          PostInferenceChecks: Post inference checks
+          [*] --> SequentialTypechecking
+          SequentialTypechecking --> PatternMatchCompilation
+          PatternMatchCompilation --> ConstraintSolving
+          ConstraintSolving --> PostInferenceChecks
+          PostInferenceChecks --> [*]
+      }
+      state Codegen {
+          QuotationTranslation: Quotation translation
+          Optimization: Optimization
+          Codegeneration: Code generation
+          AbstractILRewrite: Abstract IL rewriting
+          [*] --> QuotationTranslation
+          QuotationTranslation --> Optimization
+          Optimization --> Codegeneration
+          Codegeneration --> AbstractILRewrite
+          AbstractILRewrite --> [*]
+      }
+      state Emit {
+          Binary: Binary emit
+          Reflection: Reflection emit
+          Output: Output (assembly, references, PDBs, etc.)
+          [*] --> Binary
+          [*] --> Reflection
+          Binary --> Output
+          Reflection --> Output
+      }
+  }
+
+

The following are the key phases and high-level logical operations of the F# compiler code in its various configurations:

+ +

These and transformations used to build the following:

+ +

Bootstrapping

+

The F# compiler is bootstrapped. That is, an existing F# compiler is used to build a "proto" compiler from the current source code. That "proto" compiler is then used to compile itself, producing a "final" compiler. This ensures the final compiler is compiled with all relevant optimizations and fixes.

+

FSharp.Build

+

FSharp.Build.dll and Microsoft.FSharp.targets give MSBuild support for F# projects (.fsproj) and contain the targets. Although not strictly part of the F# compiler, they are essential for using F# in all contexts for .NET, aside from some more targeted scripting scenarios. The targets expose things like the CoreCompile and Fsc tasks called by MSBuild.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/perf-discussions-archive.html b/perf-discussions-archive.html new file mode 100644 index 0000000000..04543d2155 --- /dev/null +++ b/perf-discussions-archive.html @@ -0,0 +1,599 @@ + + + + + + + + + + + + + + + + + + Comparisons + | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+

This is just a typed version of these notes, generated during perf discussions on summer of 2023. Can be used as a reference point.

+
+

Comparisons

+ +

Underlying problems

+ +

Major problems

+ +

Hosted compiler problems

+ +

Minor problems

+ +

Incremental phases

+ +

Community guidelines

+ + + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/project-builds.html b/project-builds.html new file mode 100644 index 0000000000..a63c1b5806 --- /dev/null +++ b/project-builds.html @@ -0,0 +1,564 @@ + + + + + + + + + + + + + + + + + + Project builds | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Project builds

+

The compiler is generally built to compile one assembly: the assumption that the compiler is compiling one assembly is baked into several aspects of the design of the Typed Tree. In contrast, FCS supports compiling a graph of projects, each for a different assembly, each undergoing incremental change.

+

Project builds are currently stateful and reliant on I/O to on-disk assemblies. This causes many problems and we have a plan for how to fix this core issue in the F# Language Service implementation. See Plan: Modernizing F# Analysis. Please read this carefully if you plan to work on any of service.fs, IncrementalBuild.fs or FSharpCheckerResults.fs.

+

Key data structures:

+ +

Multi-project builds and cross-project references

+

In FCS, there is no single abstraction for a "solution build" and instead you have multiple project builds. These are all essentially independent, in the sense they each logically represent an invocation of the F# compiler. That is, the Typed Tree (TAST), TcState etc. nodes are not shared between different project compilations.

+

If you want to understand why this invariant is important, some key things to understand are:

+ +

Could the compiler share this data across projects? In theory, yes. In practice, it's very tricky business. From a correctness point of view: the process of generating this blob (TypedTreePickle p_XYZ) and resurrecting it (TypedTreePickle u_*) does some transformations to the Typed Tree that are necessary for correctness of compilation, for example, in TypedTreePickle. Basically, the Typed Tree nodes from the compilation of one assembly are not valid when compiling a different assembly.

+

The Typed Tree nodes include CcuData nodes, which have access to a number of callbacks into the TcImports compilation context for the assembly being compiled. TypedTree nodes are effectively tied to a particular compilation of a particular assembly due to this. There isn't any way to share this data without losing correctness and invalidating many invariants held in the current design. From a lifetime point of view: the Typed Tree nodes are tied together in a graph, so sharing one or two of them might drag across the entire graph and extend lifetimes of that graph. None of these interrelated nodes were designed to be shared across assemblies.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilargconvention.html b/reference/fsharp-compiler-abstractil-il-ilargconvention.html new file mode 100644 index 0000000000..d3d3136d20 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilargconvention.html @@ -0,0 +1,766 @@ + + + + + + + + + + + + + + + + + + ILArgConvention (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILArgConvention Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILArgConvention> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + CDecl + + +

+ +
+
+ Full Usage: + CDecl +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Default + + +

+ +
+
+ Full Usage: + Default +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + FastCall + + +

+ +
+
+ Full Usage: + FastCall +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + StdCall + + +

+ +
+
+ Full Usage: + StdCall +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ThisCall + + +

+ +
+
+ Full Usage: + ThisCall +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + VarArg + + +

+ +
+
+ Full Usage: + VarArg +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilarrayshape.html b/reference/fsharp-compiler-abstractil-il-ilarrayshape.html new file mode 100644 index 0000000000..e650cc2743 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilarrayshape.html @@ -0,0 +1,743 @@ + + + + + + + + + + + + + + + + + + ILArrayShape (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILArrayShape Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILArrayShape> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Rank + + +

+ +
+
+ Full Usage: + this.Rank +
+
+ + Returns: + int + +
+
+
+
+ 		+
+
+ + Returns: + + int +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILArrayShape.FromRank(arg1) + + +

+ +
+
+ Full Usage: + ILArrayShape.FromRank(arg1) +
+
+ Parameters: +
    + + + arg0 + + : + int + +
    +
+
+ + Returns: + ILArrayShape + +
+
+
+
+ 		+
+
+ + arg0 + + : + int +
+
+
+
+
+ + Returns: + + ILArrayShape +
+
+
+
+
+ +

+ + + ILArrayShape.SingleDimensional + + +

+ +
+
+ Full Usage: + ILArrayShape.SingleDimensional +
+
+ + Returns: + ILArrayShape + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Bounds for a single dimensional, zero based array +

+
+ +
+
+ + Returns: + + ILArrayShape +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilassemblylongevity.html b/reference/fsharp-compiler-abstractil-il-ilassemblylongevity.html new file mode 100644 index 0000000000..cac8aab2d6 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilassemblylongevity.html @@ -0,0 +1,607 @@ + + + + + + + + + + + + + + + + + + ILAssemblyLongevity (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAssemblyLongevity Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILAssemblyLongevity> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILAssemblyLongevity.Default + + +

+ +
+
+ Full Usage: + ILAssemblyLongevity.Default +
+
+ + Returns: + ILAssemblyLongevity + +
+
+
+
+ 		+
+
+ + Returns: + + ILAssemblyLongevity +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html b/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html new file mode 100644 index 0000000000..cec32897da --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilassemblymanifest.html @@ -0,0 +1,1296 @@ + + + + + + + + + + + + + + + + + + ILAssemblyManifest (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAssemblyManifest Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ The main module of an assembly is a module plus some manifest information. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AssemblyLongevity + + +

+ +
+
+ Full Usage: + AssemblyLongevity +
+
+ + Field type: + ILAssemblyLongevity + +
+
+
+
+ 		+
+
+ + Field type: + + ILAssemblyLongevity +
+
+
+
+
+ +

+ + + AuxModuleHashAlgorithm + + +

+ +
+
+ Full Usage: + AuxModuleHashAlgorithm +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+ +
+ + + +

+ This is the ID of the algorithm used for the hashes of auxiliary + files in the assembly. These hashes are stored in the + ILModuleRef.Hash fields of this assembly. These are not + cryptographic hashes: they are simple file hashes. The algorithm + is normally 0x00008004 indicating the SHA1 hash algorithm. +

+
+ +
+
+ + Field type: + + int32 +
+
+
+
+
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+ +

+ + + DisableJitOptimizations + + +

+ +
+
+ Full Usage: + DisableJitOptimizations +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + EntrypointElsewhere + + +

+ +
+
+ Full Usage: + EntrypointElsewhere +
+
+ + Field type: + ILModuleRef option + +
+
+
+
+ 		+
+ +
+ + + +

+ Records whether the entrypoint resides in another module. +

+
+ +
+
+ + Field type: + + ILModuleRef option +
+
+
+
+
+
+ +

+ + + ExportedTypes + + +

+ +
+
+ Full Usage: + ExportedTypes +
+
+ + Field type: + ILExportedTypesAndForwarders + +
+
+
+
+ 		+
+ +
+ + + +

+ Records the types implemented by this assembly in auxiliary + modules. +

+
+ +
+
+ + Field type: + + ILExportedTypesAndForwarders +
+
+
+
+
+
+ +

+ + + IgnoreSymbolStoreSequencePoints + + +

+ +
+
+ Full Usage: + IgnoreSymbolStoreSequencePoints +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + JitTracking + + +

+ +
+
+ Full Usage: + JitTracking +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Locale + + +

+ +
+
+ Full Usage: + Locale +
+
+ + Field type: + string option + +
+
+
+
+ 		+
+
+ + Field type: + + string option +
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + PublicKey + + +

+ +
+
+ Full Usage: + PublicKey +
+
+ + Field type: + byte[] option + +
+
+
+
+ 		+
+ +
+ + + +

+ This is the public key used to sign this + assembly (the signature itself is stored elsewhere: see the + binary format, and may not have been written if delay signing + is used). (member Name, member PublicKey) forms the full + public name of the assembly. +

+
+ +
+
+ + Field type: + + byte[] option +
+
+
+
+
+
+ +

+ + + Retargetable + + +

+ +
+
+ Full Usage: + Retargetable +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + SecurityDeclsStored + + +

+ +
+
+ Full Usage: + SecurityDeclsStored +
+
+ + Field type: + ILSecurityDeclsStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILSecurityDeclsStored +
+
+
+
+
+ +

+ + + Version + + +

+ +
+
+ Full Usage: + Version +
+
+ + Field type: + ILVersionInfo option + +
+
+
+
+ 		+
+
+ + Field type: + + ILVersionInfo option +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.SecurityDecls + + +

+ +
+
+ Full Usage: + this.SecurityDecls +
+
+ + Returns: + ILSecurityDecls + +
+
+
+
+ 		+
+
+ + Returns: + + ILSecurityDecls +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilassemblyref.html b/reference/fsharp-compiler-abstractil-il-ilassemblyref.html new file mode 100644 index 0000000000..fde28c1313 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilassemblyref.html @@ -0,0 +1,1152 @@ + + + + + + + + + + + + + + + + + + ILAssemblyRef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAssemblyRef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.EqualsIgnoringVersion + + +

+ +
+
+ Full Usage: + this.EqualsIgnoringVersion +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILAssemblyRef +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Hash + + +

+ +
+
+ Full Usage: + this.Hash +
+
+ + Returns: + byte[] option + +
+
+
+
+ 		+
+
+ + Returns: + + byte[] option +
+
+
+
+
+ +

+ + + this.Locale + + +

+ +
+
+ Full Usage: + this.Locale +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+
+ + Returns: + + string option +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.PublicKey + + +

+ +
+
+ Full Usage: + this.PublicKey +
+
+ + Returns: + PublicKey option + +
+
+
+
+ 		+
+
+ + Returns: + + PublicKey option +
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The fully qualified name of the assembly reference, e.g. mscorlib, Version=1.0.3705 etc. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Retargetable + + +

+ +
+
+ Full Usage: + this.Retargetable +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ CLI says this indicates if the assembly can be retargeted (at runtime) to be from a different publisher. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Version + + +

+ +
+
+ Full Usage: + this.Version +
+
+ + Returns: + ILVersionInfo option + +
+
+
+
+ 		+
+
+ + Returns: + + ILVersionInfo option +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILAssemblyRef.Create(name, hash, publicKey, retargetable, version, locale) + + +

+ +
+
+ Full Usage: + ILAssemblyRef.Create(name, hash, publicKey, retargetable, version, locale) +
+
+ Parameters: +
    + + + name + + : + string + +
    + + + hash + + : + byte[] option + +
    + + + publicKey + + : + PublicKey option + +
    + + + retargetable + + : + bool + +
    + + + version + + : + ILVersionInfo option + +
    + + + locale + + : + string option + +
    +
+
+ + Returns: + ILAssemblyRef + +
+
+
+
+ 		+
+
+ + name + + : + string +
+
+
+ + hash + + : + byte[] option +
+
+
+ + publicKey + + : + PublicKey option +
+
+
+ + retargetable + + : + bool +
+
+
+ + version + + : + ILVersionInfo option +
+
+
+ + locale + + : + string option +
+
+
+
+
+ + Returns: + + ILAssemblyRef +
+
+
+
+
+ +

+ + + ILAssemblyRef.FromAssemblyName(arg1) + + +

+ +
+
+ Full Usage: + ILAssemblyRef.FromAssemblyName(arg1) +
+
+ Parameters: + +
+ + Returns: + ILAssemblyRef + +
+
+
+
+ 		+
+
+ + arg0 + + : + AssemblyName +
+
+
+
+
+ + Returns: + + ILAssemblyRef +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilattribelem.html b/reference/fsharp-compiler-abstractil-il-ilattribelem.html new file mode 100644 index 0000000000..9f0e1b2da2 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilattribelem.html @@ -0,0 +1,1382 @@ + + + + + + + + + + + + + + + + + + ILAttribElem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAttribElem Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILAttribElem> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Array(ILType, ILAttribElem list) + + +

+ +
+
+ Full Usage: + Array(ILType, ILAttribElem list) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item1 + + : + ILType +
+
+
+ + Item2 + + : + ILAttribElem list +
+
+
+
+
+ +

+ + + Bool bool + + +

+ +
+
+ Full Usage: + Bool bool +
+
+ Parameters: +
    + + + Item + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + bool +
+
+
+
+
+ +

+ + + Byte byte + + +

+ +
+
+ Full Usage: + Byte byte +
+
+ Parameters: +
    + + + Item + + : + byte + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + byte +
+
+
+
+
+ +

+ + + Char char + + +

+ +
+
+ Full Usage: + Char char +
+
+ Parameters: +
    + + + Item + + : + char + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + char +
+
+
+
+
+ +

+ + + Double double + + +

+ +
+
+ Full Usage: + Double double +
+
+ Parameters: +
    + + + Item + + : + double + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + double +
+
+
+
+
+ +

+ + + Int16 int16 + + +

+ +
+
+ Full Usage: + Int16 int16 +
+
+ Parameters: +
    + + + Item + + : + int16 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int16 +
+
+
+
+
+ +

+ + + Int32 int32 + + +

+ +
+
+ Full Usage: + Int32 int32 +
+
+ Parameters: +
    + + + Item + + : + int32 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int32 +
+
+
+
+
+ +

+ + + Int64 int64 + + +

+ +
+
+ Full Usage: + Int64 int64 +
+
+ Parameters: +
    + + + Item + + : + int64 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int64 +
+
+
+
+
+ +

+ + + Null + + +

+ +
+
+ Full Usage: + Null +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SByte sbyte + + +

+ +
+
+ Full Usage: + SByte sbyte +
+
+ Parameters: +
    + + + Item + + : + sbyte + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + sbyte +
+
+
+
+
+ +

+ + + Single single + + +

+ +
+
+ Full Usage: + Single single +
+
+ Parameters: +
    + + + Item + + : + single + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + single +
+
+
+
+
+ +

+ + + String string option + + +

+ +
+
+ Full Usage: + String string option +
+
+ Parameters: +
    + + + Item + + : + string option + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Represents a custom attribute parameter of type 'string'. These may be null, in which case they are encoded in a special + way as indicated by Ecma-335 Partition II. +

+
+ +
+
+ + Item + + : + string option +
+
+
+
+
+
+ +

+ + + Type ILType option + + +

+ +
+
+ Full Usage: + Type ILType option +
+
+ Parameters: +
    + + + Item + + : + ILType option + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + ILType option +
+
+
+
+
+ +

+ + + TypeRef ILTypeRef option + + +

+ +
+
+ Full Usage: + TypeRef ILTypeRef option +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + ILTypeRef option +
+
+
+
+
+ +

+ + + UInt16 uint16 + + +

+ +
+
+ Full Usage: + UInt16 uint16 +
+
+ Parameters: +
    + + + Item + + : + uint16 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint16 +
+
+
+
+
+ +

+ + + UInt32 uint32 + + +

+ +
+
+ Full Usage: + UInt32 uint32 +
+
+ Parameters: +
    + + + Item + + : + uint32 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint32 +
+
+
+
+
+ +

+ + + UInt64 uint64 + + +

+ +
+
+ Full Usage: + UInt64 uint64 +
+
+ Parameters: +
    + + + Item + + : + uint64 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint64 +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilattribute.html b/reference/fsharp-compiler-abstractil-il-ilattribute.html new file mode 100644 index 0000000000..754b1777a1 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilattribute.html @@ -0,0 +1,751 @@ + + + + + + + + + + + + + + + + + + ILAttribute (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAttribute Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILAttribute> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Custom attribute. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Decoded(method, fixedArgs, namedArgs) + + +

+ +
+
+ Full Usage: + Decoded(method, fixedArgs, namedArgs) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Attribute with args in decoded form. +

+
+ +
+
+ + method + + : + ILMethodSpec +
+
+
+ + fixedArgs + + : + ILAttribElem list +
+
+
+ + namedArgs + + : + ILAttributeNamedArg list +
+
+
+
+
+
+ +

+ + + Encoded(method, data, elements) + + +

+ +
+
+ Full Usage: + Encoded(method, data, elements) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Attribute with args encoded to a binary blob according to ECMA-335 II.21 and II.23.3. + 'decodeILAttribData' is used to parse the byte[] blob to ILAttribElem's as best as possible. +

+
+ +
+
+ + method + + : + ILMethodSpec +
+
+
+ + data + + : + byte[] +
+
+
+ + elements + + : + ILAttribElem list +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilattributes.html b/reference/fsharp-compiler-abstractil-il-ilattributes.html new file mode 100644 index 0000000000..32faf0dc54 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilattributes.html @@ -0,0 +1,639 @@ + + + + + + + + + + + + + + + + + + ILAttributes (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAttributes Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + ValueType +
+
+ Kind: Struct +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AsArray + + +

+ +
+
+ Full Usage: + this.AsArray +
+
+ + Returns: + ILAttribute[] + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttribute[] +
+
+
+
+
+ +

+ + + this.AsList + + +

+ +
+
+ Full Usage: + this.AsList +
+
+ + Returns: + ILAttribute list + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttribute list +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilattributesstored.html b/reference/fsharp-compiler-abstractil-il-ilattributesstored.html new file mode 100644 index 0000000000..145694f591 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilattributesstored.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILAttributesStored (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILAttributesStored Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the efficiency-oriented storage of ILAttributes in another item. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilcallingconv.html b/reference/fsharp-compiler-abstractil-il-ilcallingconv.html new file mode 100644 index 0000000000..3422dea418 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilcallingconv.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + ILCallingConv (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILCallingConv Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILCallingConv> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Callconv(ILThisConvention, ILArgConvention) + + +

+ +
+
+ Full Usage: + Callconv(ILThisConvention, ILArgConvention) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item1 + + : + ILThisConvention +
+
+
+ + Item2 + + : + ILArgConvention +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILCallingConv.Instance + + +

+ +
+
+ Full Usage: + ILCallingConv.Instance +
+
+ + Returns: + ILCallingConv + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingConv +
+
+
+
+
+ +

+ + + ILCallingConv.Static + + +

+ +
+
+ Full Usage: + ILCallingConv.Static +
+
+ + Returns: + ILCallingConv + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingConv +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html b/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html new file mode 100644 index 0000000000..0bafacfac0 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilcallingsignature.html @@ -0,0 +1,685 @@ + + + + + + + + + + + + + + + + + + ILCallingSignature (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILCallingSignature Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILCallingSignature> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ArgTypes + + +

+ +
+
+ Full Usage: + ArgTypes +
+
+ + Field type: + ILTypes + +
+
+
+
+ 		+
+
+ + Field type: + + ILTypes +
+
+
+
+
+ +

+ + + CallingConv + + +

+ +
+
+ Full Usage: + CallingConv +
+
+ + Field type: + ILCallingConv + +
+
+
+
+ 		+
+
+ + Field type: + + ILCallingConv +
+
+
+
+
+ +

+ + + ReturnType + + +

+ +
+
+ Full Usage: + ReturnType +
+
+ + Field type: + ILType + +
+
+
+
+ 		+
+
+ + Field type: + + ILType +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ildebugimport.html b/reference/fsharp-compiler-abstractil-il-ildebugimport.html new file mode 100644 index 0000000000..91c80cdd74 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ildebugimport.html @@ -0,0 +1,679 @@ + + + + + + + + + + + + + + + + + + ILDebugImport (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILDebugImport Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Defines an opened namespace, type relevant to a code location. + + Emitted to the PortablePDB format. Note the format supports additional variations on + imported things that are not yet emitted in F#. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ImportNamespace targetNamespace + + +

+ +
+
+ Full Usage: + ImportNamespace targetNamespace +
+
+ Parameters: +
    + + + targetNamespace + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Represents an 'open XYZ' opening a namespace +

+
+ +
+
+ + targetNamespace + + : + string +
+
+
+
+
+
+ +

+ + + ImportType targetType + + +

+ +
+
+ Full Usage: + ImportType targetType +
+
+ Parameters: +
    + + + targetType + + : + ILType + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Represents an 'open type XYZ' opening a type +

+
+ +
+
+ + targetType + + : + ILType +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ildebugimports.html b/reference/fsharp-compiler-abstractil-il-ildebugimports.html new file mode 100644 index 0000000000..2fa71f6c50 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ildebugimports.html @@ -0,0 +1,638 @@ + + + + + + + + + + + + + + + + + + ILDebugImports (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILDebugImports Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Defines a set of opened namespace, type relevant to a code location. + + Emitted to the PortablePDB format. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Imports + + +

+ +
+
+ Full Usage: + Imports +
+
+ + Field type: + ILDebugImport[] + +
+
+
+
+ 		+
+
+ + Field type: + + ILDebugImport[] +
+
+
+
+
+ +

+ + + Parent + + +

+ +
+
+ Full Usage: + Parent +
+
+ + Field type: + ILDebugImports option + +
+
+
+
+ 		+
+
+ + Field type: + + ILDebugImports option +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html b/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html new file mode 100644 index 0000000000..0bee62f522 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ildefaultpinvokeencoding.html @@ -0,0 +1,667 @@ + + + + + + + + + + + + + + + + + + ILDefaultPInvokeEncoding (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILDefaultPInvokeEncoding Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILDefaultPInvokeEncoding> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Default Unicode encoding for P/Invoke within a type. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Ansi + + +

+ +
+
+ Full Usage: + Ansi +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Auto + + +

+ +
+
+ Full Usage: + Auto +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Unicode + + +

+ +
+
+ Full Usage: + Unicode +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ileventdef.html b/reference/fsharp-compiler-abstractil-il-ileventdef.html new file mode 100644 index 0000000000..bd47679a5e --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ileventdef.html @@ -0,0 +1,1157 @@ + + + + + + + + + + + + + + + + + + ILEventDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILEventDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Event definitions. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + ILEventDef(eventType, name, attributes, addMethod, removeMethod, fireMethod, otherMethods, customAttrs) + + +

+ +
+
+ Full Usage: + ILEventDef(eventType, name, attributes, addMethod, removeMethod, fireMethod, otherMethods, customAttrs) +
+
+ Parameters: + +
+ + Returns: + ILEventDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation of a value, immediate +

+
+ +
+
+ + eventType + + : + ILType option +
+
+
+ + name + + : + string +
+
+
+ + attributes + + : + EventAttributes +
+
+
+ + addMethod + + : + ILMethodRef +
+
+
+ + removeMethod + + : + ILMethodRef +
+
+
+ + fireMethod + + : + ILMethodRef option +
+
+
+ + otherMethods + + : + ILMethodRef list +
+
+
+ + customAttrs + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILEventDef +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AddMethod + + +

+ +
+
+ Full Usage: + this.AddMethod +
+
+ + Returns: + ILMethodRef + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef +
+
+
+
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + EventAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + EventAttributes +
+
+
+
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.EventType + + +

+ +
+
+ Full Usage: + this.EventType +
+
+ + Returns: + ILType option + +
+
+
+
+ 		+
+
+ + Returns: + + ILType option +
+
+
+
+
+ +

+ + + this.FireMethod + + +

+ +
+
+ Full Usage: + this.FireMethod +
+
+ + Returns: + ILMethodRef option + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef option +
+
+
+
+
+ +

+ + + this.IsRTSpecialName + + +

+ +
+
+ Full Usage: + this.IsRTSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSpecialName + + +

+ +
+
+ Full Usage: + this.IsSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.OtherMethods + + +

+ +
+
+ Full Usage: + this.OtherMethods +
+
+ + Returns: + ILMethodRef list + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef list +
+
+
+
+
+ +

+ + + this.RemoveMethod + + +

+ +
+
+ Full Usage: + this.RemoveMethod +
+
+ + Returns: + ILMethodRef + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ileventdefs.html b/reference/fsharp-compiler-abstractil-il-ileventdefs.html new file mode 100644 index 0000000000..0d184e66cc --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ileventdefs.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILEventDefs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILEventDefs Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Table of those events in a type definition. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html b/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html new file mode 100644 index 0000000000..e1c96d8bc4 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilexportedtypeorforwarder.html @@ -0,0 +1,939 @@ + + + + + + + + + + + + + + + + + + ILExportedTypeOrForwarder (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILExportedTypeOrForwarder Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ these are only found in the ILExportedTypesAndForwarders table in the manifest +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Attributes + + +

+ +
+
+ Full Usage: + Attributes +
+
+ + Field type: + TypeAttributes + +
+
+
+
+ 		+
+
+ + Field type: + + TypeAttributes +
+
+
+
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ [Namespace.]Name +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + Nested + + +

+ +
+
+ Full Usage: + Nested +
+
+ + Field type: + ILNestedExportedTypes + +
+
+
+
+ 		+
+
+ + Field type: + + ILNestedExportedTypes +
+
+
+
+
+ +

+ + + ScopeRef + + +

+ +
+
+ Full Usage: + ScopeRef +
+
+ + Field type: + ILScopeRef + +
+
+
+
+ 		+
+
+ + Field type: + + ILScopeRef +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Access + + +

+ +
+
+ Full Usage: + this.Access +
+
+ + Returns: + ILTypeDefAccess + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeDefAccess +
+
+
+
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.IsForwarder + + +

+ +
+
+ Full Usage: + this.IsForwarder +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilexportedtypesandforwarders.html b/reference/fsharp-compiler-abstractil-il-ilexportedtypesandforwarders.html new file mode 100644 index 0000000000..294e56f95c --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilexportedtypesandforwarders.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILExportedTypesAndForwarders (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILExportedTypesAndForwarders Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilfielddef.html b/reference/fsharp-compiler-abstractil-il-ilfielddef.html new file mode 100644 index 0000000000..dc92a0ee49 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilfielddef.html @@ -0,0 +1,1331 @@ + + + + + + + + + + + + + + + + + + ILFieldDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILFieldDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Field definitions. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + ILFieldDef(name, fieldType, attributes, data, literalValue, offset, marshal, customAttrs) + + +

+ +
+
+ Full Usage: + ILFieldDef(name, fieldType, attributes, data, literalValue, offset, marshal, customAttrs) +
+
+ Parameters: +
    + + + name + + : + string + +
    + + + fieldType + + : + ILType + +
    + + + attributes + + : + FieldAttributes + +
    + + + data + + : + byte[] option + +
    + + + literalValue + + : + ILFieldInit option + +
    + + + offset + + : + int32 option + +
    + + + marshal + + : + ILNativeType option + +
    + + + customAttrs + + : + ILAttributes + +
    +
+
+ + Returns: + ILFieldDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation of a value, immediate +

+
+ +
+
+ + name + + : + string +
+
+
+ + fieldType + + : + ILType +
+
+
+ + attributes + + : + FieldAttributes +
+
+
+ + data + + : + byte[] option +
+
+
+ + literalValue + + : + ILFieldInit option +
+
+
+ + offset + + : + int32 option +
+
+
+ + marshal + + : + ILNativeType option +
+
+
+ + customAttrs + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILFieldDef +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Access + + +

+ +
+
+ Full Usage: + this.Access +
+
+ + Returns: + ILMemberAccess + +
+
+
+
+ 		+
+
+ + Returns: + + ILMemberAccess +
+
+
+
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + FieldAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + FieldAttributes +
+
+
+
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.Data + + +

+ +
+
+ Full Usage: + this.Data +
+
+ + Returns: + byte[] option + +
+
+
+
+ 		+
+
+ + Returns: + + byte[] option +
+
+
+
+
+ +

+ + + this.FieldType + + +

+ +
+
+ Full Usage: + this.FieldType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+ +

+ + + this.IsInitOnly + + +

+ +
+
+ Full Usage: + this.IsInitOnly +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsLiteral + + +

+ +
+
+ Full Usage: + this.IsLiteral +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSpecialName + + +

+ +
+
+ Full Usage: + this.IsSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsStatic + + +

+ +
+
+ Full Usage: + this.IsStatic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.LiteralValue + + +

+ +
+
+ Full Usage: + this.LiteralValue +
+
+ + Returns: + ILFieldInit option + +
+
+
+
+ 		+
+
+ + Returns: + + ILFieldInit option +
+
+
+
+
+ +

+ + + this.Marshal + + +

+ +
+
+ Full Usage: + this.Marshal +
+
+ + Returns: + ILNativeType option + +
+
+
+
+ 		+
+
+ + Returns: + + ILNativeType option +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.NotSerialized + + +

+ +
+
+ Full Usage: + this.NotSerialized +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Offset + + +

+ +
+
+ Full Usage: + this.Offset +
+
+ + Returns: + int32 option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The explicit offset in bytes when explicit layout is used. +

+
+ +
+
+ + Returns: + + int32 option +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilfielddefs.html b/reference/fsharp-compiler-abstractil-il-ilfielddefs.html new file mode 100644 index 0000000000..10400e33a6 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilfielddefs.html @@ -0,0 +1,532 @@ + + + + + + + + + + + + + + + + + + ILFieldDefs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILFieldDefs Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Tables of fields. Logically equivalent to a list of fields but the table is kept in + a form to allow efficient looking up fields by name. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilfieldinit.html b/reference/fsharp-compiler-abstractil-il-ilfieldinit.html new file mode 100644 index 0000000000..a65142fb03 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilfieldinit.html @@ -0,0 +1,1269 @@ + + + + + + + + + + + + + + + + + + ILFieldInit (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILFieldInit Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILFieldInit> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Field Init +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Bool bool + + +

+ +
+
+ Full Usage: + Bool bool +
+
+ Parameters: +
    + + + Item + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + bool +
+
+
+
+
+ +

+ + + Char uint16 + + +

+ +
+
+ Full Usage: + Char uint16 +
+
+ Parameters: +
    + + + Item + + : + uint16 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint16 +
+
+
+
+
+ +

+ + + Double double + + +

+ +
+
+ Full Usage: + Double double +
+
+ Parameters: +
    + + + Item + + : + double + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + double +
+
+
+
+
+ +

+ + + Int16 int16 + + +

+ +
+
+ Full Usage: + Int16 int16 +
+
+ Parameters: +
    + + + Item + + : + int16 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int16 +
+
+
+
+
+ +

+ + + Int32 int32 + + +

+ +
+
+ Full Usage: + Int32 int32 +
+
+ Parameters: +
    + + + Item + + : + int32 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int32 +
+
+
+
+
+ +

+ + + Int64 int64 + + +

+ +
+
+ Full Usage: + Int64 int64 +
+
+ Parameters: +
    + + + Item + + : + int64 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int64 +
+
+
+
+
+ +

+ + + Int8 sbyte + + +

+ +
+
+ Full Usage: + Int8 sbyte +
+
+ Parameters: +
    + + + Item + + : + sbyte + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + sbyte +
+
+
+
+
+ +

+ + + Null + + +

+ +
+
+ Full Usage: + Null +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Single single + + +

+ +
+
+ Full Usage: + Single single +
+
+ Parameters: +
    + + + Item + + : + single + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + single +
+
+
+
+
+ +

+ + + String string + + +

+ +
+
+ Full Usage: + String string +
+
+ Parameters: +
    + + + Item + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + string +
+
+
+
+
+ +

+ + + UInt16 uint16 + + +

+ +
+
+ Full Usage: + UInt16 uint16 +
+
+ Parameters: +
    + + + Item + + : + uint16 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint16 +
+
+
+
+
+ +

+ + + UInt32 uint32 + + +

+ +
+
+ Full Usage: + UInt32 uint32 +
+
+ Parameters: +
    + + + Item + + : + uint32 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint32 +
+
+
+
+
+ +

+ + + UInt64 uint64 + + +

+ +
+
+ Full Usage: + UInt64 uint64 +
+
+ Parameters: +
    + + + Item + + : + uint64 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + uint64 +
+
+
+
+
+ +

+ + + UInt8 byte + + +

+ +
+
+ Full Usage: + UInt8 byte +
+
+ Parameters: +
    + + + Item + + : + byte + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + byte +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AsObject + + +

+ +
+
+ Full Usage: + this.AsObject +
+
+ + Returns: + obj + +
+
+
+
+ 		+
+
+ + Returns: + + obj +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilfieldref.html b/reference/fsharp-compiler-abstractil-il-ilfieldref.html new file mode 100644 index 0000000000..491077114b --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilfieldref.html @@ -0,0 +1,685 @@ + + + + + + + + + + + + + + + + + + ILFieldRef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILFieldRef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILFieldRef> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Formal identities of fields. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + DeclaringTypeRef + + +

+ +
+
+ Full Usage: + DeclaringTypeRef +
+
+ + Field type: + ILTypeRef + +
+
+
+
+ 		+
+
+ + Field type: + + ILTypeRef +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+ + Field type: + ILType + +
+
+
+
+ 		+
+
+ + Field type: + + ILType +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilfieldspec.html b/reference/fsharp-compiler-abstractil-il-ilfieldspec.html new file mode 100644 index 0000000000..316a3f36d4 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilfieldspec.html @@ -0,0 +1,820 @@ + + + + + + + + + + + + + + + + + + ILFieldSpec (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILFieldSpec Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILFieldSpec> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Field specs. The data given for a ldfld, stfld etc. instruction. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + DeclaringType + + +

+ +
+
+ Full Usage: + DeclaringType +
+
+ + Field type: + ILType + +
+
+
+
+ 		+
+
+ + Field type: + + ILType +
+
+
+
+
+ +

+ + + FieldRef + + +

+ +
+
+ Full Usage: + FieldRef +
+
+ + Field type: + ILFieldRef + +
+
+
+
+ 		+
+
+ + Field type: + + ILFieldRef +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ActualType + + +

+ +
+
+ Full Usage: + this.ActualType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+ +

+ + + this.DeclaringTypeRef + + +

+ +
+
+ Full Usage: + this.DeclaringTypeRef +
+
+ + Returns: + ILTypeRef + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeRef +
+
+
+
+
+ +

+ + + this.FormalType + + +

+ +
+
+ Full Usage: + this.FormalType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html b/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html new file mode 100644 index 0000000000..8575e4c23a --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilgenericparameterdef.html @@ -0,0 +1,1011 @@ + + + + + + + + + + + + + + + + + + ILGenericParameterDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILGenericParameterDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Generic parameters. Formal generic parameter declarations may include the bounds, if any, on the generic parameter. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Constraints + + +

+ +
+
+ Full Usage: + Constraints +
+
+ + Field type: + ILTypes + +
+
+
+
+ 		+
+ +
+ + + +

+ At most one is the parent type, the others are interface types. +

+
+ +
+
+ + Field type: + + ILTypes +
+
+
+
+
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+ +
+ + + +

+ Do not use this +

+
+ +
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+
+ +

+ + + HasDefaultConstructorConstraint + + +

+ +
+
+ Full Usage: + HasDefaultConstructorConstraint +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates the type argument must have a public nullary constructor. +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + HasNotNullableValueTypeConstraint + + +

+ +
+
+ Full Usage: + HasNotNullableValueTypeConstraint +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates the type argument must be a value type, but not Nullable. +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + HasReferenceTypeConstraint + + +

+ +
+
+ Full Usage: + HasReferenceTypeConstraint +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates the type argument must be a reference type. +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+ +
+ + + +

+ Do not use this +

+
+ +
+
+ + Field type: + + int32 +
+
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + Variance + + +

+ +
+
+ Full Usage: + Variance +
+
+ + Field type: + ILGenericVariance + +
+
+
+
+ 		+
+ +
+ + + +

+ Variance of type parameters, only applicable to generic parameters for generic interfaces and delegates. +

+
+ +
+
+ + Field type: + + ILGenericVariance +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html b/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html new file mode 100644 index 0000000000..2f91366a23 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilgenericvariance.html @@ -0,0 +1,667 @@ + + + + + + + + + + + + + + + + + + ILGenericVariance (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILGenericVariance Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILGenericVariance> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + CoVariant + + +

+ +
+
+ Full Usage: + CoVariant +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ContraVariant + + +

+ +
+
+ Full Usage: + ContraVariant +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NonVariant + + +

+ +
+
+ Full Usage: + NonVariant +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilguid.html b/reference/fsharp-compiler-abstractil-il-ilguid.html new file mode 100644 index 0000000000..49202dbc2e --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilguid.html @@ -0,0 +1,555 @@ + + + + + + + + + + + + + + + + + + ILGuid (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILGuid Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Abbreviation For: + byte[] +
+
+ Base Type: + Array +
+
+ All Interfaces: + IList + , + ICollection + , + IStructuralComparable + , + IStructuralEquatable + , + ICloneable + , + IList<byte> + , + ICollection<byte> + , + IEnumerable<byte> + , + IEnumerable +
+
+
+
+

+ Represents guids +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html b/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html new file mode 100644 index 0000000000..65606a0a89 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmemberaccess.html @@ -0,0 +1,799 @@ + + + + + + + + + + + + + + + + + + ILMemberAccess (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMemberAccess Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILMemberAccess> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Member Access +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Assembly + + +

+ +
+
+ Full Usage: + Assembly +
+
+
+
+
+ 		+
+ + + +

+ Assembly - Indicates that the method is accessible to any class of this assembly. (internal) +

+
+
+
+ +

+ + + CompilerControlled + + +

+ +
+
+ Full Usage: + CompilerControlled +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Family + + +

+ +
+
+ Full Usage: + Family +
+
+
+
+
+ 		+
+ + + +

+ Family - Indicates that the method is accessible only to members of this class and its derived classes. (protected) +

+
+
+
+ +

+ + + FamilyAndAssembly + + +

+ +
+
+ Full Usage: + FamilyAndAssembly +
+
+
+
+
+ 		+
+ + + +

+ FamilyAndAssembly - Indicates that the method is accessible to members of this type and its derived types that are in _this assembly only_. (private protected) +

+
+
+
+ +

+ + + FamilyOrAssembly + + +

+ +
+
+ Full Usage: + FamilyOrAssembly +
+
+
+
+
+ 		+
+ + + +

+ FamilyOrAssembly - Indicates that the method is accessible to derived classes anywhere, as well as to any class _in the assembly_. (protected internal) +

+
+
+
+ +

+ + + Private + + +

+ +
+
+ Full Usage: + Private +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Public + + +

+ +
+
+ Full Usage: + Public +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmethoddef.html b/reference/fsharp-compiler-abstractil-il-ilmethoddef.html new file mode 100644 index 0000000000..e355b08b59 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmethoddef.html @@ -0,0 +1,2597 @@ + + + + + + + + + + + + + + + + + + ILMethodDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMethodDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ IL Method definitions. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + ILMethodDef(name, attributes, implAttributes, callingConv, parameters, ret, body, isEntryPoint, genericParams, securityDecls, customAttrs) + + +

+ +
+
+ Full Usage: + ILMethodDef(name, attributes, implAttributes, callingConv, parameters, ret, body, isEntryPoint, genericParams, securityDecls, customAttrs) +
+
+ Parameters: + +
+ + Returns: + ILMethodDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation of a value, immediate +

+
+ +
+
+ + name + + : + string +
+
+
+ + attributes + + : + MethodAttributes +
+
+
+ + implAttributes + + : + MethodImplAttributes +
+
+
+ + callingConv + + : + ILCallingConv +
+
+
+ + parameters + + : + ILParameters +
+
+
+ + ret + + : + ILReturn +
+
+
+ + body + + : + InterruptibleLazy<MethodBody> +
+
+
+ + isEntryPoint + + : + bool +
+
+
+ + genericParams + + : + ILGenericParameterDefs +
+
+
+ + securityDecls + + : + ILSecurityDecls +
+
+
+ + customAttrs + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILMethodDef +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Access + + +

+ +
+
+ Full Usage: + this.Access +
+
+ + Returns: + ILMemberAccess + +
+
+
+
+ 		+
+
+ + Returns: + + ILMemberAccess +
+
+
+
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + MethodAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + MethodAttributes +
+
+
+
+
+ +

+ + + this.Body + + +

+ +
+
+ Full Usage: + this.Body +
+
+ + Returns: + MethodBody + +
+
+
+
+ 		+
+
+ + Returns: + + MethodBody +
+
+
+
+
+ +

+ + + this.CallingConv + + +

+ +
+
+ Full Usage: + this.CallingConv +
+
+ + Returns: + ILCallingConv + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingConv +
+
+
+
+
+ +

+ + + this.Code + + +

+ +
+
+ Full Usage: + this.Code +
+
+ + Returns: + ILCode option + +
+
+
+
+ 		+
+
+ + Returns: + + ILCode option +
+
+
+
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.GenericParams + + +

+ +
+
+ Full Usage: + this.GenericParams +
+
+ + Returns: + ILGenericParameterDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILGenericParameterDefs +
+
+
+
+
+ +

+ + + this.GetCallingSignature + + +

+ +
+
+ Full Usage: + this.GetCallingSignature +
+
+ + Returns: + ILCallingSignature + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingSignature +
+
+
+
+
+ +

+ + + this.HasSecurity + + +

+ +
+
+ Full Usage: + this.HasSecurity +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Some methods are marked "HasSecurity" even if there are no permissions attached, e.g. if they use SuppressUnmanagedCodeSecurityAttribute +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ImplAttributes + + +

+ +
+
+ Full Usage: + this.ImplAttributes +
+
+ + Returns: + MethodImplAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + MethodImplAttributes +
+
+
+
+
+ +

+ + + this.IsAbstract + + +

+ +
+
+ Full Usage: + this.IsAbstract +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsAggressiveInline + + +

+ +
+
+ Full Usage: + this.IsAggressiveInline +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsCheckAccessOnOverride + + +

+ +
+
+ Full Usage: + this.IsCheckAccessOnOverride +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsClassInitializer + + +

+ +
+
+ Full Usage: + this.IsClassInitializer +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a .cctor method. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsConstructor + + +

+ +
+
+ Full Usage: + this.IsConstructor +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a .ctor method. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEntryPoint + + +

+ +
+
+ Full Usage: + this.IsEntryPoint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsFinal + + +

+ +
+
+ Full Usage: + this.IsFinal +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsForwardRef + + +

+ +
+
+ Full Usage: + this.IsForwardRef +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsHideBySig + + +

+ +
+
+ Full Usage: + this.IsHideBySig +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsIL + + +

+ +
+
+ Full Usage: + this.IsIL +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsInternalCall + + +

+ +
+
+ Full Usage: + this.IsInternalCall +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsManaged + + +

+ +
+
+ Full Usage: + this.IsManaged +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsMustRun + + +

+ +
+
+ Full Usage: + this.IsMustRun +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ SafeHandle finalizer must be run. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsNewSlot + + +

+ +
+
+ Full Usage: + this.IsNewSlot +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsNoInline + + +

+ +
+
+ Full Usage: + this.IsNoInline +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsNonVirtualInstance + + +

+ +
+
+ Full Usage: + this.IsNonVirtualInstance +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates this is an instance methods that is not virtual. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPreserveSig + + +

+ +
+
+ Full Usage: + this.IsPreserveSig +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsReqSecObj + + +

+ +
+
+ Full Usage: + this.IsReqSecObj +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSpecialName + + +

+ +
+
+ Full Usage: + this.IsSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsStatic + + +

+ +
+
+ Full Usage: + this.IsStatic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a static method. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsSynchronized + + +

+ +
+
+ Full Usage: + this.IsSynchronized +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsUnmanagedExport + + +

+ +
+
+ Full Usage: + this.IsUnmanagedExport +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The method is exported to unmanaged code using COM interop. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsVirtual + + +

+ +
+
+ Full Usage: + this.IsVirtual +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates an instance methods that is virtual or abstract or implements an interface slot. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsZeroInit + + +

+ +
+
+ Full Usage: + this.IsZeroInit +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Locals + + +

+ +
+
+ Full Usage: + this.Locals +
+
+ + Returns: + ILLocals + +
+
+
+
+ 		+
+
+ + Returns: + + ILLocals +
+
+
+
+
+ +

+ + + this.MaxStack + + +

+ +
+
+ Full Usage: + this.MaxStack +
+
+ + Returns: + int32 + +
+
+
+
+ 		+
+
+ + Returns: + + int32 +
+
+
+
+
+ +

+ + + this.MethodBody + + +

+ +
+
+ Full Usage: + this.MethodBody +
+
+ + Returns: + ILMethodBody + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodBody +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.ParameterTypes + + +

+ +
+
+ Full Usage: + this.ParameterTypes +
+
+ + Returns: + ILTypes + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypes +
+
+
+
+
+ +

+ + + this.Parameters + + +

+ +
+
+ Full Usage: + this.Parameters +
+
+ + Returns: + ILParameters + +
+
+
+
+ 		+
+
+ + Returns: + + ILParameters +
+
+
+
+
+ +

+ + + this.Return + + +

+ +
+
+ Full Usage: + this.Return +
+
+ + Returns: + ILReturn + +
+
+
+
+ 		+
+
+ + Returns: + + ILReturn +
+
+
+
+
+ +

+ + + this.SecurityDecls + + +

+ +
+
+ Full Usage: + this.SecurityDecls +
+
+ + Returns: + ILSecurityDecls + +
+
+
+
+ 		+
+
+ + Returns: + + ILSecurityDecls +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html b/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html new file mode 100644 index 0000000000..ed0f11c0ac --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmethoddefs.html @@ -0,0 +1,782 @@ + + + + + + + + + + + + + + + + + + ILMethodDefs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMethodDefs Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + DelayInitArrayMap<ILMethodDef, string, ILMethodDef list> +
+
+ All Interfaces: + IEnumerable<ILMethodDef> + , + IEnumerable +
+
+
+
+

+ Tables of methods. Logically equivalent to a list of methods but + the table is kept in a form optimized for looking up methods by + name and arity. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AsArray + + +

+ +
+
+ Full Usage: + this.AsArray +
+
+ + Returns: + ILMethodDef[] + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodDef[] +
+
+
+
+
+ +

+ + + this.AsList + + +

+ +
+
+ Full Usage: + this.AsList +
+
+ + Returns: + ILMethodDef list + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodDef list +
+
+
+
+
+ +

+ + + this.FindByName + + +

+ +
+
+ Full Usage: + this.FindByName +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + ILMethodDef list + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + ILMethodDef list +
+
+
+
+
+ +

+ + + this.TryFindInstanceByNameAndCallingSignature + + +

+ +
+
+ Full Usage: + this.TryFindInstanceByNameAndCallingSignature +
+
+ Parameters: + +
+ + Returns: + ILMethodDef option + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+ + arg1 + + : + ILCallingSignature +
+
+
+
+
+ + Returns: + + ILMethodDef option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmethodimpldef.html b/reference/fsharp-compiler-abstractil-il-ilmethodimpldef.html new file mode 100644 index 0000000000..15a6640ccd --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmethodimpldef.html @@ -0,0 +1,646 @@ + + + + + + + + + + + + + + + + + + ILMethodImplDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMethodImplDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILMethodImplDef> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Method Impls +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + OverrideBy + + +

+ +
+
+ Full Usage: + OverrideBy +
+
+ + Field type: + ILMethodSpec + +
+
+
+
+ 		+
+
+ + Field type: + + ILMethodSpec +
+
+
+
+
+ +

+ + + Overrides + + +

+ +
+
+ Full Usage: + Overrides +
+
+ + Field type: + ILOverridesSpec + +
+
+
+
+ 		+
+
+ + Field type: + + ILOverridesSpec +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmethodimpldefs.html b/reference/fsharp-compiler-abstractil-il-ilmethodimpldefs.html new file mode 100644 index 0000000000..f0e3cfaa52 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmethodimpldefs.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILMethodImplDefs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMethodImplDefs Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmethodref.html b/reference/fsharp-compiler-abstractil-il-ilmethodref.html new file mode 100644 index 0000000000..5889f2c28e --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmethodref.html @@ -0,0 +1,1051 @@ + + + + + + + + + + + + + + + + + + ILMethodRef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMethodRef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IComparable +
+
+
+
+

+ Formal identities of methods. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ArgCount + + +

+ +
+
+ Full Usage: + this.ArgCount +
+
+ + Returns: + int + +
+
+
+
+ 		+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + this.ArgTypes + + +

+ +
+
+ Full Usage: + this.ArgTypes +
+
+ + Returns: + ILTypes + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypes +
+
+
+
+
+ +

+ + + this.CallingConv + + +

+ +
+
+ Full Usage: + this.CallingConv +
+
+ + Returns: + ILCallingConv + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingConv +
+
+
+
+
+ +

+ + + this.DeclaringTypeRef + + +

+ +
+
+ Full Usage: + this.DeclaringTypeRef +
+
+ + Returns: + ILTypeRef + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeRef +
+
+
+
+
+ +

+ + + this.GenericArity + + +

+ +
+
+ Full Usage: + this.GenericArity +
+
+ + Returns: + int + +
+
+
+
+ 		+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + this.GetCallingSignature + + +

+ +
+
+ Full Usage: + this.GetCallingSignature +
+
+ + Returns: + ILCallingSignature + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingSignature +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.ReturnType + + +

+ +
+
+ Full Usage: + this.ReturnType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILMethodRef.Create(enclosingTypeRef, callingConv, name, genericArity, argTypes, returnType) + + +

+ +
+
+ Full Usage: + ILMethodRef.Create(enclosingTypeRef, callingConv, name, genericArity, argTypes, returnType) +
+
+ Parameters: +
    + + + enclosingTypeRef + + : + ILTypeRef + +
    + + + callingConv + + : + ILCallingConv + +
    + + + name + + : + string + +
    + + + genericArity + + : + int + +
    + + + argTypes + + : + ILTypes + +
    + + + returnType + + : + ILType + +
    +
+
+ + Returns: + ILMethodRef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation +

+
+ +
+
+ + enclosingTypeRef + + : + ILTypeRef +
+
+
+ + callingConv + + : + ILCallingConv +
+
+
+ + name + + : + string +
+
+
+ + genericArity + + : + int +
+
+
+ + argTypes + + : + ILTypes +
+
+
+ + returnType + + : + ILType +
+
+
+
+
+ + Returns: + + ILMethodRef +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmethodspec.html b/reference/fsharp-compiler-abstractil-il-ilmethodspec.html new file mode 100644 index 0000000000..bbbe1f2486 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmethodspec.html @@ -0,0 +1,1003 @@ + + + + + + + + + + + + + + + + + + ILMethodSpec (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILMethodSpec Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IComparable +
+
+
+
+

+ The information at the callsite of a method +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CallingConv + + +

+ +
+
+ Full Usage: + this.CallingConv +
+
+ + Returns: + ILCallingConv + +
+
+
+
+ 		+
+
+ + Returns: + + ILCallingConv +
+
+
+
+
+ +

+ + + this.DeclaringType + + +

+ +
+
+ Full Usage: + this.DeclaringType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+ +

+ + + this.FormalArgTypes + + +

+ +
+
+ Full Usage: + this.FormalArgTypes +
+
+ + Returns: + ILTypes + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypes +
+
+
+
+
+ +

+ + + this.FormalReturnType + + +

+ +
+
+ Full Usage: + this.FormalReturnType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+ +

+ + + this.GenericArgs + + +

+ +
+
+ Full Usage: + this.GenericArgs +
+
+ + Returns: + ILGenericArgs + +
+
+
+
+ 		+
+
+ + Returns: + + ILGenericArgs +
+
+
+
+
+ +

+ + + this.GenericArity + + +

+ +
+
+ Full Usage: + this.GenericArity +
+
+ + Returns: + int + +
+
+
+
+ 		+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + this.MethodRef + + +

+ +
+
+ Full Usage: + this.MethodRef +
+
+ + Returns: + ILMethodRef + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILMethodSpec.Create(arg1, arg2, arg3) + + +

+ +
+
+ Full Usage: + ILMethodSpec.Create(arg1, arg2, arg3) +
+
+ Parameters: + +
+ + Returns: + ILMethodSpec + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation +

+
+ +
+
+ + arg0 + + : + ILType +
+
+
+ + arg1 + + : + ILMethodRef +
+
+
+ + arg2 + + : + ILGenericArgs +
+
+
+
+
+ + Returns: + + ILMethodSpec +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmoduledef.html b/reference/fsharp-compiler-abstractil-il-ilmoduledef.html new file mode 100644 index 0000000000..9ee2951ded --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmoduledef.html @@ -0,0 +1,1528 @@ + + + + + + + + + + + + + + + + + + ILModuleDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILModuleDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ One module in the "current" assembly, either a main-module or + an auxiliary module. The main module will have a manifest. + + An assembly is built by joining together a "main" module plus + several auxiliary modules. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+ +

+ + + ImageBase + + +

+ +
+
+ Full Usage: + ImageBase +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Is32Bit + + +

+ +
+
+ Full Usage: + Is32Bit +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Is32BitPreferred + + +

+ +
+
+ Full Usage: + Is32BitPreferred +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Is64Bit + + +

+ +
+
+ Full Usage: + Is64Bit +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + IsDLL + + +

+ +
+
+ Full Usage: + IsDLL +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + IsILOnly + + +

+ +
+
+ Full Usage: + IsILOnly +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Manifest + + +

+ +
+
+ Full Usage: + Manifest +
+
+ + Field type: + ILAssemblyManifest option + +
+
+
+
+ 		+
+
+ + Field type: + + ILAssemblyManifest option +
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + MetadataVersion + + +

+ +
+
+ Full Usage: + MetadataVersion +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + NativeResources + + +

+ +
+
+ Full Usage: + NativeResources +
+
+ + Field type: + ILNativeResource list + +
+
+
+
+ 		+
+ +
+ + + +

+ e.g. win86 resources, as the exact contents of a .res or .obj file. Must be unlinked manually. +

+
+ +
+
+ + Field type: + + ILNativeResource list +
+
+
+
+
+
+ +

+ + + PhysicalAlignment + + +

+ +
+
+ Full Usage: + PhysicalAlignment +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Platform + + +

+ +
+
+ Full Usage: + Platform +
+
+ + Field type: + ILPlatform option + +
+
+
+
+ 		+
+
+ + Field type: + + ILPlatform option +
+
+
+
+
+ +

+ + + Resources + + +

+ +
+
+ Full Usage: + Resources +
+
+ + Field type: + ILResources + +
+
+
+
+ 		+
+
+ + Field type: + + ILResources +
+
+
+
+
+ +

+ + + StackReserveSize + + +

+ +
+
+ Full Usage: + StackReserveSize +
+
+ + Field type: + int32 option + +
+
+
+
+ 		+
+
+ + Field type: + + int32 option +
+
+
+
+
+ +

+ + + SubSystemFlags + + +

+ +
+
+ Full Usage: + SubSystemFlags +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + SubsystemVersion + + +

+ +
+
+ Full Usage: + SubsystemVersion +
+
+ + Field type: + int * int + +
+
+
+
+ 		+
+
+ + Field type: + + int * int +
+
+
+
+
+ +

+ + + TypeDefs + + +

+ +
+
+ Full Usage: + TypeDefs +
+
+ + Field type: + ILTypeDefs + +
+
+
+
+ 		+
+
+ + Field type: + + ILTypeDefs +
+
+
+
+
+ +

+ + + UseHighEntropyVA + + +

+ +
+
+ Full Usage: + UseHighEntropyVA +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + VirtualAlignment + + +

+ +
+
+ Full Usage: + VirtualAlignment +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.HasManifest + + +

+ +
+
+ Full Usage: + this.HasManifest +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.ManifestOfAssembly + + +

+ +
+
+ Full Usage: + this.ManifestOfAssembly +
+
+ + Returns: + ILAssemblyManifest + +
+
+
+
+ 		+
+
+ + Returns: + + ILAssemblyManifest +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilmoduleref.html b/reference/fsharp-compiler-abstractil-il-ilmoduleref.html new file mode 100644 index 0000000000..6288af48e0 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilmoduleref.html @@ -0,0 +1,790 @@ + + + + + + + + + + + + + + + + + + ILModuleRef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILModuleRef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.HasMetadata + + +

+ +
+
+ Full Usage: + this.HasMetadata +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Hash + + +

+ +
+
+ Full Usage: + this.Hash +
+
+ + Returns: + byte[] option + +
+
+
+
+ 		+
+
+ + Returns: + + byte[] option +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILModuleRef.Create(name, hasMetadata, hash) + + +

+ +
+
+ Full Usage: + ILModuleRef.Create(name, hasMetadata, hash) +
+
+ Parameters: +
    + + + name + + : + string + +
    + + + hasMetadata + + : + bool + +
    + + + hash + + : + byte[] option + +
    +
+
+ + Returns: + ILModuleRef + +
+
+
+
+ 		+
+
+ + name + + : + string +
+
+
+ + hasMetadata + + : + bool +
+
+
+ + hash + + : + byte[] option +
+
+
+
+
+ + Returns: + + ILModuleRef +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilnativeresource.html b/reference/fsharp-compiler-abstractil-il-ilnativeresource.html new file mode 100644 index 0000000000..1b3a7b236d --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilnativeresource.html @@ -0,0 +1,541 @@ + + + + + + + + + + + + + + + + + + ILNativeResource (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILNativeResource Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILNativeResource> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilnativetype.html b/reference/fsharp-compiler-abstractil-il-ilnativetype.html new file mode 100644 index 0000000000..97aeef8b0e --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilnativetype.html @@ -0,0 +1,1986 @@ + + + + + + + + + + + + + + + + + + ILNativeType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILNativeType Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILNativeType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Native Types, for marshalling to the native C interface. + These are taken directly from the ILASM syntax. + Most of these are listed in the CLI ECMA-335 Spec (Partition II, 7.4). +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ANSIBSTR + + +

+ +
+
+ Full Usage: + ANSIBSTR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Array(ILNativeType option, (int32 * int32 option) option) + + +

+ +
+
+ Full Usage: + Array(ILNativeType option, (int32 * int32 option) option) +
+
+ Parameters: +
    + + + Item1 + + : + ILNativeType option + +
    + + + Item2 + + : + (int32 * int32 option) option + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ optional idx of parameter giving size plus optional additive i.e. num elems +

+
+ +
+
+ + Item1 + + : + ILNativeType option +
+
+
+ + Item2 + + : + (int32 * int32 option) option +
+
+
+
+
+
+ +

+ + + AsAny + + +

+ +
+
+ Full Usage: + AsAny +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + BSTR + + +

+ +
+
+ Full Usage: + BSTR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Bool + + +

+ +
+
+ Full Usage: + Bool +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ByValStr + + +

+ +
+
+ Full Usage: + ByValStr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Byte + + +

+ +
+
+ Full Usage: + Byte +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Currency + + +

+ +
+
+ Full Usage: + Currency +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Custom(ILGuid, nativeTypeName, custMarshallerName, cookieString) + + +

+ +
+
+ Full Usage: + Custom(ILGuid, nativeTypeName, custMarshallerName, cookieString) +
+
+ Parameters: +
    + + + Item1 + + : + ILGuid + +
    + + + nativeTypeName + + : + string + +
    + + + custMarshallerName + + : + string + +
    + + + cookieString + + : + byte[] + +
    +
+
+
+
+
+ 		+
+
+ + Item1 + + : + ILGuid +
+
+
+ + nativeTypeName + + : + string +
+
+
+ + custMarshallerName + + : + string +
+
+
+ + cookieString + + : + byte[] +
+
+
+
+
+ +

+ + + Double + + +

+ +
+
+ Full Usage: + Double +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Empty + + +

+ +
+
+ Full Usage: + Empty +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Error + + +

+ +
+
+ Full Usage: + Error +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + FixedArray int32 + + +

+ +
+
+ Full Usage: + FixedArray int32 +
+
+ Parameters: +
    + + + Item + + : + int32 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int32 +
+
+
+
+
+ +

+ + + FixedSysString int32 + + +

+ +
+
+ Full Usage: + FixedSysString int32 +
+
+ Parameters: +
    + + + Item + + : + int32 + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + int32 +
+
+
+
+
+ +

+ + + IDispatch + + +

+ +
+
+ Full Usage: + IDispatch +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + IUnknown + + +

+ +
+
+ Full Usage: + IUnknown +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int + + +

+ +
+
+ Full Usage: + Int +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int16 + + +

+ +
+
+ Full Usage: + Int16 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int32 + + +

+ +
+
+ Full Usage: + Int32 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int64 + + +

+ +
+
+ Full Usage: + Int64 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int8 + + +

+ +
+
+ Full Usage: + Int8 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LPSTR + + +

+ +
+
+ Full Usage: + LPSTR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LPSTRUCT + + +

+ +
+
+ Full Usage: + LPSTRUCT +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LPTSTR + + +

+ +
+
+ Full Usage: + LPTSTR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LPUTF8STR + + +

+ +
+
+ Full Usage: + LPUTF8STR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LPWSTR + + +

+ +
+
+ Full Usage: + LPWSTR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Method + + +

+ +
+
+ Full Usage: + Method +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SafeArray(ILNativeVariant, string option) + + +

+ +
+
+ Full Usage: + SafeArray(ILNativeVariant, string option) +
+
+ Parameters: +
    + + + Item1 + + : + ILNativeVariant + +
    + + + Item2 + + : + string option + +
    +
+
+
+
+
+ 		+
+
+ + Item1 + + : + ILNativeVariant +
+
+
+ + Item2 + + : + string option +
+
+
+
+
+ +

+ + + Single + + +

+ +
+
+ Full Usage: + Single +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Struct + + +

+ +
+
+ Full Usage: + Struct +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TBSTR + + +

+ +
+
+ Full Usage: + TBSTR +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt + + +

+ +
+
+ Full Usage: + UInt +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt16 + + +

+ +
+
+ Full Usage: + UInt16 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt32 + + +

+ +
+
+ Full Usage: + UInt32 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt64 + + +

+ +
+
+ Full Usage: + UInt64 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + VariantBool + + +

+ +
+
+ Full Usage: + VariantBool +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Void + + +

+ +
+
+ Full Usage: + Void +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html b/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html new file mode 100644 index 0000000000..b001abc572 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilnestedexportedtype.html @@ -0,0 +1,834 @@ + + + + + + + + + + + + + + + + + + ILNestedExportedType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILNestedExportedType Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ "Classes Elsewhere" - classes in auxiliary modules. + + Manifests include declarations for all the classes in an + assembly, regardless of which module they are in. + + The ".class extern" construct describes so-called exported types -- + these are public classes defined in the auxiliary modules of this assembly, + i.e. modules other than the manifest-carrying module. + + For example, if you have a two-module + assembly (A.DLL and B.DLL), and the manifest resides in the A.DLL, + then in the manifest all the public classes declared in B.DLL should + be defined as exported types, i.e., as ".class extern". The public classes + defined in A.DLL should not be defined as ".class extern" -- they are + already available in the manifest-carrying module. The union of all + public classes defined in the manifest-carrying module and all + exported types defined there is the set of all classes exposed by + this assembly. Thus, by analysing the metadata of the manifest-carrying + module of an assembly, you can identify all the classes exposed by + this assembly, and where to find them. + + Nested classes found in external modules should also be located in + this table, suitably nested inside another "ILExportedTypeOrForwarder" + definition. + these are only found in the "Nested" field of ILExportedTypeOrForwarder objects +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Access + + +

+ +
+
+ Full Usage: + Access +
+
+ + Field type: + ILMemberAccess + +
+
+
+
+ 		+
+
+ + Field type: + + ILMemberAccess +
+
+
+
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + Nested + + +

+ +
+
+ Full Usage: + Nested +
+
+ + Field type: + ILNestedExportedTypes + +
+
+
+
+ 		+
+
+ + Field type: + + ILNestedExportedTypes +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilnestedexportedtypes.html b/reference/fsharp-compiler-abstractil-il-ilnestedexportedtypes.html new file mode 100644 index 0000000000..bb1bb5eb51 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilnestedexportedtypes.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILNestedExportedTypes (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILNestedExportedTypes Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilparameter.html b/reference/fsharp-compiler-abstractil-il-ilparameter.html new file mode 100644 index 0000000000..6c96464706 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilparameter.html @@ -0,0 +1,978 @@ + + + + + + + + + + + + + + + + + + ILParameter (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILParameter Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Method parameters and return values. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+ +

+ + + Default + + +

+ +
+
+ Full Usage: + Default +
+
+ + Field type: + ILFieldInit option + +
+
+
+
+ 		+
+
+ + Field type: + + ILFieldInit option +
+
+
+
+
+ +

+ + + IsIn + + +

+ +
+
+ Full Usage: + IsIn +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + IsOptional + + +

+ +
+
+ Full Usage: + IsOptional +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + IsOut + + +

+ +
+
+ Full Usage: + IsOut +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Marshal + + +

+ +
+
+ Full Usage: + Marshal +
+
+ + Field type: + ILNativeType option + +
+
+
+
+ 		+
+ +
+ + + +

+ Marshalling map for parameters. COM Interop only. +

+
+ +
+
+ + Field type: + + ILNativeType option +
+
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string option + +
+
+
+
+ 		+
+
+ + Field type: + + string option +
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+ + Field type: + ILType + +
+
+
+
+ 		+
+
+ + Field type: + + ILType +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilplatform.html b/reference/fsharp-compiler-abstractil-il-ilplatform.html new file mode 100644 index 0000000000..5cb58aec5a --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilplatform.html @@ -0,0 +1,541 @@ + + + + + + + + + + + + + + + + + + ILPlatform (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILPlatform Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILPlatform> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilpretypedef.html b/reference/fsharp-compiler-abstractil-il-ilpretypedef.html new file mode 100644 index 0000000000..6efcfa9347 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilpretypedef.html @@ -0,0 +1,710 @@ + + + + + + + + + + + + + + + + + + ILPreTypeDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILPreTypeDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + ILPreTypeDef +
+
+
+
+

+ Represents a prefix of information for ILTypeDef. + + The information is enough to perform name resolution for the F# compiler, probe attributes + for ExtensionAttribute etc. This is key to the on-demand exploration of .NET metadata. + This information has to be "Goldilocks" - not too much, not too little, just right. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.GetTypeDef + + +

+ +
+
+ Full Usage: + this.GetTypeDef +
+
+ + Returns: + ILTypeDef + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Realise the actual full typedef +

+
+ +
+
+ + Returns: + + ILTypeDef +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.Namespace + + +

+ +
+
+ Full Usage: + this.Namespace +
+
+ + Returns: + string list + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + string list +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilpropertydef.html b/reference/fsharp-compiler-abstractil-il-ilpropertydef.html new file mode 100644 index 0000000000..4d48e5858b --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilpropertydef.html @@ -0,0 +1,1212 @@ + + + + + + + + + + + + + + + + + + ILPropertyDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILPropertyDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Property definitions +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + ILPropertyDef(name, attributes, setMethod, getMethod, callingConv, propertyType, init, args, customAttrs) + + +

+ +
+
+ Full Usage: + ILPropertyDef(name, attributes, setMethod, getMethod, callingConv, propertyType, init, args, customAttrs) +
+
+ Parameters: + +
+ + Returns: + ILPropertyDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation of a value, immediate +

+
+ +
+
+ + name + + : + string +
+
+
+ + attributes + + : + PropertyAttributes +
+
+
+ + setMethod + + : + ILMethodRef option +
+
+
+ + getMethod + + : + ILMethodRef option +
+
+
+ + callingConv + + : + ILThisConvention +
+
+
+ + propertyType + + : + ILType +
+
+
+ + init + + : + ILFieldInit option +
+
+
+ + args + + : + ILTypes +
+
+
+ + customAttrs + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILPropertyDef +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Args + + +

+ +
+
+ Full Usage: + this.Args +
+
+ + Returns: + ILTypes + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypes +
+
+
+
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + PropertyAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + PropertyAttributes +
+
+
+
+
+ +

+ + + this.CallingConv + + +

+ +
+
+ Full Usage: + this.CallingConv +
+
+ + Returns: + ILThisConvention + +
+
+
+
+ 		+
+
+ + Returns: + + ILThisConvention +
+
+
+
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.GetMethod + + +

+ +
+
+ Full Usage: + this.GetMethod +
+
+ + Returns: + ILMethodRef option + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef option +
+
+
+
+
+ +

+ + + this.Init + + +

+ +
+
+ Full Usage: + this.Init +
+
+ + Returns: + ILFieldInit option + +
+
+
+
+ 		+
+
+ + Returns: + + ILFieldInit option +
+
+
+
+
+ +

+ + + this.IsRTSpecialName + + +

+ +
+
+ Full Usage: + this.IsRTSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSpecialName + + +

+ +
+
+ Full Usage: + this.IsSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.PropertyType + + +

+ +
+
+ Full Usage: + this.PropertyType +
+
+ + Returns: + ILType + +
+
+
+
+ 		+
+
+ + Returns: + + ILType +
+
+
+
+
+ +

+ + + this.SetMethod + + +

+ +
+
+ Full Usage: + this.SetMethod +
+
+ + Returns: + ILMethodRef option + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodRef option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilpropertydefs.html b/reference/fsharp-compiler-abstractil-il-ilpropertydefs.html new file mode 100644 index 0000000000..700573c9c1 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilpropertydefs.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILPropertyDefs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILPropertyDefs Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Table of properties in an IL type definition. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilreferences.html b/reference/fsharp-compiler-abstractil-il-ilreferences.html new file mode 100644 index 0000000000..d515a76b90 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilreferences.html @@ -0,0 +1,763 @@ + + + + + + + + + + + + + + + + + + ILReferences (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILReferences Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILReferences> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AssemblyReferences + + +

+ +
+
+ Full Usage: + AssemblyReferences +
+
+ + Field type: + ILAssemblyRef[] + +
+
+
+
+ 		+
+
+ + Field type: + + ILAssemblyRef[] +
+
+
+
+
+ +

+ + + FieldReferences + + +

+ +
+
+ Full Usage: + FieldReferences +
+
+ + Field type: + ILFieldRef[] + +
+
+
+
+ 		+
+
+ + Field type: + + ILFieldRef[] +
+
+
+
+
+ +

+ + + MethodReferences + + +

+ +
+
+ Full Usage: + MethodReferences +
+
+ + Field type: + ILMethodRef[] + +
+
+
+
+ 		+
+
+ + Field type: + + ILMethodRef[] +
+
+
+
+
+ +

+ + + ModuleReferences + + +

+ +
+
+ Full Usage: + ModuleReferences +
+
+ + Field type: + ILModuleRef[] + +
+
+
+
+ 		+
+
+ + Field type: + + ILModuleRef[] +
+
+
+
+
+ +

+ + + TypeReferences + + +

+ +
+
+ Full Usage: + TypeReferences +
+
+ + Field type: + ILTypeRef[] + +
+
+
+
+ 		+
+
+ + Field type: + + ILTypeRef[] +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilresources.html b/reference/fsharp-compiler-abstractil-il-ilresources.html new file mode 100644 index 0000000000..ce611a9c9a --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilresources.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILResources (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILResources Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Table of resources in a module. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilreturn.html b/reference/fsharp-compiler-abstractil-il-ilreturn.html new file mode 100644 index 0000000000..93c0e0cdc8 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilreturn.html @@ -0,0 +1,832 @@ + + + + + + + + + + + + + + + + + + ILReturn (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILReturn Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Method return values. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CustomAttrsStored + + +

+ +
+
+ Full Usage: + CustomAttrsStored +
+
+ + Field type: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + Field type: + + ILAttributesStored +
+
+
+
+
+ +

+ + + Marshal + + +

+ +
+
+ Full Usage: + Marshal +
+
+ + Field type: + ILNativeType option + +
+
+
+
+ 		+
+
+ + Field type: + + ILNativeType option +
+
+
+
+
+ +

+ + + MetadataIndex + + +

+ +
+
+ Full Usage: + MetadataIndex +
+
+ + Field type: + int32 + +
+
+
+
+ 		+
+
+ + Field type: + + int32 +
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+ + Field type: + ILType + +
+
+
+
+ 		+
+
+ + Field type: + + ILType +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.WithCustomAttrs + + +

+ +
+
+ Full Usage: + this.WithCustomAttrs +
+
+ Parameters: + +
+ + Returns: + ILReturn + +
+
+
+
+ 		+
+
+ + customAttrs + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILReturn +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilscoperef.html b/reference/fsharp-compiler-abstractil-il-ilscoperef.html new file mode 100644 index 0000000000..48db117813 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilscoperef.html @@ -0,0 +1,848 @@ + + + + + + + + + + + + + + + + + + ILScopeRef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILScopeRef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILScopeRef> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Assembly ILAssemblyRef + + +

+ +
+
+ Full Usage: + Assembly ILAssemblyRef +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A reference to a type in another assembly +

+
+ +
+
+ + Item + + : + ILAssemblyRef +
+
+
+
+
+
+ +

+ + + Local + + +

+ +
+
+ Full Usage: + Local +
+
+
+
+
+ 		+
+ + + +

+ A reference to the type in the current module +

+
+
+
+ +

+ + + Module ILModuleRef + + +

+ +
+
+ Full Usage: + Module ILModuleRef +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A reference to a type in a module in the same assembly +

+
+ +
+
+ + Item + + : + ILModuleRef +
+
+
+
+
+
+ +

+ + + PrimaryAssembly + + +

+ +
+
+ Full Usage: + PrimaryAssembly +
+
+
+
+
+ 		+
+ + + +

+ A reference to a type in the primary assembly +

+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsLocalRef + + +

+ +
+
+ Full Usage: + this.IsLocalRef +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilsecuritydeclsstored.html b/reference/fsharp-compiler-abstractil-il-ilsecuritydeclsstored.html new file mode 100644 index 0000000000..3651951e47 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilsecuritydeclsstored.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + ILSecurityDeclsStored (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILSecurityDeclsStored Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the efficiency-oriented storage of ILSecurityDecls in another item. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html b/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html new file mode 100644 index 0000000000..287fb43d1e --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilsourcedocument.html @@ -0,0 +1,842 @@ + + + + + + + + + + + + + + + + + + ILSourceDocument (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILSourceDocument Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Debug info. Values of type "source" can be attached at sequence + points and some other locations. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DocumentType + + +

+ +
+
+ Full Usage: + this.DocumentType +
+
+ + Returns: + ILGuid option + +
+
+
+
+ 		+
+
+ + Returns: + + ILGuid option +
+
+
+
+
+ +

+ + + this.File + + +

+ +
+
+ Full Usage: + this.File +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.Language + + +

+ +
+
+ Full Usage: + this.Language +
+
+ + Returns: + ILGuid option + +
+
+
+
+ 		+
+
+ + Returns: + + ILGuid option +
+
+
+
+
+ +

+ + + this.Vendor + + +

+ +
+
+ Full Usage: + this.Vendor +
+
+ + Returns: + ILGuid option + +
+
+
+
+ 		+
+
+ + Returns: + + ILGuid option +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILSourceDocument.Create(language, vendor, documentType, file) + + +

+ +
+
+ Full Usage: + ILSourceDocument.Create(language, vendor, documentType, file) +
+
+ Parameters: +
    + + + language + + : + ILGuid option + +
    + + + vendor + + : + ILGuid option + +
    + + + documentType + + : + ILGuid option + +
    + + + file + + : + string + +
    +
+
+ + Returns: + ILSourceDocument + +
+
+
+
+ 		+
+
+ + language + + : + ILGuid option +
+
+
+ + vendor + + : + ILGuid option +
+
+
+ + documentType + + : + ILGuid option +
+
+
+ + file + + : + string +
+
+
+
+
+ + Returns: + + ILSourceDocument +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilthisconvention.html b/reference/fsharp-compiler-abstractil-il-ilthisconvention.html new file mode 100644 index 0000000000..897b3e7a20 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilthisconvention.html @@ -0,0 +1,667 @@ + + + + + + + + + + + + + + + + + + ILThisConvention (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILThisConvention Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILThisConvention> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Instance + + +

+ +
+
+ Full Usage: + Instance +
+
+
+
+
+ 		+
+ + + +

+ accepts an implicit 'this' pointer +

+
+
+
+ +

+ + + InstanceExplicit + + +

+ +
+
+ Full Usage: + InstanceExplicit +
+
+
+
+
+ 		+
+ + + +

+ accepts an explicit 'this' pointer +

+
+
+
+ +

+ + + Static + + +

+ +
+
+ Full Usage: + Static +
+
+
+
+
+ 		+
+ + + +

+ no 'this' pointer is passed +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltype.html b/reference/fsharp-compiler-abstractil-il-iltype.html new file mode 100644 index 0000000000..c1fe4d8b97 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltype.html @@ -0,0 +1,1412 @@ + + + + + + + + + + + + + + + + + + ILType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILType Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Array(ILArrayShape, ILType) + + +

+ +
+
+ Full Usage: + Array(ILArrayShape, ILType) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Array types +

+
+ +
+
+ + Item1 + + : + ILArrayShape +
+
+
+ + Item2 + + : + ILType +
+
+
+
+
+
+ +

+ + + Boxed ILTypeSpec + + +

+ +
+
+ Full Usage: + Boxed ILTypeSpec +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Reference types. Also may be used for parents of members even if for members in value types. +

+
+ +
+
+ + Item + + : + ILTypeSpec +
+
+
+
+
+
+ +

+ + + Byref ILType + + +

+ +
+
+ Full Usage: + Byref ILType +
+
+ Parameters: +
    + + + Item + + : + ILType + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Managed pointers. +

+
+ +
+
+ + Item + + : + ILType +
+
+
+
+
+
+ +

+ + + FunctionPointer ILCallingSignature + + +

+ +
+
+ Full Usage: + FunctionPointer ILCallingSignature +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ ILCode pointers. +

+
+ +
+
+ + Item + + : + ILCallingSignature +
+
+
+
+
+
+ +

+ + + Modified(bool, ILTypeRef, ILType) + + +

+ +
+
+ Full Usage: + Modified(bool, ILTypeRef, ILType) +
+
+ Parameters: +
    + + + Item1 + + : + bool + +
    + + + Item2 + + : + ILTypeRef + +
    + + + Item3 + + : + ILType + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Custom modifiers. +

+
+ +
+
+ + Item1 + + : + bool +
+
+
+ + Item2 + + : + ILTypeRef +
+
+
+ + Item3 + + : + ILType +
+
+
+
+
+
+ +

+ + + Ptr ILType + + +

+ +
+
+ Full Usage: + Ptr ILType +
+
+ Parameters: +
    + + + Item + + : + ILType + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Unmanaged pointers. Nb. the type is used by tools and for binding only, not by the verifier. +

+
+ +
+
+ + Item + + : + ILType +
+
+
+
+
+
+ +

+ + + TypeVar uint16 + + +

+ +
+
+ Full Usage: + TypeVar uint16 +
+
+ Parameters: +
    + + + Item + + : + uint16 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Reference a generic arg. +

+
+ +
+
+ + Item + + : + uint16 +
+
+
+
+
+
+ +

+ + + Value ILTypeSpec + + +

+ +
+
+ Full Usage: + Value ILTypeSpec +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Unboxed types, including builtin types. +

+
+ +
+
+ + Item + + : + ILTypeSpec +
+
+
+
+
+
+ +

+ + + Void + + +

+ +
+
+ Full Usage: + Void +
+
+
+
+
+ 		+
+ + + +

+ Used only in return and pointer types. +

+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.BasicQualifiedName + + +

+ +
+
+ Full Usage: + this.BasicQualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.GenericArgs + + +

+ +
+
+ Full Usage: + this.GenericArgs +
+
+ + Returns: + ILGenericArgs + +
+
+
+
+ 		+
+
+ + Returns: + + ILGenericArgs +
+
+
+
+
+ +

+ + + this.IsNominal + + +

+ +
+
+ Full Usage: + this.IsNominal +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsTyvar + + +

+ +
+
+ Full Usage: + this.IsTyvar +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.TypeRef + + +

+ +
+
+ Full Usage: + this.TypeRef +
+
+ + Returns: + ILTypeRef + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeRef +
+
+
+
+
+ +

+ + + this.TypeSpec + + +

+ +
+
+ Full Usage: + this.TypeSpec +
+
+ + Returns: + ILTypeSpec + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeSpec +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypedef.html b/reference/fsharp-compiler-abstractil-il-iltypedef.html new file mode 100644 index 0000000000..bda01977af --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypedef.html @@ -0,0 +1,2350 @@ + + + + + + + + + + + + + + + + + + ILTypeDef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeDef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+
+
+

+ Represents IL Type Definitions. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + ILTypeDef(name, attributes, layout, implements, genericParams, extends, methods, nestedTypes, fields, methodImpls, events, properties, isKnownToBeAttribute, securityDecls, customAttrs) + + +

+ +
+
+ Full Usage: + ILTypeDef(name, attributes, layout, implements, genericParams, extends, methods, nestedTypes, fields, methodImpls, events, properties, isKnownToBeAttribute, securityDecls, customAttrs) +
+
+ Parameters: + +
+ + Returns: + ILTypeDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional creation of a value, immediate +

+
+ +
+
+ + name + + : + string +
+
+
+ + attributes + + : + TypeAttributes +
+
+
+ + layout + + : + ILTypeDefLayout +
+
+
+ + implements + + : + ILTypes +
+
+
+ + genericParams + + : + ILGenericParameterDefs +
+
+
+ + extends + + : + ILType option +
+
+
+ + methods + + : + ILMethodDefs +
+
+
+ + nestedTypes + + : + ILTypeDefs +
+
+
+ + fields + + : + ILFieldDefs +
+
+
+ + methodImpls + + : + ILMethodImplDefs +
+
+
+ + events + + : + ILEventDefs +
+
+
+ + properties + + : + ILPropertyDefs +
+
+
+ + isKnownToBeAttribute + + : + bool +
+
+
+ + securityDecls + + : + ILSecurityDecls +
+
+
+ + customAttrs + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILTypeDef +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Access + + +

+ +
+
+ Full Usage: + this.Access +
+
+ + Returns: + ILTypeDefAccess + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeDefAccess +
+
+
+
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + TypeAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + TypeAttributes +
+
+
+
+
+ +

+ + + this.CustomAttrs + + +

+ +
+
+ Full Usage: + this.CustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + this.Encoding + + +

+ +
+
+ Full Usage: + this.Encoding +
+
+ + Returns: + ILDefaultPInvokeEncoding + +
+
+
+
+ 		+
+
+ + Returns: + + ILDefaultPInvokeEncoding +
+
+
+
+
+ +

+ + + this.Events + + +

+ +
+
+ Full Usage: + this.Events +
+
+ + Returns: + ILEventDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILEventDefs +
+
+
+
+
+ +

+ + + this.Extends + + +

+ +
+
+ Full Usage: + this.Extends +
+
+ + Returns: + ILType option + +
+
+
+
+ 		+
+
+ + Returns: + + ILType option +
+
+
+
+
+ +

+ + + this.Fields + + +

+ +
+
+ Full Usage: + this.Fields +
+
+ + Returns: + ILFieldDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILFieldDefs +
+
+
+
+
+ +

+ + + this.GenericParams + + +

+ +
+
+ Full Usage: + this.GenericParams +
+
+ + Returns: + ILGenericParameterDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILGenericParameterDefs +
+
+
+
+
+ +

+ + + this.HasSecurity + + +

+ +
+
+ Full Usage: + this.HasSecurity +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Some classes are marked "HasSecurity" even if there are no permissions attached, + e.g. if they use SuppressUnmanagedCodeSecurityAttribute +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Implements + + +

+ +
+
+ Full Usage: + this.Implements +
+
+ + Returns: + ILTypes + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypes +
+
+
+
+
+ +

+ + + this.IsAbstract + + +

+ +
+
+ Full Usage: + this.IsAbstract +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsClass + + +

+ +
+
+ Full Usage: + this.IsClass +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsComInterop + + +

+ +
+
+ Full Usage: + this.IsComInterop +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Class or interface generated for COM interop. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsDelegate + + +

+ +
+
+ Full Usage: + this.IsDelegate +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsEnum + + +

+ +
+
+ Full Usage: + this.IsEnum +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsInterface + + +

+ +
+
+ Full Usage: + this.IsInterface +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsKnownToBeAttribute + + +

+ +
+
+ Full Usage: + this.IsKnownToBeAttribute +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSealed + + +

+ +
+
+ Full Usage: + this.IsSealed +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSerializable + + +

+ +
+
+ Full Usage: + this.IsSerializable +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSpecialName + + +

+ +
+
+ Full Usage: + this.IsSpecialName +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsStruct + + +

+ +
+
+ Full Usage: + this.IsStruct +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsStructOrEnum + + +

+ +
+
+ Full Usage: + this.IsStructOrEnum +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Layout + + +

+ +
+
+ Full Usage: + this.Layout +
+
+ + Returns: + ILTypeDefLayout + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeDefLayout +
+
+
+
+
+ +

+ + + this.MethodImpls + + +

+ +
+
+ Full Usage: + this.MethodImpls +
+
+ + Returns: + ILMethodImplDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodImplDefs +
+
+
+
+
+ +

+ + + this.Methods + + +

+ +
+
+ Full Usage: + this.Methods +
+
+ + Returns: + ILMethodDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodDefs +
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.NestedTypes + + +

+ +
+
+ Full Usage: + this.NestedTypes +
+
+ + Returns: + ILTypeDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeDefs +
+
+
+
+
+ +

+ + + this.Properties + + +

+ +
+
+ Full Usage: + this.Properties +
+
+ + Returns: + ILPropertyDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILPropertyDefs +
+
+
+
+
+ +

+ + + this.SecurityDecls + + +

+ +
+
+ Full Usage: + this.SecurityDecls +
+
+ + Returns: + ILSecurityDecls + +
+
+
+
+ 		+
+
+ + Returns: + + ILSecurityDecls +
+
+
+
+
+ +

+ + + this.With + + +

+ +
+
+ Full Usage: + this.With +
+
+ Parameters: + +
+ + Returns: + ILTypeDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Functional update +

+
+ +
+
+ + ?name + + : + string +
+
+
+ + ?attributes + + : + TypeAttributes +
+
+
+ + ?layout + + : + ILTypeDefLayout +
+
+
+ + ?implements + + : + ILTypes +
+
+
+ + ?genericParams + + : + ILGenericParameterDefs +
+
+
+ + ?extends + + : + ILType option +
+
+
+ + ?methods + + : + ILMethodDefs +
+
+
+ + ?nestedTypes + + : + ILTypeDefs +
+
+
+ + ?fields + + : + ILFieldDefs +
+
+
+ + ?methodImpls + + : + ILMethodImplDefs +
+
+
+ + ?events + + : + ILEventDefs +
+
+
+ + ?properties + + : + ILPropertyDefs +
+
+
+ + ?isKnownToBeAttribute + + : + bool +
+
+
+ + ?customAttrs + + : + ILAttributes +
+
+
+ + ?securityDecls + + : + ILSecurityDecls +
+
+
+
+
+ + Returns: + + ILTypeDef +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html b/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html new file mode 100644 index 0000000000..db7c147af4 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypedefaccess.html @@ -0,0 +1,681 @@ + + + + + + + + + + + + + + + + + + ILTypeDefAccess (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeDefAccess Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILTypeDefAccess> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Type Access. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Nested ILMemberAccess + + +

+ +
+
+ Full Usage: + Nested ILMemberAccess +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + ILMemberAccess +
+
+
+
+
+ +

+ + + Private + + +

+ +
+
+ Full Usage: + Private +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Public + + +

+ +
+
+ Full Usage: + Public +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypedefkind.html b/reference/fsharp-compiler-abstractil-il-iltypedefkind.html new file mode 100644 index 0000000000..4562c919b3 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypedefkind.html @@ -0,0 +1,733 @@ + + + + + + + + + + + + + + + + + + ILTypeDefKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeDefKind Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILTypeDefKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ A categorization of type definitions into "kinds" +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Delegate + + +

+ +
+
+ Full Usage: + Delegate +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Enum + + +

+ +
+
+ Full Usage: + Enum +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ValueType + + +

+ +
+
+ Full Usage: + ValueType +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html b/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html new file mode 100644 index 0000000000..016fdfd380 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypedeflayout.html @@ -0,0 +1,695 @@ + + + + + + + + + + + + + + + + + + ILTypeDefLayout (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeDefLayout Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILTypeDefLayout> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Type Layout information. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Auto + + +

+ +
+
+ Full Usage: + Auto +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Explicit ILTypeDefLayoutInfo + + +

+ +
+
+ Full Usage: + Explicit ILTypeDefLayoutInfo +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + ILTypeDefLayoutInfo +
+
+
+
+
+ +

+ + + Sequential ILTypeDefLayoutInfo + + +

+ +
+
+ Full Usage: + Sequential ILTypeDefLayoutInfo +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + ILTypeDefLayoutInfo +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypedefs.html b/reference/fsharp-compiler-abstractil-il-iltypedefs.html new file mode 100644 index 0000000000..8704559c48 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypedefs.html @@ -0,0 +1,537 @@ + + + + + + + + + + + + + + + + + + ILTypeDefs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeDefs Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + DelayInitArrayMap<ILPreTypeDef, (string list * string), ILPreTypeDef> +
+
+ All Interfaces: + IEnumerable<ILTypeDef> + , + IEnumerable +
+
+
+
+

+ Tables of named type definitions. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypeinit.html b/reference/fsharp-compiler-abstractil-il-iltypeinit.html new file mode 100644 index 0000000000..6d91a2d822 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypeinit.html @@ -0,0 +1,634 @@ + + + + + + + + + + + + + + + + + + ILTypeInit (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeInit Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILTypeInit> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Indicate the initialization semantics of a type. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + BeforeField + + +

+ +
+
+ Full Usage: + BeforeField +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OnAny + + +

+ +
+
+ Full Usage: + OnAny +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltyperef.html b/reference/fsharp-compiler-abstractil-il-iltyperef.html new file mode 100644 index 0000000000..ff4d6771e4 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltyperef.html @@ -0,0 +1,1015 @@ + + + + + + + + + + + + + + + + + + ILTypeRef (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeRef Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IComparable +
+
+
+
+

+ Type refs, i.e. references to types in some .NET assembly +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.BasicQualifiedName + + +

+ +
+
+ Full Usage: + this.BasicQualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the type in the assembly using the '+' notation for nested types. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Enclosing + + +

+ +
+
+ Full Usage: + this.Enclosing +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The list of enclosing type names for a nested type. If non-nil then the first of these also contains the namespace. +

+
+ +
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + this.FullName + + +

+ +
+
+ Full Usage: + this.FullName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the type in the assembly using the '.' notation for nested types. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the type. This also contains the namespace if Enclosing is empty. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.Scope + + +

+ +
+
+ Full Usage: + this.Scope +
+
+ + Returns: + ILScopeRef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Where is the type, i.e. is it in this module, in another module in this assembly or in another assembly? +

+
+ +
+
+ + Returns: + + ILScopeRef +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILTypeRef.Create(scope, enclosing, name) + + +

+ +
+
+ Full Usage: + ILTypeRef.Create(scope, enclosing, name) +
+
+ Parameters: +
    + + + scope + + : + ILScopeRef + +
    + + + enclosing + + : + string list + +
    + + + name + + : + string + +
    +
+
+ + Returns: + ILTypeRef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a ILTypeRef. +

+
+ +
+
+ + scope + + : + ILScopeRef +
+
+
+ + enclosing + + : + string list +
+
+
+ + name + + : + string +
+
+
+
+
+ + Returns: + + ILTypeRef +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-iltypespec.html b/reference/fsharp-compiler-abstractil-il-iltypespec.html new file mode 100644 index 0000000000..64778ff779 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-iltypespec.html @@ -0,0 +1,1017 @@ + + + + + + + + + + + + + + + + + + ILTypeSpec (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILTypeSpec Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IComparable +
+
+
+
+

+ Type specs and types. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Enclosing + + +

+ +
+
+ Full Usage: + this.Enclosing +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The list of enclosing type names for a nested type. If non-nil then the first of these also contains the namespace. +

+
+ +
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + this.FullName + + +

+ +
+
+ Full Usage: + this.FullName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the type in the assembly using the '.' notation for nested types. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GenericArgs + + +

+ +
+
+ Full Usage: + this.GenericArgs +
+
+ + Returns: + ILGenericArgs + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The type instantiation if the type is generic, otherwise empty +

+
+ +
+
+ + Returns: + + ILGenericArgs +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the type. This also contains the namespace if Enclosing is empty. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Scope + + +

+ +
+
+ Full Usage: + this.Scope +
+
+ + Returns: + ILScopeRef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Where is the type, i.e. is it in this module, in another module in this assembly or in another assembly? +

+
+ +
+
+ + Returns: + + ILScopeRef +
+
+
+
+
+
+ +

+ + + this.TypeRef + + +

+ +
+
+ Full Usage: + this.TypeRef +
+
+ + Returns: + ILTypeRef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Which type is being referred to? +

+
+ +
+
+ + Returns: + + ILTypeRef +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ILTypeSpec.Create(typeRef, instantiation) + + +

+ +
+
+ Full Usage: + ILTypeSpec.Create(typeRef, instantiation) +
+
+ Parameters: + +
+ + Returns: + ILTypeSpec + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create an ILTypeSpec. +

+
+ +
+
+ + typeRef + + : + ILTypeRef +
+
+
+ + instantiation + + : + ILGenericArgs +
+
+
+
+
+ + Returns: + + ILTypeSpec +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-ilversioninfo.html b/reference/fsharp-compiler-abstractil-il-ilversioninfo.html new file mode 100644 index 0000000000..75e27b8a04 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-ilversioninfo.html @@ -0,0 +1,854 @@ + + + + + + + + + + + + + + + + + + ILVersionInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILVersionInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + ValueType +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ILVersionInfo> + , + IComparable + , + IStructuralComparable +
+
+ Kind: Struct +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Build + + +

+ +
+
+ Full Usage: + Build +
+
+ + Field type: + uint16 + +
+
+
+
+ 		+
+
+ + Field type: + + uint16 +
+
+
+
+
+ +

+ + + Major + + +

+ +
+
+ Full Usage: + Major +
+
+ + Field type: + uint16 + +
+
+
+
+ 		+
+
+ + Field type: + + uint16 +
+
+
+
+
+ +

+ + + Minor + + +

+ +
+
+ Full Usage: + Minor +
+
+ + Field type: + uint16 + +
+
+
+
+ 		+
+
+ + Field type: + + uint16 +
+
+
+
+
+ +

+ + + Revision + + +

+ +
+
+ Full Usage: + Revision +
+
+ + Field type: + uint16 + +
+
+
+
+ 		+
+
+ + Field type: + + uint16 +
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + ILVersionInfo(major, minor, build, revision) + + +

+ +
+
+ Full Usage: + ILVersionInfo(major, minor, build, revision) +
+
+ Parameters: +
    + + + major + + : + uint16 + +
    + + + minor + + : + uint16 + +
    + + + build + + : + uint16 + +
    + + + revision + + : + uint16 + +
    +
+
+ + Returns: + ILVersionInfo + +
+
+
+
+ 		+
+
+ + major + + : + uint16 +
+
+
+ + minor + + : + uint16 +
+
+
+ + build + + : + uint16 +
+
+
+ + revision + + : + uint16 +
+
+
+
+
+ + Returns: + + ILVersionInfo +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-methodbody.html b/reference/fsharp-compiler-abstractil-il-methodbody.html new file mode 100644 index 0000000000..37743a44bc --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-methodbody.html @@ -0,0 +1,755 @@ + + + + + + + + + + + + + + + + + + MethodBody (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ MethodBody Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Abstract + + +

+ +
+
+ Full Usage: + Abstract +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + IL InterruptibleLazy<ILMethodBody> + + +

+ +
+
+ Full Usage: + IL InterruptibleLazy<ILMethodBody> +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + InterruptibleLazy<ILMethodBody> +
+
+
+
+
+ +

+ + + Native + + +

+ +
+
+ Full Usage: + Native +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NotAvailable + + +

+ +
+
+ Full Usage: + NotAvailable +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + PInvoke Lazy<PInvokeMethod> + + +

+ +
+
+ Full Usage: + PInvoke Lazy<PInvokeMethod> +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + Lazy<PInvokeMethod> +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il-publickey.html b/reference/fsharp-compiler-abstractil-il-publickey.html new file mode 100644 index 0000000000..fbf0222a65 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il-publickey.html @@ -0,0 +1,915 @@ + + + + + + + + + + + + + + + + + + PublicKey (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ PublicKey Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + IL + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<PublicKey> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + PublicKey byte[] + + +

+ +
+
+ Full Usage: + PublicKey byte[] +
+
+ Parameters: +
    + + + Item + + : + byte[] + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + byte[] +
+
+
+
+
+ +

+ + + PublicKeyToken byte[] + + +

+ +
+
+ Full Usage: + PublicKeyToken byte[] +
+
+ Parameters: +
    + + + Item + + : + byte[] + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + byte[] +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsKey + + +

+ +
+
+ Full Usage: + this.IsKey +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsKeyToken + + +

+ +
+
+ Full Usage: + this.IsKeyToken +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Key + + +

+ +
+
+ Full Usage: + this.Key +
+
+ + Returns: + byte[] + +
+
+
+
+ 		+
+
+ + Returns: + + byte[] +
+
+
+
+
+ +

+ + + this.KeyToken + + +

+ +
+
+ Full Usage: + this.KeyToken +
+
+ + Returns: + byte[] + +
+
+
+
+ 		+
+
+ + Returns: + + byte[] +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + PublicKey.KeyAsToken(arg1) + + +

+ +
+
+ Full Usage: + PublicKey.KeyAsToken(arg1) +
+
+ Parameters: +
    + + + arg0 + + : + byte[] + +
    +
+
+ + Returns: + PublicKey + +
+
+
+
+ 		+
+
+ + arg0 + + : + byte[] +
+
+
+
+
+ + Returns: + + PublicKey +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-il.html b/reference/fsharp-compiler-abstractil-il.html new file mode 100644 index 0000000000..b5451f885f --- /dev/null +++ b/reference/fsharp-compiler-abstractil-il.html @@ -0,0 +1,4325 @@ + + + + + + + + + + + + + + + + + + IL (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IL Module +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ The "unlinked" view of .NET metadata and code. Central to the Abstract IL library +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + ILArgConvention + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILArrayShape + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILAssemblyLongevity + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILAssemblyManifest + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The main module of an assembly is a module plus some manifest information. +

+
+
+

+ + + ILAssemblyRef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILAttribElem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILAttribute + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Custom attribute. +

+
+
+

+ + + ILAttributes + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILAttributesStored + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the efficiency-oriented storage of ILAttributes in another item. +

+
+
+

+ + + ILCallingConv + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILCallingSignature + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILDebugImport + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Defines an opened namespace, type relevant to a code location. + + Emitted to the PortablePDB format. Note the format supports additional variations on + imported things that are not yet emitted in F#. +

+
+
+

+ + + ILDebugImports + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Defines a set of opened namespace, type relevant to a code location. + + Emitted to the PortablePDB format. +

+
+
+

+ + + ILDefaultPInvokeEncoding + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Default Unicode encoding for P/Invoke within a type. +

+
+
+

+ + + ILEventDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Event definitions. +

+
+
+

+ + + ILEventDefs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Table of those events in a type definition. +

+
+
+

+ + + ILExportedTypeOrForwarder + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ these are only found in the ILExportedTypesAndForwarders table in the manifest +

+
+
+

+ + + ILExportedTypesAndForwarders + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILFieldDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Field definitions. +

+
+
+

+ + + ILFieldDefs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Tables of fields. Logically equivalent to a list of fields but the table is kept in + a form to allow efficient looking up fields by name. +

+
+
+

+ + + ILFieldInit + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Field Init +

+
+
+

+ + + ILFieldRef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Formal identities of fields. +

+
+
+

+ + + ILFieldSpec + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Field specs. The data given for a ldfld, stfld etc. instruction. +

+
+
+

+ + + ILGenericParameterDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Generic parameters. Formal generic parameter declarations may include the bounds, if any, on the generic parameter. +

+
+
+

+ + + ILGenericVariance + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILGuid + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents guids +

+
+
+

+ + + ILMemberAccess + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Member Access +

+
+
+

+ + + ILMethodDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ IL Method definitions. +

+
+
+

+ + + ILMethodDefs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Tables of methods. Logically equivalent to a list of methods but + the table is kept in a form optimized for looking up methods by + name and arity. +

+
+
+

+ + + ILMethodImplDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Method Impls +

+
+
+

+ + + ILMethodImplDefs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILMethodRef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Formal identities of methods. +

+
+
+

+ + + ILMethodSpec + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The information at the callsite of a method +

+
+
+

+ + + ILModuleDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ One module in the "current" assembly, either a main-module or + an auxiliary module. The main module will have a manifest. + + An assembly is built by joining together a "main" module plus + several auxiliary modules. +

+
+
+

+ + + ILModuleRef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILNativeResource + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILNativeType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Native Types, for marshalling to the native C interface. + These are taken directly from the ILASM syntax. + Most of these are listed in the CLI ECMA-335 Spec (Partition II, 7.4). +

+
+
+

+ + + ILNestedExportedType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ "Classes Elsewhere" - classes in auxiliary modules. + + Manifests include declarations for all the classes in an + assembly, regardless of which module they are in. + + The ".class extern" construct describes so-called exported types -- + these are public classes defined in the auxiliary modules of this assembly, + i.e. modules other than the manifest-carrying module. + + For example, if you have a two-module + assembly (A.DLL and B.DLL), and the manifest resides in the A.DLL, + then in the manifest all the public classes declared in B.DLL should + be defined as exported types, i.e., as ".class extern". The public classes + defined in A.DLL should not be defined as ".class extern" -- they are + already available in the manifest-carrying module. The union of all + public classes defined in the manifest-carrying module and all + exported types defined there is the set of all classes exposed by + this assembly. Thus, by analysing the metadata of the manifest-carrying + module of an assembly, you can identify all the classes exposed by + this assembly, and where to find them. + + Nested classes found in external modules should also be located in + this table, suitably nested inside another "ILExportedTypeOrForwarder" + definition. + these are only found in the "Nested" field of ILExportedTypeOrForwarder objects +

+
+
+

+ + + ILNestedExportedTypes + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILParameter + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Method parameters and return values. +

+
+
+

+ + + ILPlatform + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILPreTypeDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a prefix of information for ILTypeDef. + + The information is enough to perform name resolution for the F# compiler, probe attributes + for ExtensionAttribute etc. This is key to the on-demand exploration of .NET metadata. + This information has to be "Goldilocks" - not too much, not too little, just right. +

+
+
+

+ + + ILPropertyDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Property definitions +

+
+
+

+ + + ILPropertyDefs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Table of properties in an IL type definition. +

+
+
+

+ + + ILReferences + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILResources + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Table of resources in a module. +

+
+
+

+ + + ILReturn + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Method return values. +

+
+
+

+ + + ILScopeRef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILSecurityDeclsStored + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the efficiency-oriented storage of ILSecurityDecls in another item. +

+
+
+

+ + + ILSourceDocument + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Debug info. Values of type "source" can be attached at sequence + points and some other locations. +

+
+
+

+ + + ILThisConvention + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILTypeDef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents IL Type Definitions. +

+
+
+

+ + + ILTypeDefAccess + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Type Access. +

+
+
+

+ + + ILTypeDefKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A categorization of type definitions into "kinds" +

+
+
+

+ + + ILTypeDefLayout + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Type Layout information. +

+
+
+

+ + + ILTypeDefs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Tables of named type definitions. +

+
+
+

+ + + ILTypeInit + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicate the initialization semantics of a type. +

+
+
+

+ + + ILTypeRef + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Type refs, i.e. references to types in some .NET assembly +

+
+
+

+ + + ILTypeSpec + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Type specs and types. +

+
+
+

+ + + ILVersionInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + MethodBody + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + PublicKey + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + NoMetadataIdx + + +

+ +
+
+ Full Usage: + NoMetadataIdx +
+
+ + Returns: + int32 + +
+
+
+
+ 		+
+
+ + Returns: + + int32 +
+
+
+
+
+ +

+ + + emptyILCustomAttrs + + +

+ +
+
+ Full Usage: + emptyILCustomAttrs +
+
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + emptyILEvents + + +

+ +
+
+ Full Usage: + emptyILEvents +
+
+ + Returns: + ILEventDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILEventDefs +
+
+
+
+
+ +

+ + + emptyILFields + + +

+ +
+
+ Full Usage: + emptyILFields +
+
+ + Returns: + ILFieldDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILFieldDefs +
+
+
+
+
+ +

+ + + emptyILMethodImpls + + +

+ +
+
+ Full Usage: + emptyILMethodImpls +
+
+ + Returns: + ILMethodImplDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodImplDefs +
+
+
+
+
+ +

+ + + emptyILMethods + + +

+ +
+
+ Full Usage: + emptyILMethods +
+
+ + Returns: + ILMethodDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILMethodDefs +
+
+
+
+
+ +

+ + + emptyILProperties + + +

+ +
+
+ Full Usage: + emptyILProperties +
+
+ + Returns: + ILPropertyDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILPropertyDefs +
+
+
+
+
+ +

+ + + emptyILResources + + +

+ +
+
+ Full Usage: + emptyILResources +
+
+ + Returns: + ILResources + +
+
+
+
+ 		+
+
+ + Returns: + + ILResources +
+
+
+
+
+ +

+ + + emptyILSecurityDecls + + +

+ +
+
+ Full Usage: + emptyILSecurityDecls +
+
+ + Returns: + ILSecurityDecls + +
+
+
+
+ 		+
+
+ + Returns: + + ILSecurityDecls +
+
+
+
+
+ +

+ + + emptyILTypeDefs + + +

+ +
+
+ Full Usage: + emptyILTypeDefs +
+
+ + Returns: + ILTypeDefs + +
+
+
+
+ 		+
+
+ + Returns: + + ILTypeDefs +
+
+
+
+
+ +

+ + + mkILCustomAttrs arg1 + + +

+ +
+
+ Full Usage: + mkILCustomAttrs arg1 +
+
+ Parameters: + +
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Making tables of custom attributes, etc. +

+
+ +
+
+ + arg0 + + : + ILAttribute list +
+
+
+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+
+ +

+ + + mkILCustomAttrsFromArray arg1 + + +

+ +
+
+ Full Usage: + mkILCustomAttrsFromArray arg1 +
+
+ Parameters: + +
+ + Returns: + ILAttributes + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILAttribute[] +
+
+
+
+
+ + Returns: + + ILAttributes +
+
+
+
+
+ +

+ + + mkILEvents arg1 + + +

+ +
+
+ Full Usage: + mkILEvents arg1 +
+
+ Parameters: + +
+ + Returns: + ILEventDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILEventDef list +
+
+
+
+
+ + Returns: + + ILEventDefs +
+
+
+
+
+ +

+ + + mkILEventsLazy arg1 + + +

+ +
+
+ Full Usage: + mkILEventsLazy arg1 +
+
+ Parameters: + +
+ + Returns: + ILEventDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + InterruptibleLazy<ILEventDef list> +
+
+
+
+
+ + Returns: + + ILEventDefs +
+
+
+
+
+ +

+ + + mkILExportedTypes arg1 + + +

+ +
+
+ Full Usage: + mkILExportedTypes arg1 +
+
+ Parameters: + +
+ + Returns: + ILExportedTypesAndForwarders + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILExportedTypeOrForwarder list +
+
+
+
+
+ + Returns: + + ILExportedTypesAndForwarders +
+
+
+
+
+ +

+ + + mkILFields arg1 + + +

+ +
+
+ Full Usage: + mkILFields arg1 +
+
+ Parameters: + +
+ + Returns: + ILFieldDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILFieldDef list +
+
+
+
+
+ + Returns: + + ILFieldDefs +
+
+
+
+
+ +

+ + + mkILFieldsLazy arg1 + + +

+ +
+
+ Full Usage: + mkILFieldsLazy arg1 +
+
+ Parameters: + +
+ + Returns: + ILFieldDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + InterruptibleLazy<ILFieldDef list> +
+
+
+
+
+ + Returns: + + ILFieldDefs +
+
+
+
+
+ +

+ + + mkILMethodImpls arg1 + + +

+ +
+
+ Full Usage: + mkILMethodImpls arg1 +
+
+ Parameters: + +
+ + Returns: + ILMethodImplDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILMethodImplDef list +
+
+
+
+
+ + Returns: + + ILMethodImplDefs +
+
+
+
+
+ +

+ + + mkILMethodImplsLazy arg1 + + +

+ +
+
+ Full Usage: + mkILMethodImplsLazy arg1 +
+
+ Parameters: + +
+ + Returns: + ILMethodImplDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + Lazy<ILMethodImplDef list> +
+
+
+
+
+ + Returns: + + ILMethodImplDefs +
+
+
+
+
+ +

+ + + mkILMethods arg1 + + +

+ +
+
+ Full Usage: + mkILMethods arg1 +
+
+ Parameters: + +
+ + Returns: + ILMethodDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILMethodDef list +
+
+
+
+
+ + Returns: + + ILMethodDefs +
+
+
+
+
+ +

+ + + mkILMethodsComputed arg1 + + +

+ +
+
+ Full Usage: + mkILMethodsComputed arg1 +
+
+ Parameters: + +
+ + Returns: + ILMethodDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + unit -> ILMethodDef[] +
+
+
+
+
+ + Returns: + + ILMethodDefs +
+
+
+
+
+ +

+ + + mkILMethodsFromArray arg1 + + +

+ +
+
+ Full Usage: + mkILMethodsFromArray arg1 +
+
+ Parameters: + +
+ + Returns: + ILMethodDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILMethodDef[] +
+
+
+
+
+ + Returns: + + ILMethodDefs +
+
+
+
+
+ +

+ + + mkILNestedExportedTypes arg1 + + +

+ +
+
+ Full Usage: + mkILNestedExportedTypes arg1 +
+
+ Parameters: + +
+ + Returns: + ILNestedExportedTypes + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILNestedExportedType list +
+
+
+
+
+ + Returns: + + ILNestedExportedTypes +
+
+
+
+
+ +

+ + + mkILProperties arg1 + + +

+ +
+
+ Full Usage: + mkILProperties arg1 +
+
+ Parameters: + +
+ + Returns: + ILPropertyDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILPropertyDef list +
+
+
+
+
+ + Returns: + + ILPropertyDefs +
+
+
+
+
+ +

+ + + mkILPropertiesLazy arg1 + + +

+ +
+
+ Full Usage: + mkILPropertiesLazy arg1 +
+
+ Parameters: + +
+ + Returns: + ILPropertyDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + InterruptibleLazy<ILPropertyDef list> +
+
+
+
+
+ + Returns: + + ILPropertyDefs +
+
+
+
+
+ +

+ + + mkILReturn arg1 + + +

+ +
+
+ Full Usage: + mkILReturn arg1 +
+
+ Parameters: +
    + + + arg0 + + : + ILType + +
    +
+
+ + Returns: + ILReturn + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILType +
+
+
+
+
+ + Returns: + + ILReturn +
+
+
+
+
+ +

+ + + mkILSecurityDecls arg1 + + +

+ +
+
+ Full Usage: + mkILSecurityDecls arg1 +
+
+ Parameters: + +
+ + Returns: + ILSecurityDecls + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILSecurityDecl list +
+
+
+
+
+ + Returns: + + ILSecurityDecls +
+
+
+
+
+ +

+ + + mkILSimpleModule assemblyName moduleName dll subsystemVersion useHighEntropyVA arg6 arg7 arg8 arg9 arg10 arg11 + + +

+ +
+
+ Full Usage: + mkILSimpleModule assemblyName moduleName dll subsystemVersion useHighEntropyVA arg6 arg7 arg8 arg9 arg10 arg11 +
+
+ Parameters: +
    + + + assemblyName + + : + string + +
    + + + moduleName + + : + string + +
    + + + dll + + : + bool + +
    + + + subsystemVersion + + : + int * int + +
    + + + useHighEntropyVA + + : + bool + +
    + + + arg5 + + : + ILTypeDefs + +
    + + + arg6 + + : + int32 option + +
    + + + arg7 + + : + string option + +
    + + + arg8 + + : + int + +
    + + + arg9 + + : + ILExportedTypesAndForwarders + +
    + + + arg10 + + : + string + +
    +
+
+ + Returns: + ILModuleDef + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Making modules. +

+
+ +
+
+ + assemblyName + + : + string +
+
+
+ + moduleName + + : + string +
+
+
+ + dll + + : + bool +
+
+
+ + subsystemVersion + + : + int * int +
+
+
+ + useHighEntropyVA + + : + bool +
+
+
+ + arg5 + + : + ILTypeDefs +
+
+
+ + arg6 + + : + int32 option +
+
+
+ + arg7 + + : + string option +
+
+
+ + arg8 + + : + int +
+
+
+ + arg9 + + : + ILExportedTypesAndForwarders +
+
+
+ + arg10 + + : + string +
+
+
+
+
+ + Returns: + + ILModuleDef +
+
+
+
+
+
+ +

+ + + mkILTypeDefs arg1 + + +

+ +
+
+ Full Usage: + mkILTypeDefs arg1 +
+
+ Parameters: + +
+ + Returns: + ILTypeDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILTypeDef list +
+
+
+
+
+ + Returns: + + ILTypeDefs +
+
+
+
+
+ +

+ + + mkILTypeDefsComputed arg1 + + +

+ +
+
+ Full Usage: + mkILTypeDefsComputed arg1 +
+
+ Parameters: + +
+ + Returns: + ILTypeDefs + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create table of types which is loaded/computed on-demand, and whose individual + elements are also loaded/computed on-demand. Any call to tdefs.AsList will + result in the laziness being forced. Operations can examine the + custom attributes and name of each type in order to decide whether + to proceed with examining the other details of the type. + + Note that individual type definitions may contain further delays + in their method, field and other tables. +

+
+ +
+
+ + arg0 + + : + unit -> ILPreTypeDef[] +
+
+
+
+
+ + Returns: + + ILTypeDefs +
+
+
+
+
+
+ +

+ + + mkILTypeDefsFromArray arg1 + + +

+ +
+
+ Full Usage: + mkILTypeDefsFromArray arg1 +
+
+ Parameters: + +
+ + Returns: + ILTypeDefs + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILTypeDef[] +
+
+
+
+
+ + Returns: + + ILTypeDefs +
+
+
+
+
+ +

+ + + storeILCustomAttrs arg1 + + +

+ +
+
+ Full Usage: + storeILCustomAttrs arg1 +
+
+ Parameters: + +
+ + Returns: + ILAttributesStored + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILAttributes +
+
+
+
+
+ + Returns: + + ILAttributesStored +
+
+
+
+
+ +

+ + + storeILSecurityDecls arg1 + + +

+ +
+
+ Full Usage: + storeILSecurityDecls arg1 +
+
+ Parameters: + +
+ + Returns: + ILSecurityDeclsStored + +
+
+
+
+ 		+
+
+ + arg0 + + : + ILSecurityDecls +
+
+
+
+
+ + Returns: + + ILSecurityDeclsStored +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-ilmodulereader.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-ilmodulereader.html new file mode 100644 index 0000000000..18165d1172 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-ilmodulereader.html @@ -0,0 +1,649 @@ + + + + + + + + + + + + + + + + + + ILModuleReader (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILModuleReader Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ILBinaryReader + +
+
+ Base Type: + obj +
+
+ All Interfaces: + ILModuleReader + , + IDisposable +
+
+
+
+

+ Represents a reader of the metadata of a .NET binary. May also give some values (e.g. IL code) from the PE file + if it was provided. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ILAssemblyRefs + + +

+ +
+
+ Full Usage: + this.ILAssemblyRefs +
+
+ + Returns: + ILAssemblyRef list + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + ILAssemblyRef list +
+
+
+
+
+ +

+ + + this.ILModuleDef + + +

+ +
+
+ Full Usage: + this.ILModuleDef +
+
+ + Returns: + ILModuleDef + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + ILModuleDef +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html new file mode 100644 index 0000000000..2cddd0e679 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreaderoptions.html @@ -0,0 +1,743 @@ + + + + + + + + + + + + + + + + + + ILReaderOptions (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILReaderOptions Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ILBinaryReader + +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + metadataOnly + + +

+ +
+
+ Full Usage: + metadataOnly +
+
+ + Field type: + MetadataOnlyFlag + +
+
+
+
+ 		+
+ +
+ + + +

+ Only open a metadata reader for the metadata portion of the .NET binary without keeping alive any data associated with the PE reader + - IL code will not be available (mdBody in ILMethodDef will return NotAvailable) + - Managed resources will be reported back as ILResourceLocation.LocalIn (as always) + - Native resources will not be available (none will be returned) + - Static data associated with fields will not be available +

+
+ +
+
+ + Field type: + + MetadataOnlyFlag +
+
+
+
+
+
+ +

+ + + pdbDirPath + + +

+ +
+
+ Full Usage: + pdbDirPath +
+
+ + Field type: + string option + +
+
+
+
+ 		+
+
+ + Field type: + + string option +
+
+
+
+
+ +

+ + + reduceMemoryUsage + + +

+ +
+
+ Full Usage: + reduceMemoryUsage +
+
+ + Field type: + ReduceMemoryFlag + +
+
+
+
+ 		+
+
+ + Field type: + + ReduceMemoryFlag +
+
+
+
+
+ +

+ + + tryGetMetadataSnapshot + + +

+ +
+
+ Full Usage: + tryGetMetadataSnapshot +
+
+ + Field type: + ILReaderTryGetMetadataSnapshot + +
+
+
+
+ 		+
+ +
+ + + +

+ A function to call to try to get an object that acts as a snapshot of the metadata section of a .NET binary, + and from which we can read the metadata. Only used when metadataOnly=true. +

+
+ +
+
+ + Field type: + + ILReaderTryGetMetadataSnapshot +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreadertrygetmetadatasnapshot.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreadertrygetmetadatasnapshot.html new file mode 100644 index 0000000000..d4f2a8889c --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-ilreadertrygetmetadatasnapshot.html @@ -0,0 +1,535 @@ + + + + + + + + + + + + + + + + + + ILReaderTryGetMetadataSnapshot (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILReaderTryGetMetadataSnapshot Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ILBinaryReader + +
+
+ Abbreviation For: + string * DateTime -> ILReaderMetadataSnapshot option +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-metadataonlyflag.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-metadataonlyflag.html new file mode 100644 index 0000000000..8d608e338b --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-metadataonlyflag.html @@ -0,0 +1,634 @@ + + + + + + + + + + + + + + + + + + MetadataOnlyFlag (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ MetadataOnlyFlag Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ILBinaryReader + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<MetadataOnlyFlag> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes + + +

+ +
+
+ Full Usage: + Yes +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-reducememoryflag.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-reducememoryflag.html new file mode 100644 index 0000000000..af03c92194 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-reducememoryflag.html @@ -0,0 +1,634 @@ + + + + + + + + + + + + + + + + + + ReduceMemoryFlag (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ReduceMemoryFlag Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ILBinaryReader + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ReduceMemoryFlag> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes + + +

+ +
+
+ Full Usage: + Yes +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-shim-iassemblyreader.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-shim-iassemblyreader.html new file mode 100644 index 0000000000..6d9ff97cdc --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-shim-iassemblyreader.html @@ -0,0 +1,642 @@ + + + + + + + + + + + + + + + + + + IAssemblyReader (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IAssemblyReader Type +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shim + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IAssemblyReader +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.GetILModuleReader + + +

+ +
+
+ Full Usage: + this.GetILModuleReader +
+
+ Parameters: +
    + + + fileName + + : + string + +
    + + + readerOptions + + : + ILReaderOptions + +
    +
+
+ + Returns: + ILModuleReader + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+ + readerOptions + + : + ILReaderOptions +
+
+
+
+
+ + Returns: + + ILModuleReader +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader-shim.html b/reference/fsharp-compiler-abstractil-ilbinaryreader-shim.html new file mode 100644 index 0000000000..b6f739edbf --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader-shim.html @@ -0,0 +1,639 @@ + + + + + + + + + + + + + + + + + + Shim (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Shim Module +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ILBinaryReader + +
+
+
+
+

+ The public API hook for changing the IL assembly reader, used by Resharper +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + IAssemblyReader + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + AssemblyReader + + +

+ +
+
+ Full Usage: + AssemblyReader +
+
+ + Returns: + IAssemblyReader + +
+
+
+
+ 		+
+
+ + Returns: + + IAssemblyReader +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil-ilbinaryreader.html b/reference/fsharp-compiler-abstractil-ilbinaryreader.html new file mode 100644 index 0000000000..e6978c30c7 --- /dev/null +++ b/reference/fsharp-compiler-abstractil-ilbinaryreader.html @@ -0,0 +1,724 @@ + + + + + + + + + + + + + + + + + + ILBinaryReader (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILBinaryReader Module +

+
+
+ Namespace: + + FSharp.Compiler.AbstractIL + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+ 
 Binary reader.  Read a .NET binary and concert it to Abstract IL data
+ structures.
+ 
+ NOTE:
+   - The metadata in the loaded modules will be relative to 
+     those modules, e.g. ILScopeRef.Local will mean "local to 
+     that module".  You must use [rescopeILType] etc. if you want to include 
+     (i.e. copy) the metadata into your own module. 
+
+   - PDB (debug info) reading/folding:
+     The PDB reader is invoked if you give a PDB path 
+     This indicates if you want to search for PDB files and have the 
+     reader fold them in.  You cannot currently name the pdb file 
+     directly - you can only name the path.  Giving "None" says 
+     "do not read the PDB file even if one exists". 
+ 
+     The debug info appears primarily as I_seqpoint annotations in 
+     the instruction streams.  Unfortunately the PDB information does
+     not, for example, tell you how to map back from a class definition
+     to a source code line number - you will need to explicitly search
+     for a sequence point in the code for one of the methods of the 
+     class.  That is not particularly satisfactory, and it may be
+     a good idea to build a small library which extracts the information
+     you need.
+
+
+
+

+ Types and nested modules +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + Shim + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The public API hook for changing the IL assembly reader, used by Resharper +

+
+
+

+ + + ILModuleReader + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a reader of the metadata of a .NET binary. May also give some values (e.g. IL code) from the PE file + if it was provided. +

+
+
+

+ + + ILReaderOptions + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ILReaderTryGetMetadataSnapshot + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + MetadataOnlyFlag + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ReduceMemoryFlag + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-abstractil.html b/reference/fsharp-compiler-abstractil.html new file mode 100644 index 0000000000..fa14ee677f --- /dev/null +++ b/reference/fsharp-compiler-abstractil.html @@ -0,0 +1,593 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.AbstractIL | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.AbstractIL Namespace +

+
+ + + + + + + + + + + + + + + + + +
+ Modules + + Description +
+

+ + + IL + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The "unlinked" view of .NET metadata and code. Central to the Abstract IL library +

+
+
+

+ + + ILBinaryReader + + +

+ 		+
+
+ +
+
+ +
+ + + + 
 Binary reader.  Read a .NET binary and concert it to Abstract IL data
+ structures.
+ 
+ NOTE:
+   - The metadata in the loaded modules will be relative to 
+     those modules, e.g. ILScopeRef.Local will mean "local to 
+     that module".  You must use [rescopeILType] etc. if you want to include 
+     (i.e. copy) the metadata into your own module. 
+
+   - PDB (debug info) reading/folding:
+     The PDB reader is invoked if you give a PDB path 
+     This indicates if you want to search for PDB files and have the 
+     reader fold them in.  You cannot currently name the pdb file 
+     directly - you can only name the path.  Giving "None" says 
+     "do not read the PDB file even if one exists". 
+ 
+     The debug info appears primarily as I_seqpoint annotations in 
+     the instruction streams.  Unfortunately the PDB information does
+     not, for example, tell you how to map back from a class definition
+     to a source code line number - you will need to explicitly search
+     for a sequence point in the code for one of the methods of the 
+     class.  That is not particularly satisfactory, and it may be
+     a good idea to build a small library which extracts the information
+     you need.
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-cancellable.html b/reference/fsharp-compiler-cancellable.html new file mode 100644 index 0000000000..5561e82e34 --- /dev/null +++ b/reference/fsharp-compiler-cancellable.html @@ -0,0 +1,630 @@ + + + + + + + + + + + + + + + + + + Cancellable (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Cancellable Type +

+
+
+ Namespace: + + FSharp.Compiler + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + Cancellable.CheckAndThrow() + + +

+ +
+
+ Full Usage: + Cancellable.CheckAndThrow() +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +

+ + + Cancellable.Token + + +

+ +
+
+ Full Usage: + Cancellable.Token +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-delayedilmodulereader.html b/reference/fsharp-compiler-codeanalysis-delayedilmodulereader.html new file mode 100644 index 0000000000..82e32695da --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-delayedilmodulereader.html @@ -0,0 +1,686 @@ + + + + + + + + + + + + + + + + + + DelayedILModuleReader (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DelayedILModuleReader Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Delays the creation of an ILModuleReader +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + DelayedILModuleReader(name, getStream) + + +

+ +
+
+ Full Usage: + DelayedILModuleReader(name, getStream) +
+
+ Parameters: + +
+ + Returns: + DelayedILModuleReader + +
+
+
+
+ 		+
+
+ + name + + : + string +
+
+
+ + getStream + + : + CancellationToken -> Stream option +
+
+
+
+
+ + Returns: + + DelayedILModuleReader +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.OutputFile + + +

+ +
+
+ Full Usage: + this.OutputFile +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-documentsource.html b/reference/fsharp-compiler-codeanalysis-documentsource.html new file mode 100644 index 0000000000..56bf3c3b75 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-documentsource.html @@ -0,0 +1,632 @@ + + + + + + + + + + + + + + + + + + DocumentSource (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DocumentSource Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Custom string -> Async<ISourceText option> + + +

+ +
+
+ Full Usage: + Custom string -> Async<ISourceText option> +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + string -> Async<ISourceText option> +
+
+
+
+
+ +

+ + + FileSystem + + +

+ +
+
+ Full Usage: + FileSystem +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpchecker.html b/reference/fsharp-compiler-codeanalysis-fsharpchecker.html new file mode 100644 index 0000000000..c2a7249c50 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpchecker.html @@ -0,0 +1,4329 @@ + + + + + + + + + + + + + + + + + + FSharpChecker (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpChecker Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Used to parse and check F# source code. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.BeforeBackgroundFileCheck + + +

+ +
+
+ Full Usage: + this.BeforeBackgroundFileCheck +
+
+ + Returns: + IEvent<string * FSharpProjectOptions> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Notify the host that the logical type checking context for a file has now been updated internally + and that the file has become eligible to be re-typechecked for errors. + The event will be raised on a background thread. +

+
+ +
+
+ + Returns: + + IEvent<string * FSharpProjectOptions> +
+
+
+
+
+
+ +

+ + + this.CheckFileInProject + + +

+ +
+
+ Full Usage: + this.CheckFileInProject +
+
+ Parameters: +
    + + + parseResults + + : + FSharpParseFileResults + - + The results of ParseFile for this file. + +
    + + + fileName + + : + string + - + The name of the file in the project whose source is being checked. + +
    + + + fileVersion + + : + int + - + An integer that can be used to indicate the version of the file. This will be returned by TryGetRecentCheckResultsForFile when looking up the file. + +
    + + + sourceText + + : + ISourceText + - + The full source for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpCheckFileAnswer> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

+ Check a source code file, returning a handle to the results +

+ Note: all files except the one being checked are read from the FileSystem API +

+ Return FSharpCheckFileAnswer.Aborted if a parse tree was not available. +

+

+
+ +
+
+ + parseResults + + : + FSharpParseFileResults +
+
+

+ The results of ParseFile for this file. +

+
+
+ + fileName + + : + string +
+
+

+ The name of the file in the project whose source is being checked. +

+
+
+ + fileVersion + + : + int +
+
+

+ An integer that can be used to indicate the version of the file. This will be returned by TryGetRecentCheckResultsForFile when looking up the file. +

+
+
+ + sourceText + + : + ISourceText +
+
+

+ The full source for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpCheckFileAnswer> +
+
+
+
+
+
+ +

+ + + this.ClearCache + + +

+ +
+
+ Full Usage: + this.ClearCache +
+
+ Parameters: +
    + + + options + + : + FSharpProjectOptions seq + - + The given project options. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Clear the internal cache of the given projects. +

+
+ +
+
+ + options + + : + FSharpProjectOptions seq +
+
+

+ The given project options. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+
+ +

+ + + this.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients + + +

+ +
+
+ Full Usage: + this.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Flush all caches and garbage collect +

+
+
+
+ +

+ + + this.Compile + + +

+ +
+
+ Full Usage: + this.Compile +
+
+ Parameters: +
    + + + argv + + : + string[] + - + The command line arguments for the project build. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpDiagnostic[] * int> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + Compile using the given flags. Source files names are resolved via the FileSystem API. + The output file must be given by a -o flag. + The first argument is ignored and can just be "fsc.exe". + +

+
+ +
+
+ + argv + + : + string[] +
+
+

+ The command line arguments for the project build. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpDiagnostic[] * int> +
+
+
+
+
+
+ +

+ + + this.FileChecked + + +

+ +
+
+ Full Usage: + this.FileChecked +
+
+ + Returns: + IEvent<string * FSharpProjectOptions> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Raised after a check of a file in the background analysis. + + The event will be raised on a background thread. +

+
+ +
+
+ + Returns: + + IEvent<string * FSharpProjectOptions> +
+
+
+
+
+
+ +

+ + + this.FileParsed + + +

+ +
+
+ Full Usage: + this.FileParsed +
+
+ + Returns: + IEvent<string * FSharpProjectOptions> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Raised after a parse of a file in the background analysis. + + The event will be raised on a background thread. +

+
+ +
+
+ + Returns: + + IEvent<string * FSharpProjectOptions> +
+
+
+
+
+
+ +

+ + + this.FindBackgroundReferencesInFile + + +

+ +
+
+ Full Usage: + this.FindBackgroundReferencesInFile +
+
+ Parameters: +
    + + + fileName + + : + string + - + The file name for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. + +
    + + + symbol + + : + FSharpSymbol + - + The symbol to find all uses in the file. + +
    + + + ?canInvalidateProject + + : + bool + - + Default: true. If true, this call can invalidate the current state of project if the options have changed. If false, the current state of the project will be used. + +
    + + + ?fastCheck + + : + bool + - + Default: false. Experimental feature that makes the operation faster. Requires FSharpChecker to be created with captureIdentifiersWhenParsing = true. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<range seq> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Optimized find references for a given symbol in a file of project.

All files are read from the FileSystem API, including the file being checked.

Can cause a second type-check when `enablePartialTypeChecking` is true on the FSharpChecker.

+

+
+ +
+
+ + fileName + + : + string +
+
+

+ The file name for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. +

+
+
+ + symbol + + : + FSharpSymbol +
+
+

+ The symbol to find all uses in the file. +

+
+
+ + ?canInvalidateProject + + : + bool +
+
+

+ Default: true. If true, this call can invalidate the current state of project if the options have changed. If false, the current state of the project will be used. +

+
+
+ + ?fastCheck + + : + bool +
+
+

+ Default: false. Experimental feature that makes the operation faster. Requires FSharpChecker to be created with captureIdentifiersWhenParsing = true. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<range seq> +
+
+
+
+
+
+ +

+ + + this.GetBackgroundCheckResultsForFileInProject + + +

+ +
+
+ Full Usage: + this.GetBackgroundCheckResultsForFileInProject +
+
+ Parameters: +
    + + + fileName + + : + string + - + The file name for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpParseFileResults * FSharpCheckFileResults> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Like CheckFileInProject, but uses the existing results from the background builder.

All files are read from the FileSystem API, including the file being checked.

Can cause a second type-check when `enablePartialTypeChecking` is true on the FSharpChecker.

+

+
+ +
+
+ + fileName + + : + string +
+
+

+ The file name for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpParseFileResults * FSharpCheckFileResults> +
+
+
+
+
+
+ +

+ + + this.GetBackgroundParseResultsForFileInProject + + +

+ +
+
+ Full Usage: + this.GetBackgroundParseResultsForFileInProject +
+
+ Parameters: +
    + + + fileName + + : + string + - + The name for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpParseFileResults> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Like ParseFile, but uses results from the background builder.

All files are read from the FileSystem API, including the file being checked.

+

+
+ +
+
+ + fileName + + : + string +
+
+

+ The name for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpParseFileResults> +
+
+
+
+
+
+ +

+ + + this.GetBackgroundSemanticClassificationForFile + + +

+ +
+
+ Full Usage: + this.GetBackgroundSemanticClassificationForFile +
+
+ Parameters: +
    + + + fileName + + : + string + - + The file name for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<SemanticClassificationView option> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Get semantic classification for a file.

All files are read from the FileSystem API, including the file being checked.

Can cause a second type-check when `enablePartialTypeChecking` is true on the FSharpChecker.

+

+
+ +
+
+ + fileName + + : + string +
+
+

+ The file name for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<SemanticClassificationView option> +
+
+
+
+
+
+ +

+ + + this.GetParsingOptionsFromCommandLineArgs + + +

+ +
+
+ Full Usage: + this.GetParsingOptionsFromCommandLineArgs +
+
+ Parameters: +
    + + + argv + + : + string list + - + The command line arguments for the project build. + +
    + + + ?isInteractive + + : + bool + - + Indicates that parsing should assume the INTERACTIVE define and related settings + +
    + + + ?isEditing + + : + bool + - + Indicates that compilation should assume the EDITING define and related settings + +
    +
+
+ + Returns: + FSharpParsingOptions * FSharpDiagnostic list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Get the FSharpParsingOptions implied by a set of command line arguments.

+

+
+ +
+
+ + argv + + : + string list +
+
+

+ The command line arguments for the project build. +

+
+
+ + ?isInteractive + + : + bool +
+
+

+ Indicates that parsing should assume the INTERACTIVE define and related settings +

+
+
+ + ?isEditing + + : + bool +
+
+

+ Indicates that compilation should assume the EDITING define and related settings +

+
+
+
+
+ + Returns: + + FSharpParsingOptions * FSharpDiagnostic list +
+
+
+
+
+
+ +

+ + + this.GetParsingOptionsFromCommandLineArgs + + +

+ +
+
+ Full Usage: + this.GetParsingOptionsFromCommandLineArgs +
+
+ Parameters: +
    + + + sourceFiles + + : + string list + - + Initial source files list. Additional files may be added during argv evaluation. + +
    + + + argv + + : + string list + - + The command line arguments for the project build. + +
    + + + ?isInteractive + + : + bool + - + Indicates that parsing should assume the INTERACTIVE define and related settings + +
    + + + ?isEditing + + : + bool + - + Indicates that compilation should assume the EDITING define and related settings + +
    +
+
+ + Returns: + FSharpParsingOptions * FSharpDiagnostic list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Get the FSharpParsingOptions implied by a set of command line arguments and list of source files.

+

+
+ +
+
+ + sourceFiles + + : + string list +
+
+

+ Initial source files list. Additional files may be added during argv evaluation. +

+
+
+ + argv + + : + string list +
+
+

+ The command line arguments for the project build. +

+
+
+ + ?isInteractive + + : + bool +
+
+

+ Indicates that parsing should assume the INTERACTIVE define and related settings +

+
+
+ + ?isEditing + + : + bool +
+
+

+ Indicates that compilation should assume the EDITING define and related settings +

+
+
+
+
+ + Returns: + + FSharpParsingOptions * FSharpDiagnostic list +
+
+
+
+
+
+ +

+ + + this.GetParsingOptionsFromProjectOptions + + +

+ +
+
+ Full Usage: + this.GetParsingOptionsFromProjectOptions +
+
+ Parameters: + +
+ + Returns: + FSharpParsingOptions * FSharpDiagnostic list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Get the FSharpParsingOptions implied by a FSharpProjectOptions.

+

+
+ +
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The overall options. +

+
+
+
+
+ + Returns: + + FSharpParsingOptions * FSharpDiagnostic list +
+
+
+
+
+
+ +

+ + + this.GetProjectOptionsFromCommandLineArgs + + +

+ +
+
+ Full Usage: + this.GetProjectOptionsFromCommandLineArgs +
+
+ Parameters: +
    + + + projectFileName + + : + string + - + Used to differentiate between projects and for the base directory of the project. + +
    + + + argv + + : + string[] + - + The command line arguments for the project build. + +
    + + + ?loadedTimeStamp + + : + DateTime + - + Indicates when the script was loaded into the editing environment, + Indicates that compilation should assume the EDITING define and related settingsIndicates that compilation should assume the INTERACTIVE define and related settings + so that an 'unload' and 'reload' action will cause the script to be considered as a new project, + so that references are re-resolved. + +
    + + + ?isInteractive + + : + bool + +
    + + + ?isEditing + + : + bool + +
    +
+
+ + Returns: + FSharpProjectOptions + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the FSharpProjectOptions implied by a set of command line arguments. +

+
+ +
+
+ + projectFileName + + : + string +
+
+

+ Used to differentiate between projects and for the base directory of the project. +

+
+
+ + argv + + : + string[] +
+
+

+ The command line arguments for the project build. +

+
+
+ + ?loadedTimeStamp + + : + DateTime +
+
+

+ Indicates when the script was loaded into the editing environment, + Indicates that compilation should assume the EDITING define and related settingsIndicates that compilation should assume the INTERACTIVE define and related settings + so that an 'unload' and 'reload' action will cause the script to be considered as a new project, + so that references are re-resolved. +

+
+
+ + ?isInteractive + + : + bool +
+
+
+ + ?isEditing + + : + bool +
+
+
+
+
+ + Returns: + + FSharpProjectOptions +
+
+
+
+
+
+ +

+ + + this.GetProjectOptionsFromScript + + +

+ +
+
+ Full Usage: + this.GetProjectOptionsFromScript +
+
+ Parameters: +
    + + + fileName + + : + string + - + Used to differentiate between scripts, to consider each script a separate project. Also used in formatted error messages. + +
    + + + source + + : + ISourceText + - + The source for the file. + +
    + + + ?previewEnabled + + : + bool + - + Is the preview compiler enabled. + +
    + + + ?loadedTimeStamp + + : + DateTime + - + Indicates when the script was loaded into the editing environment, + so that an 'unload' and 'reload' action will cause the script to be considered as a new project, + so that references are re-resolved. + +
    + + + ?otherFlags + + : + string[] + - + Other flags for compilation. + +
    + + + ?useFsiAuxLib + + : + bool + - + Add a default reference to the FSharp.Compiler.Interactive.Settings library. + +
    + + + ?useSdkRefs + + : + bool + - + Use the implicit references from the .NET SDK. + +
    + + + ?assumeDotNetFramework + + : + bool + - + Set up compilation and analysis for .NET Framework scripts. + +
    + + + ?sdkDirOverride + + : + string + - + Override the .NET SDK used for default references. + +
    + + + ?optionsStamp + + : + int64 + - + An optional unique stamp for the options. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpProjectOptions * FSharpDiagnostic list> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

For a given script file, get the FSharpProjectOptions implied by the #load closure.

All files are read from the FileSystem API, except the file being checked.

+

+
+ +
+
+ + fileName + + : + string +
+
+

+ Used to differentiate between scripts, to consider each script a separate project. Also used in formatted error messages. +

+
+
+ + source + + : + ISourceText +
+
+

+ The source for the file. +

+
+
+ + ?previewEnabled + + : + bool +
+
+

+ Is the preview compiler enabled. +

+
+
+ + ?loadedTimeStamp + + : + DateTime +
+
+

+ Indicates when the script was loaded into the editing environment, + so that an 'unload' and 'reload' action will cause the script to be considered as a new project, + so that references are re-resolved. +

+
+
+ + ?otherFlags + + : + string[] +
+
+

+ Other flags for compilation. +

+
+
+ + ?useFsiAuxLib + + : + bool +
+
+

+ Add a default reference to the FSharp.Compiler.Interactive.Settings library. +

+
+
+ + ?useSdkRefs + + : + bool +
+
+

+ Use the implicit references from the .NET SDK. +

+
+
+ + ?assumeDotNetFramework + + : + bool +
+
+

+ Set up compilation and analysis for .NET Framework scripts. +

+
+
+ + ?sdkDirOverride + + : + string +
+
+

+ Override the .NET SDK used for default references. +

+
+
+ + ?optionsStamp + + : + int64 +
+
+

+ An optional unique stamp for the options. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpProjectOptions * FSharpDiagnostic list> +
+
+
+
+
+
+ +

+ + + this.InvalidateAll + + +

+ +
+
+ Full Usage: + this.InvalidateAll +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ This function is called when the entire environment is known to have changed for reasons not encoded in the ProjectOptions of any project/compilation. +

+
+
+
+ +

+ + + this.InvalidateConfiguration + + +

+ +
+
+ Full Usage: + this.InvalidateConfiguration +
+
+ Parameters: +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + This function is called when the configuration is known to have changed for reasons not encoded in the ProjectOptions. + For example, dependent references may have been deleted or created. + +

+
+ +
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+
+ +

+ + + this.MatchBraces + + +

+ +
+
+ Full Usage: + this.MatchBraces +
+
+ Parameters: +
    + + + fileName + + : + string + - + The fileName for the file, used to help caching of results. + +
    + + + sourceText + + : + ISourceText + - + The full source for the file. + +
    + + + options + + : + FSharpParsingOptions + - + Parsing options for the project or script. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<(range * range)[]> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + Parse a source code file, returning information about brace matching in the file. + Return an enumeration of the matching parenthetical tokens in the file. + +

+
+ +
+
+ + fileName + + : + string +
+
+

+ The fileName for the file, used to help caching of results. +

+
+
+ + sourceText + + : + ISourceText +
+
+

+ The full source for the file. +

+
+
+ + options + + : + FSharpParsingOptions +
+
+

+ Parsing options for the project or script. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<(range * range)[]> +
+
+
+
+
+
+ +

+ + + this.NotifyFileChanged + + +

+ +
+
+ Full Usage: + this.NotifyFileChanged +
+
+ Parameters: +
    + + + fileName + + : + string + +
    + + + options + + : + FSharpProjectOptions + +
    + + + ?userOpName + + : + string + +
    +
+
+ + Returns: + Async<unit> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Notify the checker that given file has changed. This needs to be used when checker is created with documentSource = Custom. +

+
+ +
+
+ + fileName + + : + string +
+
+
+ + options + + : + FSharpProjectOptions +
+
+
+ + ?userOpName + + : + string +
+
+
+
+
+ + Returns: + + Async<unit> +
+
+
+
+
+
+ +

+ + + this.ParseAndCheckFileInProject + + +

+ +
+
+ Full Usage: + this.ParseAndCheckFileInProject +
+
+ Parameters: +
    + + + fileName + + : + string + - + The name of the file in the project whose source is being checked. + +
    + + + fileVersion + + : + int + - + An integer that can be used to indicate the version of the file. This will be returned by TryGetRecentCheckResultsForFile when looking up the file. + +
    + + + sourceText + + : + ISourceText + - + The source for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpParseFileResults * FSharpCheckFileAnswer> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

+ Parse and check a source code file, returning a handle to the results +

+ Note: all files except the one being checked are read from the FileSystem API +

+ Return FSharpCheckFileAnswer.Aborted if a parse tree was not available. +

+

+
+ +
+
+ + fileName + + : + string +
+
+

+ The name of the file in the project whose source is being checked. +

+
+
+ + fileVersion + + : + int +
+
+

+ An integer that can be used to indicate the version of the file. This will be returned by TryGetRecentCheckResultsForFile when looking up the file. +

+
+
+ + sourceText + + : + ISourceText +
+
+

+ The source for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpParseFileResults * FSharpCheckFileAnswer> +
+
+
+
+
+
+ +

+ + + this.ParseAndCheckProject + + +

+ +
+
+ Full Usage: + this.ParseAndCheckProject +
+
+ Parameters: +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpCheckProjectResults> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Parse and typecheck all files in a project.

All files are read from the FileSystem API

Can cause a second type-check on the entire project when `enablePartialTypeChecking` is true on the FSharpChecker.

+

+
+ +
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpCheckProjectResults> +
+
+
+
+
+
+ +

+ + + this.ParseFile + + +

+ +
+
+ Full Usage: + this.ParseFile +
+
+ Parameters: +
    + + + fileName + + : + string + - + The path for the file. The file name is used as a module name for implicit top level modules (e.g. in scripts). + +
    + + + sourceText + + : + ISourceText + - + The source to be parsed. + +
    + + + options + + : + FSharpParsingOptions + - + Parsing options for the project or script. + +
    + + + ?cache + + : + bool + - + Store the parse in a size-limited cache assocaited with the FSharpChecker. Default: true + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + Async<FSharpParseFileResults> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + Parses a source code for a file and caches the results. Returns an AST that can be traversed for various features. + +

+
+ +
+
+ + fileName + + : + string +
+
+

+ The path for the file. The file name is used as a module name for implicit top level modules (e.g. in scripts). +

+
+
+ + sourceText + + : + ISourceText +
+
+

+ The source to be parsed. +

+
+
+ + options + + : + FSharpParsingOptions +
+
+

+ Parsing options for the project or script. +

+
+
+ + ?cache + + : + bool +
+
+

+ Store the parse in a size-limited cache assocaited with the FSharpChecker. Default: true +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + Async<FSharpParseFileResults> +
+
+
+
+
+
+ +

+ + + this.ProjectChecked + + +

+ +
+
+ Full Usage: + this.ProjectChecked +
+
+ + Returns: + IEvent<FSharpProjectOptions> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Notify the host that a project has been fully checked in the background (using file contents provided by the file system API) + + The event may be raised on a background thread. +

+
+ +
+
+ + Returns: + + IEvent<FSharpProjectOptions> +
+
+
+
+
+
+ +

+ + + this.TokenizeFile + + +

+ +
+
+ Full Usage: + this.TokenizeFile +
+
+ Parameters: +
    + + + source + + : + string + +
    +
+
+ + Returns: + FSharpTokenInfo[][] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Tokenize an entire file, line by line +

+
+ +
+
+ + source + + : + string +
+
+
+
+
+ + Returns: + + FSharpTokenInfo[][] +
+
+
+
+
+
+ +

+ + + this.TokenizeLine + + +

+ +
+
+ Full Usage: + this.TokenizeLine +
+
+ Parameters: + +
+ + Returns: + FSharpTokenInfo[] * FSharpTokenizerLexState + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Tokenize a single line, returning token information and a tokenization state represented by an integer +

+
+ +
+
+ + line + + : + string +
+
+
+ + state + + : + FSharpTokenizerLexState +
+
+
+
+
+ + Returns: + + FSharpTokenInfo[] * FSharpTokenizerLexState +
+
+
+
+
+
+ +

+ + + this.TryGetRecentCheckResultsForFile + + +

+ +
+
+ Full Usage: + this.TryGetRecentCheckResultsForFile +
+
+ Parameters: +
    + + + fileName + + : + string + - + The file name for the file. + +
    + + + options + + : + FSharpProjectOptions + - + The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. + +
    + + + ?sourceText + + : + ISourceText + - + Optionally, specify source that must match the previous parse precisely. + +
    + + + ?userOpName + + : + string + - + An optional string used for tracing compiler operations associated with this request. + +
    +
+
+ + Returns: + (FSharpParseFileResults * FSharpCheckFileResults * int64) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + Try to get type check results for a file. This looks up the results of recent type checks of the + same file, regardless of contents. The version tag specified in the original check of the file is returned. + If the source of the file has changed the results returned by this function may be out of date, though may + still be usable for generating intellisense menus and information. + +

+
+ +
+
+ + fileName + + : + string +
+
+

+ The file name for the file. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The options for the project or script, used to determine active --define conditionals and other options relevant to parsing. +

+
+
+ + ?sourceText + + : + ISourceText +
+
+

+ Optionally, specify source that must match the previous parse precisely. +

+
+
+ + ?userOpName + + : + string +
+
+

+ An optional string used for tracing compiler operations associated with this request. +

+
+
+
+
+ + Returns: + + (FSharpParseFileResults * FSharpCheckFileResults * int64) option +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpChecker.ActualCheckFileCount + + +

+ +
+
+ Full Usage: + FSharpChecker.ActualCheckFileCount +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Report a statistic for testability +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + FSharpChecker.ActualParseFileCount + + +

+ +
+
+ Full Usage: + FSharpChecker.ActualParseFileCount +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Report a statistic for testability +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + FSharpChecker.Create(?projectCacheSize, ?keepAssemblyContents, ?keepAllBackgroundResolutions, ?legacyReferenceResolver, ?tryGetMetadataSnapshot, ?suggestNamesForErrors, ?keepAllBackgroundSymbolUses, ?enableBackgroundItemKeyStoreAndSemanticClassification, ?enablePartialTypeChecking, ?parallelReferenceResolution, ?captureIdentifiersWhenParsing, ?documentSource, ?useSyntaxTreeCache) + + +

+ +
+
+ Full Usage: + FSharpChecker.Create(?projectCacheSize, ?keepAssemblyContents, ?keepAllBackgroundResolutions, ?legacyReferenceResolver, ?tryGetMetadataSnapshot, ?suggestNamesForErrors, ?keepAllBackgroundSymbolUses, ?enableBackgroundItemKeyStoreAndSemanticClassification, ?enablePartialTypeChecking, ?parallelReferenceResolution, ?captureIdentifiersWhenParsing, ?documentSource, ?useSyntaxTreeCache) +
+
+ Parameters: +
    + + + ?projectCacheSize + + : + int + - + The optional size of the project checking cache. + +
    + + + ?keepAssemblyContents + + : + bool + - + Keep the checked contents of projects. + +
    + + + ?keepAllBackgroundResolutions + + : + bool + - + If false, do not keep full intermediate checking results from background checking suitable for returning from GetBackgroundCheckResultsForFileInProject. This reduces memory usage. + +
    + + + ?legacyReferenceResolver + + : + LegacyReferenceResolver + - + An optional resolver for legacy MSBuild references + +
    + + + ?tryGetMetadataSnapshot + + : + ILReaderTryGetMetadataSnapshot + - + An optional resolver to access the contents of .NET binaries in a memory-efficient way + +
    + + + ?suggestNamesForErrors + + : + bool + - + Indicate whether name suggestion should be enabled + +
    + + + ?keepAllBackgroundSymbolUses + + : + bool + - + Indicate whether all symbol uses should be kept in background checking + +
    + + + ?enableBackgroundItemKeyStoreAndSemanticClassification + + : + bool + - + Indicates whether a table of symbol keys should be kept for background compilation + +
    + + + ?enablePartialTypeChecking + + : + bool + - + Indicates whether to perform partial type checking. Cannot be set to true if keepAssmeblyContents is true. If set to true, can cause duplicate type-checks when richer information on a file is needed, but can skip background type-checking entirely on implementation files with signature files. + +
    + + + ?parallelReferenceResolution + + : + bool + - + Indicates whether to resolve references in parallel. + +
    + + + ?captureIdentifiersWhenParsing + + : + bool + - + When set to true we create a set of all identifiers for each parsed file which can be used to speed up finding references. + +
    + + + ?documentSource + + : + DocumentSource + - + Default: FileSystem. You can use Custom source to provide a function that will return the source for a given file path instead of reading it from the file system. Note that with this option the FSharpChecker will also not monitor the file system for file changes. It will expect to be notified of changes via the NotifyFileChanged method. + +
    + + + ?useSyntaxTreeCache + + : + bool + - + Default: true. Indicates whether to keep parsing results in a cache. + +
    +
+
+ + Returns: + FSharpChecker + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + Create an instance of an FSharpChecker. + +

+
+ +
+
+ + ?projectCacheSize + + : + int +
+
+

+ The optional size of the project checking cache. +

+
+
+ + ?keepAssemblyContents + + : + bool +
+
+

+ Keep the checked contents of projects. +

+
+
+ + ?keepAllBackgroundResolutions + + : + bool +
+
+

+ If false, do not keep full intermediate checking results from background checking suitable for returning from GetBackgroundCheckResultsForFileInProject. This reduces memory usage. +

+
+
+ + ?legacyReferenceResolver + + : + LegacyReferenceResolver +
+
+

+ An optional resolver for legacy MSBuild references +

+
+
+ + ?tryGetMetadataSnapshot + + : + ILReaderTryGetMetadataSnapshot +
+
+

+ An optional resolver to access the contents of .NET binaries in a memory-efficient way +

+
+
+ + ?suggestNamesForErrors + + : + bool +
+
+

+ Indicate whether name suggestion should be enabled +

+
+
+ + ?keepAllBackgroundSymbolUses + + : + bool +
+
+

+ Indicate whether all symbol uses should be kept in background checking +

+
+
+ + ?enableBackgroundItemKeyStoreAndSemanticClassification + + : + bool +
+
+

+ Indicates whether a table of symbol keys should be kept for background compilation +

+
+
+ + ?enablePartialTypeChecking + + : + bool +
+
+

+ Indicates whether to perform partial type checking. Cannot be set to true if keepAssmeblyContents is true. If set to true, can cause duplicate type-checks when richer information on a file is needed, but can skip background type-checking entirely on implementation files with signature files. +

+
+
+ + ?parallelReferenceResolution + + : + bool +
+
+

+ Indicates whether to resolve references in parallel. +

+
+
+ + ?captureIdentifiersWhenParsing + + : + bool +
+
+

+ When set to true we create a set of all identifiers for each parsed file which can be used to speed up finding references. +

+
+
+ + ?documentSource + + : + DocumentSource +
+
+

+ Default: FileSystem. You can use Custom source to provide a function that will return the source for a given file path instead of reading it from the file system. Note that with this option the FSharpChecker will also not monitor the file system for file changes. It will expect to be notified of changes via the NotifyFileChanged method. +

+
+
+ + ?useSyntaxTreeCache + + : + bool +
+
+

+ Default: true. Indicates whether to keep parsing results in a cache. +

+
+
+
+
+ + Returns: + + FSharpChecker +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpcheckfileanswer.html b/reference/fsharp-compiler-codeanalysis-fsharpcheckfileanswer.html new file mode 100644 index 0000000000..84f0f68116 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpcheckfileanswer.html @@ -0,0 +1,648 @@ + + + + + + + + + + + + + + + + + + FSharpCheckFileAnswer (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpCheckFileAnswer Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Aborted + + +

+ +
+
+ Full Usage: + Aborted +
+
+
+
+
+ 		+
+ + + +

+ Aborted because cancellation caused an abandonment of the operation +

+
+
+
+ +

+ + + Succeeded FSharpCheckFileResults + + +

+ +
+
+ Full Usage: + Succeeded FSharpCheckFileResults +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Success +

+
+ +
+
+ + Item + + : + FSharpCheckFileResults +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html b/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html new file mode 100644 index 0000000000..bd09b50a7d --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpcheckfileresults.html @@ -0,0 +1,3308 @@ + + + + + + + + + + + + + + + + + + FSharpCheckFileResults (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpCheckFileResults Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ A handle to the results of CheckFileInProject. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DependencyFiles + + +

+ +
+
+ Full Usage: + this.DependencyFiles +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the set of files which must be watched to accurately track changes that affect these results, + Clients interested in reacting to updates to these files should watch these files and take actions as described + in the documentation for compiler service. +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.Diagnostics + + +

+ +
+
+ Full Usage: + this.Diagnostics +
+
+ + Returns: + FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The errors returned by parsing a source file. +

+
+ +
+
+ + Returns: + + FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.GenerateSignature + + +

+ +
+
+ Full Usage: + this.GenerateSignature +
+
+ Parameters: +
    + + + ?pageWidth + + : + int + +
    +
+
+ + Returns: + ISourceText option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Lays out and returns the formatted signature for the typechecked file as source text. +

+
+ +
+
+ + ?pageWidth + + : + int +
+
+
+
+
+ + Returns: + + ISourceText option +
+
+
+
+
+
+ +

+ + + this.GetAllUsesOfAllSymbolsInFile + + +

+ +
+
+ Full Usage: + this.GetAllUsesOfAllSymbolsInFile +
+
+ Parameters: + +
+ + Returns: + FSharpSymbolUse seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all textual usages of all symbols throughout the file +

+
+ +
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+ + Returns: + + FSharpSymbolUse seq +
+
+
+
+
+
+ +

+ + + this.GetDeclarationListInfo + + +

+ +
+
+ Full Usage: + this.GetDeclarationListInfo +
+
+ Parameters: +
    + + + parsedFileResults + + : + FSharpParseFileResults option + - + + If this is present, it is used to filter declarations based on location in the + parse tree, specifically at 'open' declarations, 'inherit' of class or interface + 'record field' locations and r.h.s. of 'range' operator a..b + + +
    + + + line + + : + int + - + The line number where the completion is happening + +
    + + + lineText + + : + string + - + + The text of the line where the completion is happening. This is only used to make a couple + of adhoc corrections to completion accuracy (e.g. checking for "..") + + +
    + + + partialName + + : + PartialLongName + - + + Partial long name. QuickParse.GetPartialLongNameEx can be used to get it. + + +
    + + + ?getAllEntities + + : + unit -> AssemblySymbol list + - + + Function that returns all entities from current and referenced assemblies. + + +
    + + + ?completionContextAtPos + + : + pos * CompletionContext option + - + + Completion context for a particular position computed in advance. + + +
    +
+
+ + Returns: + DeclarationListInfo + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the items for a declaration list +

+
+ +
+
+ + parsedFileResults + + : + FSharpParseFileResults option +
+
+

+ + If this is present, it is used to filter declarations based on location in the + parse tree, specifically at 'open' declarations, 'inherit' of class or interface + 'record field' locations and r.h.s. of 'range' operator a..b + +

+
+
+ + line + + : + int +
+
+

+ The line number where the completion is happening +

+
+
+ + lineText + + : + string +
+
+

+ + The text of the line where the completion is happening. This is only used to make a couple + of adhoc corrections to completion accuracy (e.g. checking for "..") + +

+
+
+ + partialName + + : + PartialLongName +
+
+

+ + Partial long name. QuickParse.GetPartialLongNameEx can be used to get it. + +

+
+
+ + ?getAllEntities + + : + unit -> AssemblySymbol list +
+
+

+ + Function that returns all entities from current and referenced assemblies. + +

+
+
+ + ?completionContextAtPos + + : + pos * CompletionContext option +
+
+

+ + Completion context for a particular position computed in advance. + +

+
+
+
+
+ + Returns: + + DeclarationListInfo +
+
+
+
+
+
+ +

+ + + this.GetDeclarationListSymbols + + +

+ +
+
+ Full Usage: + this.GetDeclarationListSymbols +
+
+ Parameters: +
    + + + parsedFileResults + + : + FSharpParseFileResults option + - + + If this is present, it is used to filter declarations based on location in the + parse tree, specifically at 'open' declarations, 'inherit' of class or interface + 'record field' locations and r.h.s. of 'range' operator a..b + + +
    + + + line + + : + int + - + The line number where the completion is happening + +
    + + + lineText + + : + string + - + + The text of the line where the completion is happening. This is only used to make a couple + of adhoc corrections to completion accuracy (e.g. checking for "..") + + +
    + + + partialName + + : + PartialLongName + - + + Partial long name. QuickParse.GetPartialLongNameEx can be used to get it. + + +
    + + + ?getAllEntities + + : + unit -> AssemblySymbol list + - + + Function that returns all entities from current and referenced assemblies. + + +
    +
+
+ + Returns: + FSharpSymbolUse list list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the items for a declaration list in FSharpSymbol format +

+
+ +
+
+ + parsedFileResults + + : + FSharpParseFileResults option +
+
+

+ + If this is present, it is used to filter declarations based on location in the + parse tree, specifically at 'open' declarations, 'inherit' of class or interface + 'record field' locations and r.h.s. of 'range' operator a..b + +

+
+
+ + line + + : + int +
+
+

+ The line number where the completion is happening +

+
+
+ + lineText + + : + string +
+
+

+ + The text of the line where the completion is happening. This is only used to make a couple + of adhoc corrections to completion accuracy (e.g. checking for "..") + +

+
+
+ + partialName + + : + PartialLongName +
+
+

+ + Partial long name. QuickParse.GetPartialLongNameEx can be used to get it. + +

+
+
+ + ?getAllEntities + + : + unit -> AssemblySymbol list +
+
+

+ + Function that returns all entities from current and referenced assemblies. + +

+
+
+
+
+ + Returns: + + FSharpSymbolUse list list +
+
+
+
+
+
+ +

+ + + this.GetDeclarationLocation + + +

+ +
+
+ Full Usage: + this.GetDeclarationLocation +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list + - + The identifiers at the location where the information is being requested. + +
    + + + ?preferFlag + + : + bool + - + If not given, then get the location of the symbol. If false, then prefer the location of the corresponding symbol in the implementation of the file (rather than the signature if present). If true, prefer the location of the corresponding symbol in the signature of the file (rather than the implementation). + +
    +
+
+ + Returns: + FindDeclResult + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Resolve the names at the given location to the declaration location of the corresponding construct. +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+ + ?preferFlag + + : + bool +
+
+

+ If not given, then get the location of the symbol. If false, then prefer the location of the corresponding symbol in the implementation of the file (rather than the signature if present). If true, prefer the location of the corresponding symbol in the signature of the file (rather than the implementation). +

+
+
+
+
+ + Returns: + + FindDeclResult +
+
+
+
+
+
+ +

+ + + this.GetDescription + + +

+ +
+
+ Full Usage: + this.GetDescription +
+
+ Parameters: +
    + + + symbol + + : + FSharpSymbol + - + The symbol. + +
    + + + inst + + : + (FSharpGenericParameter * FSharpType) list + - + Generic arguments. + +
    + + + displayFullName + + : + bool + - + Display the symbol full name. + +
    + + + range + + : + range + - + The position. + +
    +
+
+ + Returns: + ToolTipText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compute a formatted tooltip for the given symbol at position +

+
+ +
+
+ + symbol + + : + FSharpSymbol +
+
+

+ The symbol. +

+
+
+ + inst + + : + (FSharpGenericParameter * FSharpType) list +
+
+

+ Generic arguments. +

+
+
+ + displayFullName + + : + bool +
+
+

+ Display the symbol full name. +

+
+
+ + range + + : + range +
+
+

+ The position. +

+
+
+
+
+ + Returns: + + ToolTipText +
+
+
+
+
+
+ +

+ + + this.GetDisplayContextForPos + + +

+ +
+
+ Full Usage: + this.GetDisplayContextForPos +
+
+ Parameters: +
    + + + cursorPos + + : + pos + +
    +
+
+ + Returns: + FSharpDisplayContext option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Find the most precise display environment for the given line and column. +

+
+ +
+
+ + cursorPos + + : + pos +
+
+
+
+
+ + Returns: + + FSharpDisplayContext option +
+
+
+
+
+
+ +

+ + + this.GetF1Keyword + + +

+ +
+
+ Full Usage: + this.GetF1Keyword +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list + - + The identifiers at the location where the information is being requested. + +
    +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compute the Visual Studio F1-help key identifier for the given location, based on name resolution results +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.GetFormatSpecifierLocationsAndArity + + +

+ +
+
+ Full Usage: + this.GetFormatSpecifierLocationsAndArity +
+
+ + Returns: + (range * int)[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the locations of and number of arguments associated with format specifiers +

+
+ +
+
+ + Returns: + + (range * int)[] +
+
+
+
+
+
+ +

+ + + this.GetKeywordTooltip + + +

+ +
+
+ Full Usage: + this.GetKeywordTooltip +
+
+ Parameters: +
    + + + names + + : + string list + - + The keywords at the location where the information is being requested. + +
    +
+
+ + Returns: + ToolTipText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compute a formatted tooltip for the given keywords +

+
+ +
+
+ + names + + : + string list +
+
+

+ The keywords at the location where the information is being requested. +

+
+
+
+
+ + Returns: + + ToolTipText +
+
+
+
+
+
+ +

+ + + this.GetMethods + + +

+ +
+
+ Full Usage: + this.GetMethods +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list option + - + The identifiers at the location where the information is being requested. + +
    +
+
+ + Returns: + MethodGroup + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compute a set of method overloads to show in a dialog relevant to the given code location. +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list option +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+
+
+ + Returns: + + MethodGroup +
+
+
+
+
+
+ +

+ + + this.GetMethodsAsSymbols + + +

+ +
+
+ Full Usage: + this.GetMethodsAsSymbols +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list + - + The identifiers at the location where the information is being requested. + +
    +
+
+ + Returns: + FSharpSymbolUse list option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compute a set of method overloads to show in a dialog relevant to the given code location. The resulting method overloads are returned as symbols. +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+
+
+ + Returns: + + FSharpSymbolUse list option +
+
+
+
+
+
+ +

+ + + this.GetSemanticClassification + + +

+ +
+
+ Full Usage: + this.GetSemanticClassification +
+
+ Parameters: +
    + + + arg0 + + : + range option + +
    +
+
+ + Returns: + SemanticClassificationItem[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get any extra colorization info that is available after the typecheck +

+
+ +
+
+ + arg0 + + : + range option +
+
+
+
+
+ + Returns: + + SemanticClassificationItem[] +
+
+
+
+
+
+ +

+ + + this.GetSymbolUseAtLocation + + +

+ +
+
+ Full Usage: + this.GetSymbolUseAtLocation +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list + - + The identifiers at the location where the information is being requested. + +
    +
+
+ + Returns: + FSharpSymbolUse option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Resolve the names at the given location to a use of symbol. +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+
+
+ + Returns: + + FSharpSymbolUse option +
+
+
+
+
+
+ +

+ + + this.GetSymbolUsesAtLocation + + +

+ +
+
+ Full Usage: + this.GetSymbolUsesAtLocation +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list + - + The identifiers at the location where the information is being requested. + +
    +
+
+ + Returns: + FSharpSymbolUse list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Similar to GetSymbolUseAtLocation, but returns all found symbols if there are multiple. +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+
+
+ + Returns: + + FSharpSymbolUse list +
+
+
+
+
+
+ +

+ + + this.GetToolTip + + +

+ +
+
+ Full Usage: + this.GetToolTip +
+
+ Parameters: +
    + + + line + + : + int + - + The line number where the information is being requested. + +
    + + + colAtEndOfNames + + : + int + - + The column number at the end of the identifiers where the information is being requested. + +
    + + + lineText + + : + string + - + The text of the line where the information is being requested. + +
    + + + names + + : + string list + - + The identifiers at the location where the information is being requested. + +
    + + + tokenTag + + : + int + - + Used to discriminate between 'identifiers', 'strings' and others. For strings, an attempt is made to give a tooltip for a #r "..." location. Use a value from FSharpTokenInfo.Tag, or FSharpTokenTag.Identifier, unless you have other information available. + +
    + + + ?width + + : + int + - + The optional width that the layout gets squashed to. + +
    +
+
+ + Returns: + ToolTipText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compute a formatted tooltip for the given location +

+
+ +
+
+ + line + + : + int +
+
+

+ The line number where the information is being requested. +

+
+
+ + colAtEndOfNames + + : + int +
+
+

+ The column number at the end of the identifiers where the information is being requested. +

+
+
+ + lineText + + : + string +
+
+

+ The text of the line where the information is being requested. +

+
+
+ + names + + : + string list +
+
+

+ The identifiers at the location where the information is being requested. +

+
+
+ + tokenTag + + : + int +
+
+

+ Used to discriminate between 'identifiers', 'strings' and others. For strings, an attempt is made to give a tooltip for a #r "..." location. Use a value from FSharpTokenInfo.Tag, or FSharpTokenTag.Identifier, unless you have other information available. +

+
+
+ + ?width + + : + int +
+
+

+ The optional width that the layout gets squashed to. +

+
+
+
+
+ + Returns: + + ToolTipText +
+
+
+
+
+
+ +

+ + + this.GetUsesOfSymbolInFile + + +

+ +
+
+ Full Usage: + this.GetUsesOfSymbolInFile +
+
+ Parameters: + +
+ + Returns: + FSharpSymbolUse[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the textual usages that resolved to the given symbol throughout the file +

+
+ +
+
+ + symbol + + : + FSharpSymbol +
+
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+ + Returns: + + FSharpSymbolUse[] +
+
+
+
+
+
+ +

+ + + this.HasFullTypeCheckInfo + + +

+ +
+
+ Full Usage: + this.HasFullTypeCheckInfo +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates whether type checking successfully occurred with some results returned. If false, indicates that + an unrecoverable error in earlier checking/parsing/resolution steps. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ImplementationFile + + +

+ +
+
+ Full Usage: + this.ImplementationFile +
+
+ + Returns: + FSharpImplementationFileContents option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents complete typechecked implementation file, including its typechecked signatures if any. +

+
+ +
+
+ + Returns: + + FSharpImplementationFileContents option +
+
+
+
+
+
+ +

+ + + this.IsRelativeNameResolvableFromSymbol + + +

+ +
+
+ Full Usage: + this.IsRelativeNameResolvableFromSymbol +
+
+ Parameters: +
    + + + cursorPos + + : + pos + +
    + + + plid + + : + string list + +
    + + + symbol + + : + FSharpSymbol + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if a long ident is resolvable at a specific point. +

+
+ +
+
+ + cursorPos + + : + pos +
+
+
+ + plid + + : + string list +
+
+
+ + symbol + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.OpenDeclarations + + +

+ +
+
+ Full Usage: + this.OpenDeclarations +
+
+ + Returns: + FSharpOpenDeclaration[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Open declarations in the file, including auto open modules. +

+
+ +
+
+ + Returns: + + FSharpOpenDeclaration[] +
+
+
+
+
+
+ +

+ + + this.PartialAssemblySignature + + +

+ +
+
+ Full Usage: + this.PartialAssemblySignature +
+
+ + Returns: + FSharpAssemblySignature + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a view of the contents of the assembly up to and including the file just checked +

+
+ +
+
+ + Returns: + + FSharpAssemblySignature +
+
+
+
+
+
+ +

+ + + this.ProjectContext + + +

+ +
+
+ Full Usage: + this.ProjectContext +
+
+ + Returns: + FSharpProjectContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the resolution of the ProjectOptions +

+
+ +
+
+ + Returns: + + FSharpProjectContext +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html b/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html new file mode 100644 index 0000000000..d197be4ae5 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpcheckprojectresults.html @@ -0,0 +1,1127 @@ + + + + + + + + + + + + + + + + + + FSharpCheckProjectResults (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpCheckProjectResults Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ A handle to the results of CheckFileInProject. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AssemblyContents + + +

+ +
+
+ Full Usage: + this.AssemblyContents +
+
+ + Returns: + FSharpAssemblyContents + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a view of the overall contents of the assembly. Only valid to use if HasCriticalErrors is false. +

+
+ +
+
+ + Returns: + + FSharpAssemblyContents +
+
+
+
+
+
+ +

+ + + this.AssemblySignature + + +

+ +
+
+ Full Usage: + this.AssemblySignature +
+
+ + Returns: + FSharpAssemblySignature + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a view of the overall signature of the assembly. Only valid to use if HasCriticalErrors is false. +

+
+ +
+
+ + Returns: + + FSharpAssemblySignature +
+
+
+
+
+
+ +

+ + + this.DependencyFiles + + +

+ +
+
+ Full Usage: + this.DependencyFiles +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the set of files which must be watched to accurately track changes that affect these results, + Clients interested in reacting to updates to these files should watch these files and take actions as described + in the documentation for compiler service. +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.Diagnostics + + +

+ +
+
+ Full Usage: + this.Diagnostics +
+
+ + Returns: + FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The errors returned by processing the project +

+
+ +
+
+ + Returns: + + FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.GetAllUsesOfAllSymbols + + +

+ +
+
+ Full Usage: + this.GetAllUsesOfAllSymbols +
+
+ Parameters: + +
+ + Returns: + FSharpSymbolUse[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all textual usages of all symbols throughout the project +

+
+ +
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+ + Returns: + + FSharpSymbolUse[] +
+
+
+
+
+
+ +

+ + + this.GetOptimizedAssemblyContents + + +

+ +
+
+ Full Usage: + this.GetOptimizedAssemblyContents +
+
+ + Returns: + FSharpAssemblyContents + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get an optimized view of the overall contents of the assembly. Only valid to use if HasCriticalErrors is false. +

+
+ +
+
+ + Returns: + + FSharpAssemblyContents +
+
+
+
+
+
+ +

+ + + this.GetUsesOfSymbol + + +

+ +
+
+ Full Usage: + this.GetUsesOfSymbol +
+
+ Parameters: + +
+ + Returns: + FSharpSymbolUse[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the textual usages that resolved to the given symbol throughout the project +

+
+ +
+
+ + symbol + + : + FSharpSymbol +
+
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+ + Returns: + + FSharpSymbolUse[] +
+
+
+
+
+
+ +

+ + + this.HasCriticalErrors + + +

+ +
+
+ Full Usage: + this.HasCriticalErrors +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if critical errors existed in the project options +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ProjectContext + + +

+ +
+
+ Full Usage: + this.ProjectContext +
+
+ + Returns: + FSharpProjectContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the resolution of the ProjectOptions +

+
+ +
+
+ + Returns: + + FSharpProjectContext +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html b/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html new file mode 100644 index 0000000000..b5e97f6edc --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpparsefileresults.html @@ -0,0 +1,2494 @@ + + + + + + + + + + + + + + + + + + FSharpParseFileResults (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpParseFileResults Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the results of parsing an F# file and a set of analysis operations based on the parse tree alone. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DependencyFiles + + +

+ +
+
+ Full Usage: + this.DependencyFiles +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ When these files change then the build is invalid +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.Diagnostics + + +

+ +
+
+ Full Usage: + this.Diagnostics +
+
+ + Returns: + FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the errors and warnings for the parse +

+
+ +
+
+ + Returns: + + FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Name of the file for which this information were created +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.FindParameterLocations + + +

+ +
+
+ Full Usage: + this.FindParameterLocations +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + ParameterLocations option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Notable parse info for ParameterInfo at a given location +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + ParameterLocations option +
+
+
+
+
+
+ +

+ + + this.GetAllArgumentsForFunctionApplicationAtPosition + + +

+ +
+
+ Full Usage: + this.GetAllArgumentsForFunctionApplicationAtPosition +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range list option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the ranges of all arguments, if they can be found, for a function application at the given position. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range list option +
+
+
+
+
+
+ +

+ + + this.GetNavigationItems + + +

+ +
+
+ Full Usage: + this.GetNavigationItems +
+
+ + Returns: + NavigationItems + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get declared items and the selected item at the specified location +

+
+ +
+
+ + Returns: + + NavigationItems +
+
+
+
+
+
+ +

+ + + this.IsBindingALambdaAtPosition + + +

+ +
+
+ Full Usage: + this.IsBindingALambdaAtPosition +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the binding at the given position is bound to a lambda expression +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPosContainedInApplication + + +

+ +
+
+ Full Usage: + this.IsPosContainedInApplication +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the given position is inside a function or method application. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPositionContainedInACurriedParameter + + +

+ +
+
+ Full Usage: + this.IsPositionContainedInACurriedParameter +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the given position is contained within a curried parameter in a binding. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPositionWithinRecordDefinition + + +

+ +
+
+ Full Usage: + this.IsPositionWithinRecordDefinition +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the given position is bound to a record definition +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPositionWithinTypeDefinition + + +

+ +
+
+ Full Usage: + this.IsPositionWithinTypeDefinition +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the given position is bound to a type definition +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsTypeAnnotationGivenAtPosition + + +

+ +
+
+ Full Usage: + this.IsTypeAnnotationGivenAtPosition +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the expression or pattern at the given position has a type annotation +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsTypeName + + +

+ +
+
+ Full Usage: + this.IsTypeName +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Determines if the range points to a type name in the type definition. +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ParseHadErrors + + +

+ +
+
+ Full Usage: + this.ParseHadErrors +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if any errors occurred during the parse +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ParseTree + + +

+ +
+
+ Full Usage: + this.ParseTree +
+
+ + Returns: + ParsedInput + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The syntax tree resulting from the parse +

+
+ +
+
+ + Returns: + + ParsedInput +
+
+
+
+
+
+ +

+ + + this.TryIdentOfPipelineContainingPosAndNumArgsApplied + + +

+ +
+
+ Full Usage: + this.TryIdentOfPipelineContainingPosAndNumArgsApplied +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + (Ident * int) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find an Ident of a pipeline containing the given position, and the number of args already applied in that pipeline. + For example, '[1..10] |> List.map ' would give back the ident of '|>' and 1, because it applied 1 arg (the list) to 'List.map'. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + (Ident * int) option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfExprInYieldOrReturn + + +

+ +
+
+ Full Usage: + this.TryRangeOfExprInYieldOrReturn +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find the range of an expression `expr` contained in a `yield expr` or `return expr` expression (and bang-variants). +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfExpressionBeingDereferencedContainingPos + + +

+ +
+
+ Full Usage: + this.TryRangeOfExpressionBeingDereferencedContainingPos +
+
+ Parameters: +
    + + + expressionPos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the range of an expression being dereferenced. For `!expr`, gives the range of `expr` +

+
+ +
+
+ + expressionPos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfFunctionOrMethodBeingApplied + + +

+ +
+
+ Full Usage: + this.TryRangeOfFunctionOrMethodBeingApplied +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find the range of a function or method that is being applied. Also accounts for functions in pipelines. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfNameOfNearestOuterBindingContainingPos + + +

+ +
+
+ Full Usage: + this.TryRangeOfNameOfNearestOuterBindingContainingPos +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find the range of the name of the nearest outer binding that contains a given position. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfParenEnclosingOpEqualsGreaterUsage + + +

+ +
+
+ Full Usage: + this.TryRangeOfParenEnclosingOpEqualsGreaterUsage +
+
+ Parameters: +
    + + + opGreaterEqualPos + + : + pos + +
    +
+
+ + Returns: + (range * range * range) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find the range of an attempted lambda expression or pattern, the argument range, and the expr range when writing a C#-style "lambda" (which is actually an operator application) +

+
+ +
+
+ + opGreaterEqualPos + + : + pos +
+
+
+
+
+ + Returns: + + (range * range * range) option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfRecordExpressionContainingPos + + +

+ +
+
+ Full Usage: + this.TryRangeOfRecordExpressionContainingPos +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find the range of a record expression containing the given position. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfRefCellDereferenceContainingPos + + +

+ +
+
+ Full Usage: + this.TryRangeOfRefCellDereferenceContainingPos +
+
+ Parameters: +
    + + + expressionPos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Given the position of an expression, attempts to find the range of the + '!' in a derefence operation of that expression, like: + '!expr', '!(expr)', etc. +

+
+ +
+
+ + expressionPos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfReturnTypeHint + + +

+ +
+
+ Full Usage: + this.TryRangeOfReturnTypeHint +
+
+ Parameters: +
    + + + symbolUseStart + + : + pos + +
    + + + ?skipLambdas + + : + bool + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the range of where a return type hint could be placed for a function binding. This will be right in front of the equals sign. + Returns None if type annotation is present. +

+
+ +
+
+ + symbolUseStart + + : + pos +
+
+
+ + ?skipLambdas + + : + bool +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryRangeOfStringInterpolationContainingPos + + +

+ +
+
+ Full Usage: + this.TryRangeOfStringInterpolationContainingPos +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempts to find the range of the string interpolation that contains a given position. +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.ValidateBreakpointLocation + + +

+ +
+
+ Full Usage: + this.ValidateBreakpointLocation +
+
+ Parameters: +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Return the inner-most range associated with a possible breakpoint location +

+
+ +
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html b/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html new file mode 100644 index 0000000000..ee4dd76117 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpparsingoptions.html @@ -0,0 +1,1025 @@ + + + + + + + + + + + + + + + + + + FSharpParsingOptions (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpParsingOptions Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpParsingOptions> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Options used to determine active --define conditionals and other options relevant to parsing files in a project +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ApplyLineDirectives + + +

+ +
+
+ Full Usage: + ApplyLineDirectives +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates if the ranges returned by parsing should have '#line' directives applied to them. + When compiling code, this should usually be 'true'. For editing tools, this is usually 'false. + The default for FSharpParsingOptions.ApplyLineDirectives is 'false'. The default for + FSharpParsingOptions arising from FSharpProjectOptions will be 'true' unless '--ignorelinedirectives' is used in the + parameters from which these are derived. +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + CompilingFSharpCore + + +

+ +
+
+ Full Usage: + CompilingFSharpCore +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + ConditionalDefines + + +

+ +
+
+ Full Usage: + ConditionalDefines +
+
+ + Field type: + string list + +
+
+
+
+ 		+
+
+ + Field type: + + string list +
+
+
+
+
+ +

+ + + DiagnosticOptions + + +

+ +
+
+ Full Usage: + DiagnosticOptions +
+
+ + Field type: + FSharpDiagnosticOptions + +
+
+
+
+ 		+
+
+ + Field type: + + FSharpDiagnosticOptions +
+
+
+
+
+ +

+ + + IndentationAwareSyntax + + +

+ +
+
+ Full Usage: + IndentationAwareSyntax +
+
+ + Field type: + bool option + +
+
+
+
+ 		+
+
+ + Field type: + + bool option +
+
+
+
+
+ +

+ + + IsExe + + +

+ +
+
+ Full Usage: + IsExe +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + IsInteractive + + +

+ +
+
+ Full Usage: + IsInteractive +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + LangVersionText + + +

+ +
+
+ Full Usage: + LangVersionText +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + SourceFiles + + +

+ +
+
+ Full Usage: + SourceFiles +
+
+ + Field type: + string[] + +
+
+
+
+ 		+
+
+ + Field type: + + string[] +
+
+
+
+
+ +

+ + + StrictIndentation + + +

+ +
+
+ Full Usage: + StrictIndentation +
+
+ + Field type: + bool option + +
+
+
+
+ 		+
+
+ + Field type: + + bool option +
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpParsingOptions.Default + + +

+ +
+
+ Full Usage: + FSharpParsingOptions.Default +
+
+ + Returns: + FSharpParsingOptions + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpParsingOptions +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html b/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html new file mode 100644 index 0000000000..5768e27d58 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpprojectcontext.html @@ -0,0 +1,723 @@ + + + + + + + + + + + + + + + + + + FSharpProjectContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpProjectContext Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the checking context implied by the ProjectOptions +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AccessibilityRights + + +

+ +
+
+ Full Usage: + this.AccessibilityRights +
+
+ + Returns: + FSharpAccessibilityRights + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the accessibility rights for this project context w.r.t. InternalsVisibleTo attributes granting access to other assemblies +

+
+ +
+
+ + Returns: + + FSharpAccessibilityRights +
+
+
+
+
+
+ +

+ + + this.GetReferencedAssemblies + + +

+ +
+
+ Full Usage: + this.GetReferencedAssemblies +
+
+ + Returns: + FSharpAssembly list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the resolution and full contents of the assemblies referenced by the project options +

+
+ +
+
+ + Returns: + + FSharpAssembly list +
+
+
+
+
+
+ +

+ + + this.ProjectOptions + + +

+ +
+
+ Full Usage: + this.ProjectOptions +
+
+ + Returns: + FSharpProjectOptions + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the project options +

+
+ +
+
+ + Returns: + + FSharpProjectOptions +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html b/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html new file mode 100644 index 0000000000..0f79891b51 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpprojectoptions.html @@ -0,0 +1,1112 @@ + + + + + + + + + + + + + + + + + + FSharpProjectOptions (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpProjectOptions Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ A set of information describing a project or script build configuration. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + IsIncompleteTypeCheckEnvironment + + +

+ +
+
+ Full Usage: + IsIncompleteTypeCheckEnvironment +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ When true, the typechecking environment is known a priori to be incomplete, for + example when a .fs file is opened outside of a project. In this case, the number of error + messages reported is reduced. +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + LoadTime + + +

+ +
+
+ Full Usage: + LoadTime +
+
+ + Field type: + DateTime + +
+
+
+
+ 		+
+ +
+ + + +

+ Timestamp of project/script load, used to differentiate between different instances of a project load. + This ensures that a complete reload of the project or script type checking + context occurs on project or script unload/reload. +

+
+ +
+
+ + Field type: + + DateTime +
+
+
+
+
+
+ +

+ + + OriginalLoadReferences + + +

+ +
+
+ Full Usage: + OriginalLoadReferences +
+
+ + Field type: + (range * string * string) list + +
+
+
+
+ 		+
+ +
+ + + +

+ Unused in this API and should be '[]' when used as user-specified input +

+
+ +
+
+ + Field type: + + (range * string * string) list +
+
+
+
+
+
+ +

+ + + OtherOptions + + +

+ +
+
+ Full Usage: + OtherOptions +
+
+ + Field type: + string[] + +
+
+
+
+ 		+
+ +
+ + + +

+ Additional command line argument options for the project. These can include additional files and references. +

+
+ +
+
+ + Field type: + + string[] +
+
+
+
+
+
+ +

+ + + ProjectFileName + + +

+ +
+
+ Full Usage: + ProjectFileName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + ProjectId + + +

+ +
+
+ Full Usage: + ProjectId +
+
+ + Field type: + string option + +
+
+
+
+ 		+
+ +
+ + + +

+ This is the unique identifier for the project, it is case sensitive. If it's None, will key off of ProjectFileName in our caching. +

+
+ +
+
+ + Field type: + + string option +
+
+
+
+
+
+ +

+ + + ReferencedProjects + + +

+ +
+
+ Full Usage: + ReferencedProjects +
+
+ + Field type: + FSharpReferencedProject[] + +
+
+
+
+ 		+
+ +
+ + + +

+ The command line arguments for the other projects referenced by this project, indexed by the + exact text used in the "-r:" reference in FSharpProjectOptions. +

+
+ +
+
+ + Field type: + + FSharpReferencedProject[] +
+
+
+
+
+
+ +

+ + + SourceFiles + + +

+ +
+
+ Full Usage: + SourceFiles +
+
+ + Field type: + string[] + +
+
+
+
+ 		+
+ +
+ + + +

+ The files in the project +

+
+ +
+
+ + Field type: + + string[] +
+
+
+
+
+
+ +

+ + + Stamp + + +

+ +
+
+ Full Usage: + Stamp +
+
+ + Field type: + int64 option + +
+
+
+
+ 		+
+ +
+ + + +

+ An optional stamp to uniquely identify this set of options + If two sets of options both have stamps, then they are considered equal + if and only if the stamps are equal +

+
+ +
+
+ + Field type: + + int64 option +
+
+
+
+
+
+ +

+ + + UnresolvedReferences + + +

+ +
+
+ Full Usage: + UnresolvedReferences +
+
+ + Field type: + FSharpUnresolvedReferencesSet option + +
+
+
+
+ 		+
+ +
+ + + +

+ Unused in this API and should be 'None' when used as user-specified input +

+
+ +
+
+ + Field type: + + FSharpUnresolvedReferencesSet option +
+
+
+
+
+
+ +

+ + + UseScriptResolutionRules + + +

+ +
+
+ Full Usage: + UseScriptResolutionRules +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ When true, use the reference resolution rules for scripts rather than the rules for compiler. +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html b/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html new file mode 100644 index 0000000000..e39f11c0e2 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpreferencedproject.html @@ -0,0 +1,922 @@ + + + + + + + + + + + + + + + + + + FSharpReferencedProject (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpReferencedProject Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + FSharpReference(projectOutputFile, options) + + +

+ +
+
+ Full Usage: + FSharpReference(projectOutputFile, options) +
+
+ Parameters: +
    + + + projectOutputFile + + : + string + - + The fully qualified path to the output of the referenced project. This should be the same value as the -r reference in the project options for this referenced project. + +
    + + + options + + : + FSharpProjectOptions + - + The Project Options for this F# project + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ + A reference for an F# project. The physical data for it is stored/cached inside of the compiler service. + +

+
+ +
+
+ + projectOutputFile + + : + string +
+
+

+ The fully qualified path to the output of the referenced project. This should be the same value as the -r reference in the project options for this referenced project. +

+
+
+ + options + + : + FSharpProjectOptions +
+
+

+ The Project Options for this F# project +

+
+
+
+
+
+ +

+ + + ILModuleReference(projectOutputFile, getStamp, getReader) + + +

+ +
+
+ Full Usage: + ILModuleReference(projectOutputFile, getStamp, getReader) +
+
+ Parameters: +
    + + + projectOutputFile + + : + string + - + The fully qualified path to the output of the referenced project. This should be the same value as the -r reference in the project options for this referenced project. + +
    + + + getStamp + + : + unit -> DateTime + - + A function that calculates a last-modified timestamp for this reference. This will be used to determine if the reference is up-to-date. + +
    + + + getReader + + : + unit -> ILModuleReader + - + A function that creates an ILModuleReader for reading module data. + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ + A reference from an ILModuleReader. + +

+
+ +
+
+ + projectOutputFile + + : + string +
+
+

+ The fully qualified path to the output of the referenced project. This should be the same value as the -r reference in the project options for this referenced project. +

+
+
+ + getStamp + + : + unit -> DateTime +
+
+

+ A function that calculates a last-modified timestamp for this reference. This will be used to determine if the reference is up-to-date. +

+
+
+ + getReader + + : + unit -> ILModuleReader +
+
+

+ A function that creates an ILModuleReader for reading module data. +

+
+
+
+
+
+ +

+ + + PEReference(getStamp, delayedReader) + + +

+ +
+
+ Full Usage: + PEReference(getStamp, delayedReader) +
+
+ Parameters: +
    + + + getStamp + + : + unit -> DateTime + - + A function that calculates a last-modified timestamp for this reference. This will be used to determine if the reference is up-to-date. + +
    + + + delayedReader + + : + DelayedILModuleReader + - + A function that opens a Portable Executable data stream for reading. + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ + A reference for any portable executable, including F#. The stream is owned by this reference. + The stream will be automatically disposed when there are no references to FSharpReferencedProject and is GC collected. + Once the stream is evaluated, the function that constructs the stream will no longer be referenced by anything. + If the stream evaluation throws an exception, it will be automatically handled. + +

+
+ +
+
+ + getStamp + + : + unit -> DateTime +
+
+

+ A function that calculates a last-modified timestamp for this reference. This will be used to determine if the reference is up-to-date. +

+
+
+ + delayedReader + + : + DelayedILModuleReader +
+
+

+ A function that opens a Portable Executable data stream for reading. +

+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.OutputFile + + +

+ +
+
+ Full Usage: + this.OutputFile +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ + The fully qualified path to the output of the referenced project. This should be the same value as the -r + reference in the project options for this referenced project. + +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html b/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html new file mode 100644 index 0000000000..6f269b9a77 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpsymboluse.html @@ -0,0 +1,1391 @@ + + + + + + + + + + + + + + + + + + FSharpSymbolUse (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpSymbolUse Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the use of an F# symbol from F# source code +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DisplayContext + + +

+ +
+
+ Full Usage: + this.DisplayContext +
+
+ + Returns: + FSharpDisplayContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The display context active at the point where the symbol is used. Can be passed to FSharpType.Format + and other methods to format items in a way that is suitable for a specific source code location. +

+
+ +
+
+ + Returns: + + FSharpDisplayContext +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The file name the reference occurs in +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GenericArguments + + +

+ +
+
+ Full Usage: + this.GenericArguments +
+
+ + Returns: + (FSharpGenericParameter * FSharpType) list + +
+
+
+
+ 		+
+
+ + Returns: + + (FSharpGenericParameter * FSharpType) list +
+
+
+
+
+ +

+ + + this.IsFromAttribute + + +

+ +
+
+ Full Usage: + this.IsFromAttribute +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is in an attribute +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromComputationExpression + + +

+ +
+
+ Full Usage: + this.IsFromComputationExpression +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is either a builder or a custom operation in a computation expression +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromDefinition + + +

+ +
+
+ Full Usage: + this.IsFromDefinition +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is a definition for the symbol, either in a signature or implementation +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromDispatchSlotImplementation + + +

+ +
+
+ Full Usage: + this.IsFromDispatchSlotImplementation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is via the member being implemented in a class or object expression +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromOpenStatement + + +

+ +
+
+ Full Usage: + this.IsFromOpenStatement +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is in open statement +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromPattern + + +

+ +
+
+ Full Usage: + this.IsFromPattern +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is in a pattern +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromType + + +

+ +
+
+ Full Usage: + this.IsFromType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is in a syntactic type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFromUse + + +

+ +
+
+ Full Usage: + this.IsFromUse +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the reference is used for example at a call site +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPrivateToFile + + +

+ +
+
+ Full Usage: + this.IsPrivateToFile +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the FSharpSymbolUse is declared as private +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPrivateToFileAndSignatureFile + + +

+ +
+
+ Full Usage: + this.IsPrivateToFileAndSignatureFile +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the FSharpSymbolUse is private to the implementation & signature file. + This is true for function and method parameters. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The range of text representing the reference to the symbol +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.Symbol + + +

+ +
+
+ Full Usage: + this.Symbol +
+
+ + Returns: + FSharpSymbol + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The symbol referenced +

+
+ +
+
+ + Returns: + + FSharpSymbol +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-fsharpunresolvedreferencesset.html b/reference/fsharp-compiler-codeanalysis-fsharpunresolvedreferencesset.html new file mode 100644 index 0000000000..97720fe066 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-fsharpunresolvedreferencesset.html @@ -0,0 +1,529 @@ + + + + + + + + + + + + + + + + + + FSharpUnresolvedReferencesSet (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpUnresolvedReferencesSet Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Unused in this API +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html b/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html new file mode 100644 index 0000000000..5fee4dba3d --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-ilegacyreferenceresolver.html @@ -0,0 +1,909 @@ + + + + + + + + + + + + + + + + + + ILegacyReferenceResolver (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ILegacyReferenceResolver Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + ILegacyReferenceResolver +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DotNetFrameworkReferenceAssembliesRootDirectory + + +

+ +
+
+ Full Usage: + this.DotNetFrameworkReferenceAssembliesRootDirectory +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the Reference Assemblies directory for the .NET Framework (on Windows) + This is added to the default resolution path for + design-time compilations. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.HighestInstalledNetFrameworkVersion + + +

+ +
+
+ Full Usage: + this.HighestInstalledNetFrameworkVersion +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the "v4.5.1"-style moniker for the highest installed .NET Framework version. + This is the value passed back to Resolve if no explicit "mscorlib" has been given. + + Note: If an explicit "mscorlib" is given, then --noframework is being used, and the whole ReferenceResolver logic is essentially + unused. However in the future an option may be added to allow an explicit specification of + a .NET Framework version to use for scripts. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Resolve + + +

+ +
+
+ Full Usage: + this.Resolve +
+
+ Parameters: +
    + + + resolutionEnvironment + + : + LegacyResolutionEnvironment + +
    + + + references + + : + (string * string)[] + +
    + + + targetFrameworkVersion + + : + string + +
    + + + targetFrameworkDirectories + + : + string list + +
    + + + targetProcessorArchitecture + + : + string + +
    + + + fsharpCoreDir + + : + string + +
    + + + explicitIncludeDirs + + : + string list + +
    + + + implicitIncludeDir + + : + string + +
    + + + logMessage + + : + string -> unit + +
    + + + logDiagnostic + + : + bool -> string -> string -> unit + +
    +
+
+ + Returns: + LegacyResolvedFile[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Perform assembly resolution on the given references under the given conditions +

+
+ +
+
+ + resolutionEnvironment + + : + LegacyResolutionEnvironment +
+
+
+ + references + + : + (string * string)[] +
+
+
+ + targetFrameworkVersion + + : + string +
+
+
+ + targetFrameworkDirectories + + : + string list +
+
+
+ + targetProcessorArchitecture + + : + string +
+
+
+ + fsharpCoreDir + + : + string +
+
+
+ + explicitIncludeDirs + + : + string list +
+
+
+ + implicitIncludeDir + + : + string +
+
+
+ + logMessage + + : + string -> unit +
+
+
+ + logDiagnostic + + : + bool -> string -> string -> unit +
+
+
+
+
+ + Returns: + + LegacyResolvedFile[] +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-legacyreferenceresolver.html b/reference/fsharp-compiler-codeanalysis-legacyreferenceresolver.html new file mode 100644 index 0000000000..9a2db60643 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-legacyreferenceresolver.html @@ -0,0 +1,613 @@ + + + + + + + + + + + + + + + + + + LegacyReferenceResolver (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ LegacyReferenceResolver Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + LegacyReferenceResolver(impl) + + +

+ +
+
+ Full Usage: + LegacyReferenceResolver(impl) +
+
+ Parameters: + +
+ + Returns: + LegacyReferenceResolver + +
+
+
+
+ 		+
+
+ + impl + + : + ILegacyReferenceResolver +
+
+
+
+
+ + Returns: + + LegacyReferenceResolver +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-legacyresolutionenvironment.html b/reference/fsharp-compiler-codeanalysis-legacyresolutionenvironment.html new file mode 100644 index 0000000000..11fd762dfd --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-legacyresolutionenvironment.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + LegacyResolutionEnvironment (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ LegacyResolutionEnvironment Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<LegacyResolutionEnvironment> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + CompilationAndEvaluation + + +

+ +
+
+ Full Usage: + CompilationAndEvaluation +
+
+
+
+
+ 		+
+ + + +

+ Indicates a script or source being dynamically compiled and executed. Uses implementation assemblies. +

+
+
+
+ +

+ + + EditingOrCompilation isEditing + + +

+ +
+
+ Full Usage: + EditingOrCompilation isEditing +
+
+ Parameters: +
    + + + isEditing + + : + bool + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Indicates a script or source being edited or compiled. Uses reference assemblies (not implementation assemblies). +

+
+ +
+
+ + isEditing + + : + bool +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-legacyresolutionfailure.html b/reference/fsharp-compiler-codeanalysis-legacyresolutionfailure.html new file mode 100644 index 0000000000..245c445d42 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-legacyresolutionfailure.html @@ -0,0 +1,531 @@ + + + + + + + + + + + + + + + + + + LegacyResolutionFailure (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ LegacyResolutionFailure Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + exn +
+
+ All Interfaces: + ISerializable + , + IStructuralEquatable +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html b/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html new file mode 100644 index 0000000000..52b4ab78d0 --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis-legacyresolvedfile.html @@ -0,0 +1,705 @@ + + + + + + + + + + + + + + + + + + LegacyResolvedFile (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ LegacyResolvedFile Type +

+
+
+ Namespace: + + FSharp.Compiler.CodeAnalysis + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + baggage + + +

+ +
+
+ Full Usage: + baggage +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Round-tripped baggage +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + itemSpec + + +

+ +
+
+ Full Usage: + itemSpec +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Item specification. +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + prepareToolTip + + +

+ +
+
+ Full Usage: + prepareToolTip +
+
+ + Field type: + string * string -> string + +
+
+
+
+ 		+
+ +
+ + + +

+ Prepare textual information about where the assembly was resolved from, used for tooltip output +

+
+ +
+
+ + Field type: + + string * string -> string +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-codeanalysis.html b/reference/fsharp-compiler-codeanalysis.html new file mode 100644 index 0000000000..47b03d5edb --- /dev/null +++ b/reference/fsharp-compiler-codeanalysis.html @@ -0,0 +1,977 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.CodeAnalysis | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.CodeAnalysis Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + DelayedILModuleReader + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Delays the creation of an ILModuleReader +

+
+
+

+ + + DocumentSource + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpChecker + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Used to parse and check F# source code. +

+
+
+

+ + + FSharpCheckFileAnswer + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. +

+
+
+

+ + + FSharpCheckFileResults + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A handle to the results of CheckFileInProject. +

+
+
+

+ + + FSharpCheckProjectResults + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A handle to the results of CheckFileInProject. +

+
+
+

+ + + FSharpParseFileResults + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the results of parsing an F# file and a set of analysis operations based on the parse tree alone. +

+
+
+

+ + + FSharpParsingOptions + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Options used to determine active --define conditionals and other options relevant to parsing files in a project +

+
+
+

+ + + FSharpProjectContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the checking context implied by the ProjectOptions +

+
+
+

+ + + FSharpProjectOptions + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A set of information describing a project or script build configuration. +

+
+
+

+ + + FSharpReferencedProject + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpSymbolUse + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the use of an F# symbol from F# source code +

+
+
+

+ + + FSharpUnresolvedReferencesSet + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Unused in this API +

+
+
+

+ + + ILegacyReferenceResolver + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + LegacyResolutionEnvironment + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + LegacyResolutionFailure + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + LegacyResolvedFile + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-compilerenvironment.html b/reference/fsharp-compiler-compilerenvironment.html new file mode 100644 index 0000000000..27180f3230 --- /dev/null +++ b/reference/fsharp-compiler-compilerenvironment.html @@ -0,0 +1,1163 @@ + + + + + + + + + + + + + + + + + + CompilerEnvironment (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CompilerEnvironment Type +

+
+
+ Namespace: + + FSharp.Compiler + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Information about the compilation environment +

+
+
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + CompilerEnvironment.BinFolderOfDefaultFSharpCompiler(?probePoint) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.BinFolderOfDefaultFSharpCompiler(?probePoint) +
+
+ Parameters: +
    + + + ?probePoint + + : + string + +
    +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running +

+
+ +
+
+ + ?probePoint + + : + string +
+
+
+
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.DefaultReferencesForOrphanSources(assumeDotNetFramework) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.DefaultReferencesForOrphanSources(assumeDotNetFramework) +
+
+ Parameters: +
    + + + assumeDotNetFramework + + : + bool + +
    +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ These are the names of assemblies that should be referenced for .fs or .fsi files that + are not associated with a project. +

+
+ +
+
+ + assumeDotNetFramework + + : + bool +
+
+
+
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.GetConditionalDefinesForEditing(parsingOptions) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.GetConditionalDefinesForEditing(parsingOptions) +
+
+ Parameters: + +
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Return the compilation defines that should be used when editing the given file. +

+
+ +
+
+ + parsingOptions + + : + FSharpParsingOptions +
+
+
+
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.GetDebuggerLanguageID() + + +

+ +
+
+ Full Usage: + CompilerEnvironment.GetDebuggerLanguageID() +
+
+ + Returns: + Guid + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Return the language ID, which is the expression evaluator id that the debugger will use. +

+
+ +
+
+ + Returns: + + Guid +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.IsCheckerSupportedSubcategory(arg1) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.IsCheckerSupportedSubcategory(arg1) +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Return true if this is a subcategory of error or warning message that the language service can emit +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.IsCompilable(arg1) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.IsCompilable(arg1) +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Whether or not this file is compilable +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.IsScriptFile(arg1) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.IsScriptFile(arg1) +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A helpers for dealing with F# files. +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + CompilerEnvironment.MustBeSingleFileProject(arg1) + + +

+ +
+
+ Full Usage: + CompilerEnvironment.MustBeSingleFileProject(arg1) +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Whether or not this file should be a single-file project +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-assemblyresolutionprobe.html b/reference/fsharp-compiler-dependencymanager-assemblyresolutionprobe.html new file mode 100644 index 0000000000..62c20d08fb --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-assemblyresolutionprobe.html @@ -0,0 +1,605 @@ + + + + + + + + + + + + + + + + + + AssemblyResolutionProbe (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ AssemblyResolutionProbe Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + MulticastDelegate +
+
+ All Interfaces: + ICloneable + , + ISerializable +
+
+ Delegate Signature: + AssemblyResolutionProbe(Unit -> string seq) +
+
+
+
+

+ Signature for ResolutionProbe callback + host implements this, it's job is to return a list of assembly paths to probe. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Invoke + + +

+ +
+
+ Full Usage: + this.Invoke +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + string seq +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-assemblyresolvehandler.html b/reference/fsharp-compiler-dependencymanager-assemblyresolvehandler.html new file mode 100644 index 0000000000..8eee484b3f --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-assemblyresolvehandler.html @@ -0,0 +1,635 @@ + + + + + + + + + + + + + + + + + + AssemblyResolveHandler (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ AssemblyResolveHandler Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IDisposable +
+
+
+
+

+ Handle Assembly resolution +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + AssemblyResolveHandler(assemblyProbingPaths) + + +

+ +
+
+ Full Usage: + AssemblyResolveHandler(assemblyProbingPaths) +
+
+ Parameters: + +
+ + Returns: + AssemblyResolveHandler + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new DependencyProvider +

+
+ +
+
+ + assemblyProbingPaths + + : + AssemblyResolutionProbe +
+
+
+
+
+ + Returns: + + AssemblyResolveHandler +
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-dependencyprovider.html b/reference/fsharp-compiler-dependencymanager-dependencyprovider.html new file mode 100644 index 0000000000..c7cf470a9a --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-dependencyprovider.html @@ -0,0 +1,1828 @@ + + + + + + + + + + + + + + + + + + DependencyProvider (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DependencyProvider Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IDisposable +
+
+
+
+

+ Provides DependencyManagement functions. + + The class incrementally collects IDependencyManagerProvider, indexed by key, and + queries them. These are found and instantiated with respect to the compilerTools and outputDir + provided each time the TryFindDependencyManagerByKey and TryFindDependencyManagerInPath are + executed, which are assumed to be invariant over the lifetime of the DependencyProvider. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + DependencyProvider(assemblyProbingPaths, nativeProbingRoots, useResultsCache) + + +

+ +
+
+ Full Usage: + DependencyProvider(assemblyProbingPaths, nativeProbingRoots, useResultsCache) +
+
+ Parameters: + +
+ + Returns: + DependencyProvider + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new DependencyProvider with managed and native resolution and specify caching +

+
+ +
+
+ + assemblyProbingPaths + + : + AssemblyResolutionProbe +
+
+
+ + nativeProbingRoots + + : + NativeResolutionProbe +
+
+
+ + useResultsCache + + : + bool +
+
+
+
+
+ + Returns: + + DependencyProvider +
+
+
+
+
+
+ +

+ + + DependencyProvider(assemblyProbingPaths, nativeProbingRoots) + + +

+ +
+
+ Full Usage: + DependencyProvider(assemblyProbingPaths, nativeProbingRoots) +
+
+ Parameters: + +
+ + Returns: + DependencyProvider + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new DependencyProvider with managed and native resolution +

+
+ +
+
+ + assemblyProbingPaths + + : + AssemblyResolutionProbe +
+
+
+ + nativeProbingRoots + + : + NativeResolutionProbe +
+
+
+
+
+ + Returns: + + DependencyProvider +
+
+
+
+
+
+ +

+ + + DependencyProvider(nativeProbingRoots, useResultsCache) + + +

+ +
+
+ Full Usage: + DependencyProvider(nativeProbingRoots, useResultsCache) +
+
+ Parameters: + +
+ + Returns: + DependencyProvider + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new DependencyProvider with only native resolution and specify caching +

+
+ +
+
+ + nativeProbingRoots + + : + NativeResolutionProbe +
+
+
+ + useResultsCache + + : + bool +
+
+
+
+
+ + Returns: + + DependencyProvider +
+
+
+
+
+
+ +

+ + + DependencyProvider(nativeProbingRoots) + + +

+ +
+
+ Full Usage: + DependencyProvider(nativeProbingRoots) +
+
+ Parameters: + +
+ + Returns: + DependencyProvider + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new DependencyProvider with only native resolution +

+
+ +
+
+ + nativeProbingRoots + + : + NativeResolutionProbe +
+
+
+
+
+ + Returns: + + DependencyProvider +
+
+
+
+
+
+ +

+ + + DependencyProvider() + + +

+ +
+
+ Full Usage: + DependencyProvider() +
+
+ + Returns: + DependencyProvider + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new DependencyProvider with no dynamic load handlers (only for compilation/analysis) +

+
+ +
+
+ + Returns: + + DependencyProvider +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ClearResultsCache + + +

+ +
+
+ Full Usage: + this.ClearResultsCache +
+
+ Parameters: +
    + + + arg0 + + : + string seq + +
    + + + arg1 + + : + string + +
    + + + arg2 + + : + ResolvingErrorReport + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Clear the DependencyManager results caches +

+
+ +
+
+ + arg0 + + : + string seq +
+
+
+ + arg1 + + : + string +
+
+
+ + arg2 + + : + ResolvingErrorReport +
+
+
+
+
+
+ +

+ + + this.CreatePackageManagerUnknownError + + +

+ +
+
+ Full Usage: + this.CreatePackageManagerUnknownError +
+
+ Parameters: +
    + + + arg0 + + : + string seq + +
    + + + arg1 + + : + string + +
    + + + arg2 + + : + string + +
    + + + arg3 + + : + ResolvingErrorReport + +
    +
+
+ + Returns: + int * string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns a formatted error message for the host to present +

+
+ +
+
+ + arg0 + + : + string seq +
+
+
+ + arg1 + + : + string +
+
+
+ + arg2 + + : + string +
+
+
+ + arg3 + + : + ResolvingErrorReport +
+
+
+
+
+ + Returns: + + int * string +
+
+
+
+
+
+ +

+ + + this.GetRegisteredDependencyManagerHelpText + + +

+ +
+
+ Full Usage: + this.GetRegisteredDependencyManagerHelpText +
+
+ Parameters: +
    + + + arg0 + + : + string seq + +
    + + + arg1 + + : + string + +
    + + + arg2 + + : + ResolvingErrorReport + +
    +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns a formatted help messages for registered dependencymanagers for the host to present +

+
+ +
+
+ + arg0 + + : + string seq +
+
+
+ + arg1 + + : + string +
+
+
+ + arg2 + + : + ResolvingErrorReport +
+
+
+
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.Resolve + + +

+ +
+
+ Full Usage: + this.Resolve +
+
+ Parameters: +
    + + + packageManager + + : + IDependencyManagerProvider + +
    + + + scriptExt + + : + string + +
    + + + packageManagerTextLines + + : + (string * string) seq + +
    + + + reportError + + : + ResolvingErrorReport + +
    + + + executionTfm + + : + string + +
    + + + ?executionRid + + : + string + +
    + + + ?implicitIncludeDir + + : + string + +
    + + + ?mainScriptName + + : + string + +
    + + + ?fileName + + : + string + +
    + + + ?timeout + + : + int + +
    +
+
+ + Returns: + IResolveDependenciesResult + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Resolve reference for a list of package manager lines +

+
+ +
+
+ + packageManager + + : + IDependencyManagerProvider +
+
+
+ + scriptExt + + : + string +
+
+
+ + packageManagerTextLines + + : + (string * string) seq +
+
+
+ + reportError + + : + ResolvingErrorReport +
+
+
+ + executionTfm + + : + string +
+
+
+ + ?executionRid + + : + string +
+
+
+ + ?implicitIncludeDir + + : + string +
+
+
+ + ?mainScriptName + + : + string +
+
+
+ + ?fileName + + : + string +
+
+
+ + ?timeout + + : + int +
+
+
+
+
+ + Returns: + + IResolveDependenciesResult +
+
+
+
+
+
+ +

+ + + this.TryFindDependencyManagerByKey + + +

+ +
+
+ Full Usage: + this.TryFindDependencyManagerByKey +
+
+ Parameters: +
    + + + compilerTools + + : + string seq + +
    + + + outputDir + + : + string + +
    + + + reportError + + : + ResolvingErrorReport + +
    + + + key + + : + string + +
    +
+
+ + Returns: + IDependencyManagerProvider MaybeNull + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Fetch a dependencymanager that supports a specific key +

+
+ +
+
+ + compilerTools + + : + string seq +
+
+
+ + outputDir + + : + string +
+
+
+ + reportError + + : + ResolvingErrorReport +
+
+
+ + key + + : + string +
+
+
+
+
+ + Returns: + + IDependencyManagerProvider MaybeNull +
+
+
+
+
+
+ +

+ + + this.TryFindDependencyManagerInPath + + +

+ +
+
+ Full Usage: + this.TryFindDependencyManagerInPath +
+
+ Parameters: +
    + + + compilerTools + + : + string seq + +
    + + + outputDir + + : + string + +
    + + + reportError + + : + ResolvingErrorReport + +
    + + + path + + : + string + +
    +
+
+ + Returns: + string MaybeNull * IDependencyManagerProvider MaybeNull + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ TryFindDependencyManagerInPath - given a #r "key:sometext" go and find a DependencyManager that satisfies the key +

+
+ +
+
+ + compilerTools + + : + string seq +
+
+
+ + outputDir + + : + string +
+
+
+ + reportError + + : + ResolvingErrorReport +
+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string MaybeNull * IDependencyManagerProvider MaybeNull +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-errorreporttype.html b/reference/fsharp-compiler-dependencymanager-errorreporttype.html new file mode 100644 index 0000000000..1b91d297ea --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-errorreporttype.html @@ -0,0 +1,628 @@ + + + + + + + + + + + + + + + + + + ErrorReportType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ErrorReportType Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ErrorReportType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Todo describe this API +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Error + + +

+ +
+
+ Full Usage: + Error +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Warning + + +

+ +
+
+ Full Usage: + Warning +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html b/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html new file mode 100644 index 0000000000..667e970850 --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-idependencymanagerprovider.html @@ -0,0 +1,973 @@ + + + + + + + + + + + + + + + + + + IDependencyManagerProvider (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IDependencyManagerProvider Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IDependencyManagerProvider +
+
+
+
+

+ Wraps access to a DependencyManager implementation +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ClearResultsCache + + +

+ +
+
+ Full Usage: + this.ClearResultsCache +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Clear the results cache +

+
+
+
+ +

+ + + this.HelpMessages + + +

+ +
+
+ Full Usage: + this.HelpMessages +
+
+ + Returns: + string[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The help messages for this dependency manager inster +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.Key + + +

+ +
+
+ Full Usage: + this.Key +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Key that identifies the types of dependencies that this DependencyManager operates on
+ E.g
+     nuget: indicates that this DM is for nuget packages
+     paket: indicates that this DM is for paket scripts, which manage nuget packages, github source dependencies etc ...
+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Name of the dependency manager +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ResolveDependencies + + +

+ +
+
+ Full Usage: + this.ResolveDependencies +
+
+ Parameters: +
    + + + scriptDir + + : + string + +
    + + + mainScriptName + + : + string + +
    + + + scriptName + + : + string + +
    + + + scriptExt + + : + string + +
    + + + packageManagerTextLines + + : + (string * string) seq + +
    + + + tfm + + : + string + +
    + + + rid + + : + string + +
    + + + timeout + + : + int + +
    +
+
+ + Returns: + IResolveDependenciesResult + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Resolve the dependencies, for the given set of arguments, go find the .dll references, scripts and additional include values. +

+
+ +
+
+ + scriptDir + + : + string +
+
+
+ + mainScriptName + + : + string +
+
+
+ + scriptName + + : + string +
+
+
+ + scriptExt + + : + string +
+
+
+ + packageManagerTextLines + + : + (string * string) seq +
+
+
+ + tfm + + : + string +
+
+
+ + rid + + : + string +
+
+
+ + timeout + + : + int +
+
+
+
+
+ + Returns: + + IResolveDependenciesResult +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html b/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html new file mode 100644 index 0000000000..3aa0cbe2f8 --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-iresolvedependenciesresult.html @@ -0,0 +1,924 @@ + + + + + + + + + + + + + + + + + + IResolveDependenciesResult (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IResolveDependenciesResult Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IResolveDependenciesResult +
+
+
+
+

+ The results of ResolveDependencies +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Resolutions + + +

+ +
+
+ Full Usage: + this.Resolutions +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The resolution paths - the full paths to selected resolved dll's. + In scripts this is equivalent to #r @"c:\somepath\to\packages\ResolvedPackage\1.1.1\lib\netstandard2.0\ResolvedAssembly.dll" +

+
+ +
+
+ + Returns: + + string seq +
+
+
+
+
+
+ +

+ + + this.Roots + + +

+ +
+
+ Full Usage: + this.Roots +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 The roots to package directories
+     This points to the root of each located package.
+     The layout of the package manager will be package manager specific.
+     however, the dependency manager dll understands the nuget package layout
+     and so if the package contains folders similar to the nuget layout then
+     the dependency manager will be able to probe and resolve any native dependencies
+     required by the nuget package.
+
+ This path is also equivalent to
+     #I @"c:\somepath\to\packages\1.1.1\ResolvedPackage"
+
+ +
+
+ + Returns: + + string seq +
+
+
+
+
+
+ +

+ + + this.SourceFiles + + +

+ +
+
+ Full Usage: + this.SourceFiles +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The source code file paths +

+
+ +
+
+ + Returns: + + string seq +
+
+
+
+
+
+ +

+ + + this.StdError + + +

+ +
+
+ Full Usage: + this.StdError +
+
+ + Returns: + string[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The resolution error log (process stderr) +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.StdOut + + +

+ +
+
+ Full Usage: + this.StdOut +
+
+ + Returns: + string[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The resolution output log +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.Success + + +

+ +
+
+ Full Usage: + this.Success +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Succeded? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-nativedllresolvehandler.html b/reference/fsharp-compiler-dependencymanager-nativedllresolvehandler.html new file mode 100644 index 0000000000..1aefa7cc80 --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-nativedllresolvehandler.html @@ -0,0 +1,635 @@ + + + + + + + + + + + + + + + + + + NativeDllResolveHandler (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NativeDllResolveHandler Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IDisposable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + NativeDllResolveHandler(nativeProbingRoots) + + +

+ +
+
+ Full Usage: + NativeDllResolveHandler(nativeProbingRoots) +
+
+ Parameters: + +
+ + Returns: + NativeDllResolveHandler + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Construct a new NativeDllResolveHandler +

+
+ +
+
+ + nativeProbingRoots + + : + NativeResolutionProbe +
+
+
+
+
+ + Returns: + + NativeDllResolveHandler +
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-nativeresolutionprobe.html b/reference/fsharp-compiler-dependencymanager-nativeresolutionprobe.html new file mode 100644 index 0000000000..af69726d99 --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-nativeresolutionprobe.html @@ -0,0 +1,605 @@ + + + + + + + + + + + + + + + + + + NativeResolutionProbe (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NativeResolutionProbe Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + MulticastDelegate +
+
+ All Interfaces: + ICloneable + , + ISerializable +
+
+ Delegate Signature: + NativeResolutionProbe(Unit -> string seq) +
+
+
+
+

+ Signature for Native library resolution probe callback + host implements this, it's job is to return a list of package roots to probe. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Invoke + + +

+ +
+
+ Full Usage: + this.Invoke +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + string seq +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager-resolvingerrorreport.html b/reference/fsharp-compiler-dependencymanager-resolvingerrorreport.html new file mode 100644 index 0000000000..ae6c6c367c --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager-resolvingerrorreport.html @@ -0,0 +1,644 @@ + + + + + + + + + + + + + + + + + + ResolvingErrorReport (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ResolvingErrorReport Type +

+
+
+ Namespace: + + FSharp.Compiler.DependencyManager + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + MulticastDelegate +
+
+ All Interfaces: + ICloneable + , + ISerializable +
+
+ Delegate Signature: + ResolvingErrorReport(ErrorReportType * int * string -> unit) +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Invoke + + +

+ +
+
+ Full Usage: + this.Invoke +
+
+ Parameters: +
    + + + arg0 + + : + ErrorReportType + +
    + + + arg1 + + : + int + +
    + + + arg2 + + : + string + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + arg0 + + : + ErrorReportType +
+
+
+ + arg1 + + : + int +
+
+
+ + arg2 + + : + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-dependencymanager.html b/reference/fsharp-compiler-dependencymanager.html new file mode 100644 index 0000000000..d294faeb15 --- /dev/null +++ b/reference/fsharp-compiler-dependencymanager.html @@ -0,0 +1,768 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.DependencyManager | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.DependencyManager Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + AssemblyResolutionProbe + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Signature for ResolutionProbe callback + host implements this, it's job is to return a list of assembly paths to probe. +

+
+
+

+ + + AssemblyResolveHandler + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Handle Assembly resolution +

+
+
+

+ + + DependencyProvider + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Provides DependencyManagement functions. + + The class incrementally collects IDependencyManagerProvider, indexed by key, and + queries them. These are found and instantiated with respect to the compilerTools and outputDir + provided each time the TryFindDependencyManagerByKey and TryFindDependencyManagerInPath are + executed, which are assumed to be invariant over the lifetime of the DependencyProvider. +

+
+
+

+ + + ErrorReportType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Todo describe this API +

+
+
+

+ + + IDependencyManagerProvider + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Wraps access to a DependencyManager implementation +

+
+
+

+ + + IResolveDependenciesResult + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The results of ResolveDependencies +

+
+
+

+ + + NativeDllResolveHandler + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NativeResolutionProbe + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Signature for Native library resolution probe callback + host implements this, it's job is to return a list of package roots to probe. +

+
+
+

+ + + ResolvingErrorReport + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-activitynames.html b/reference/fsharp-compiler-diagnostics-activitynames.html new file mode 100644 index 0000000000..c14a6250cd --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-activitynames.html @@ -0,0 +1,666 @@ + + + + + + + + + + + + + + + + + + ActivityNames (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ActivityNames Module +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ For activities following the dotnet distributed tracing concept + https://learn.microsoft.com/dotnet/core/diagnostics/distributed-tracing-concepts?source=recommendations +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + ActivityNames.AllRelevantNames + + +

+ +
+
+ Full Usage: + ActivityNames.AllRelevantNames +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+
+ + Returns: + + string[] +
+
+
+
+
+ +

+ + + ActivityNames.FscSourceName + + +

+ +
+
+ Full Usage: + ActivityNames.FscSourceName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + ActivityNames.ProfiledSourceName + + +

+ +
+
+ Full Usage: + ActivityNames.ProfiledSourceName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-compilerdiagnostics.html b/reference/fsharp-compiler-diagnostics-compilerdiagnostics.html new file mode 100644 index 0000000000..cf74fff10b --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-compilerdiagnostics.html @@ -0,0 +1,723 @@ + + + + + + + + + + + + + + + + + + CompilerDiagnostics (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CompilerDiagnostics Module +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Exposes compiler diagnostic error messages. +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + GetErrorMessage diagnosticKind + + +

+ +
+
+ Full Usage: + GetErrorMessage diagnosticKind +
+
+ Parameters: + +
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Given a DiagnosticKind, returns the string representing the error message for that diagnostic. +

+
+ +
+
+ + diagnosticKind + + : + FSharpDiagnosticKind +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + GetSuggestedNames suggestionsF unresolvedIdentifier + + +

+ +
+
+ Full Usage: + GetSuggestedNames suggestionsF unresolvedIdentifier +
+
+ Parameters: +
    + + + suggestionsF + + : + (string -> unit) -> unit + +
    + + + unresolvedIdentifier + + : + string + +
    +
+
+ + Returns: + string seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Given a set of names, uses and a string representing an unresolved identifier, + returns a list of suggested names if there are any feasible candidates. +

+
+ +
+
+ + suggestionsF + + : + (string -> unit) -> unit +
+
+
+ + unresolvedIdentifier + + : + string +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html new file mode 100644 index 0000000000..3b31359cdd --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-argumentsinsigandimplmismatchextendeddata.html @@ -0,0 +1,790 @@ + + + + + + + + + + + + + + + + + + ArgumentsInSigAndImplMismatchExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ArgumentsInSigAndImplMismatchExtendedData Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFSharpDiagnosticExtendedData +
+
+
+
+

+ Additional data for 'argument names in the signature and implementation do not match' diagnostic +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ImplementationName + + +

+ +
+
+ Full Usage: + this.ImplementationName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Argument name in implementation file +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ImplementationRange + + +

+ +
+
+ Full Usage: + this.ImplementationRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Argument identifier range within implementation file +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.SignatureName + + +

+ +
+
+ Full Usage: + this.SignatureName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Argument name in signature file +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.SignatureRange + + +

+ +
+
+ Full Usage: + this.SignatureRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Argument identifier range within signature file +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html b/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html new file mode 100644 index 0000000000..1c5e3e1f61 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-diagnosticcontextinfo.html @@ -0,0 +1,1030 @@ + + + + + + + + + + + + + + + + + + DiagnosticContextInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DiagnosticContextInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<DiagnosticContextInfo> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Information about the context of a type equation in type-mismatch-like diagnostic +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + CollectionElement + + +

+ +
+
+ Full Usage: + CollectionElement +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a list or array constructor +

+
+
+
+ +

+ + + DowncastUsedInsteadOfUpcast + + +

+ +
+
+ Full Usage: + DowncastUsedInsteadOfUpcast +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from an downcast where a upcast could be used +

+
+
+
+ +

+ + + ElseBranchResult + + +

+ +
+
+ Full Usage: + ElseBranchResult +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a type check of the result of an else branch +

+
+
+
+ +

+ + + FollowingPatternMatchClause + + +

+ +
+
+ Full Usage: + FollowingPatternMatchClause +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a return type of a pattern match clause (not the first clause) +

+
+
+
+ +

+ + + IfExpression + + +

+ +
+
+ Full Usage: + IfExpression +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from an IF expression +

+
+
+
+ +

+ + + NoContext + + +

+ +
+
+ Full Usage: + NoContext +
+
+
+
+
+ 		+
+ + + +

+ No context was given +

+
+
+
+ +

+ + + OmittedElseBranch + + +

+ +
+
+ Full Usage: + OmittedElseBranch +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from an omitted else branch +

+
+
+
+ +

+ + + PatternMatchGuard + + +

+ +
+
+ Full Usage: + PatternMatchGuard +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a pattern match guard +

+
+
+
+ +

+ + + RecordFields + + +

+ +
+
+ Full Usage: + RecordFields +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from the verification of record fields +

+
+
+
+ +

+ + + ReturnInComputationExpression + + +

+ +
+
+ Full Usage: + ReturnInComputationExpression +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a return in a computation expression +

+
+
+
+ +

+ + + RuntimeTypeTest + + +

+ +
+
+ Full Usage: + RuntimeTypeTest +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a runtime type test +

+
+
+
+ +

+ + + SequenceExpression + + +

+ +
+
+ Full Usage: + SequenceExpression +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a sequence expression +

+
+
+
+ +

+ + + TupleInRecordFields + + +

+ +
+
+ Full Usage: + TupleInRecordFields +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from the verification of a tuple in record fields +

+
+
+
+ +

+ + + YieldInComputationExpression + + +

+ +
+
+ Full Usage: + YieldInComputationExpression +
+
+
+
+
+ 		+
+ + + +

+ The type equation comes from a yield in a computation expression +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-expressionisafunctionextendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata-expressionisafunctionextendeddata.html new file mode 100644 index 0000000000..264b3d540f --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-expressionisafunctionextendeddata.html @@ -0,0 +1,619 @@ + + + + + + + + + + + + + + + + + + ExpressionIsAFunctionExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ExpressionIsAFunctionExtendedData Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFSharpDiagnosticExtendedData +
+
+
+
+

+ Additional data for 'This expression is a function value, i.e. is missing arguments' diagnostic +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ActualType + + +

+ +
+
+ Full Usage: + this.ActualType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# type of the expression +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-fieldnotcontaineddiagnosticextendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata-fieldnotcontaineddiagnosticextendeddata.html new file mode 100644 index 0000000000..249f2e66eb --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-fieldnotcontaineddiagnosticextendeddata.html @@ -0,0 +1,676 @@ + + + + + + + + + + + + + + + + + + FieldNotContainedDiagnosticExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FieldNotContainedDiagnosticExtendedData Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFSharpDiagnosticExtendedData +
+
+
+
+

+ Additional data for diagnostics about a field whose declarations differ in signature and implementation +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ImplementationField + + +

+ +
+
+ Full Usage: + this.ImplementationField +
+
+ + Returns: + FSharpField + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# field in implementation file +

+
+ +
+
+ + Returns: + + FSharpField +
+
+
+
+
+
+ +

+ + + this.SignatureField + + +

+ +
+
+ Full Usage: + this.SignatureField +
+
+ + Returns: + FSharpField + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# field in signature file +

+
+ +
+
+ + Returns: + + FSharpField +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-ifsharpdiagnosticextendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata-ifsharpdiagnosticextendeddata.html new file mode 100644 index 0000000000..5f2a6bbba5 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-ifsharpdiagnosticextendeddata.html @@ -0,0 +1,535 @@ + + + + + + + + + + + + + + + + + + IFSharpDiagnosticExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IFSharpDiagnosticExtendedData Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFSharpDiagnosticExtendedData +
+
+
+
+

+ Contextually-relevant data to each particular diagnostic +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html new file mode 100644 index 0000000000..3e56bb5895 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-typemismatchdiagnosticextendeddata.html @@ -0,0 +1,790 @@ + + + + + + + + + + + + + + + + + + TypeMismatchDiagnosticExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ TypeMismatchDiagnosticExtendedData Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFSharpDiagnosticExtendedData +
+
+
+
+

+ Additional data for type-mismatch-like (usually with ErrorNumber = 1) diagnostics +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ActualType + + +

+ +
+
+ Full Usage: + this.ActualType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# type type actual in the current context +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.ContextInfo + + +

+ +
+
+ Full Usage: + this.ContextInfo +
+
+ + Returns: + DiagnosticContextInfo + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The context in which the type mismatch was found +

+
+ +
+
+ + Returns: + + DiagnosticContextInfo +
+
+
+
+
+
+ +

+ + + this.DisplayContext + + +

+ +
+
+ Full Usage: + this.DisplayContext +
+
+ + Returns: + FSharpDisplayContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents the information needed to format types +

+
+ +
+
+ + Returns: + + FSharpDisplayContext +
+
+
+
+
+
+ +

+ + + this.ExpectedType + + +

+ +
+
+ Full Usage: + this.ExpectedType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# type expected in the current context +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata-valuenotcontaineddiagnosticextendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata-valuenotcontaineddiagnosticextendeddata.html new file mode 100644 index 0000000000..324433389d --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata-valuenotcontaineddiagnosticextendeddata.html @@ -0,0 +1,676 @@ + + + + + + + + + + + + + + + + + + ValueNotContainedDiagnosticExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ValueNotContainedDiagnosticExtendedData Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + ExtendedData + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFSharpDiagnosticExtendedData +
+
+
+
+

+ Additional data for diagnostics about a value whose declarations differ in signature and implementation +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ImplementationValue + + +

+ +
+
+ Full Usage: + this.ImplementationValue +
+
+ + Returns: + FSharpMemberOrFunctionOrValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# value in implementation file +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue +
+
+
+
+
+
+ +

+ + + this.SignatureValue + + +

+ +
+
+ Full Usage: + this.SignatureValue +
+
+ + Returns: + FSharpMemberOrFunctionOrValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Represents F# value in signature file +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-extendeddata.html b/reference/fsharp-compiler-diagnostics-extendeddata.html new file mode 100644 index 0000000000..fe8810af3e --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-extendeddata.html @@ -0,0 +1,729 @@ + + + + + + + + + + + + + + + + + + ExtendedData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ExtendedData Module +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + ArgumentsInSigAndImplMismatchExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Additional data for 'argument names in the signature and implementation do not match' diagnostic +

+
+
+

+ + + DiagnosticContextInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Information about the context of a type equation in type-mismatch-like diagnostic +

+
+
+

+ + + ExpressionIsAFunctionExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Additional data for 'This expression is a function value, i.e. is missing arguments' diagnostic +

+
+
+

+ + + FieldNotContainedDiagnosticExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Additional data for diagnostics about a field whose declarations differ in signature and implementation +

+
+
+

+ + + IFSharpDiagnosticExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Contextually-relevant data to each particular diagnostic +

+
+
+

+ + + TypeMismatchDiagnosticExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Additional data for type-mismatch-like (usually with ErrorNumber = 1) diagnostics +

+
+
+

+ + + ValueNotContainedDiagnosticExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Additional data for diagnostics about a value whose declarations differ in signature and implementation +

+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html b/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html new file mode 100644 index 0000000000..f46ceeaa73 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-fsharpdiagnostic.html @@ -0,0 +1,1744 @@ + + + + + + + + + + + + + + + + + + FSharpDiagnostic (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpDiagnostic Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a diagnostic produced by the F# compiler +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.End + + +

+ +
+
+ Full Usage: + this.End +
+
+ + Returns: + Position + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the end position for the diagnostic +

+
+ +
+
+ + Returns: + + Position +
+
+
+
+
+
+ +

+ + + this.EndColumn + + +

+ +
+
+ Full Usage: + this.EndColumn +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the end column for the diagnostic +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.EndLine + + +

+ +
+
+ Full Usage: + this.EndLine +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the end line for the diagnostic +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.ErrorNumber + + +

+ +
+
+ Full Usage: + this.ErrorNumber +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the number for the diagnostic +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.ErrorNumberPrefix + + +

+ +
+
+ Full Usage: + this.ErrorNumberPrefix +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the number prefix for the diagnostic, usually "FS" but may differ for analyzers +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ErrorNumberText + + +

+ +
+
+ Full Usage: + this.ErrorNumberText +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the full error number text e.g "FS0031" +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ExtendedData + + +

+ +
+
+ Full Usage: + this.ExtendedData +
+
+ + Returns: + IFSharpDiagnosticExtendedData option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the contextually-relevant data to each particular diagnostic for things like code fixes +

+
+ +
+
+ + Returns: + + IFSharpDiagnosticExtendedData option +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the file name for the diagnostic +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Message + + +

+ +
+
+ Full Usage: + this.Message +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the message for the diagnostic +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the range for the diagnostic +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.Severity + + +

+ +
+
+ Full Usage: + this.Severity +
+
+ + Returns: + FSharpDiagnosticSeverity + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the severity for the diagnostic +

+
+ +
+
+ + Returns: + + FSharpDiagnosticSeverity +
+
+
+
+
+
+ +

+ + + this.Start + + +

+ +
+
+ Full Usage: + this.Start +
+
+ + Returns: + Position + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the start position for the diagnostic +

+
+ +
+
+ + Returns: + + Position +
+
+
+
+
+
+ +

+ + + this.StartColumn + + +

+ +
+
+ Full Usage: + this.StartColumn +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the start column for the diagnostic +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.StartLine + + +

+ +
+
+ Full Usage: + this.StartLine +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the start line for the diagnostic +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.Subcategory + + +

+ +
+
+ Full Usage: + this.Subcategory +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the sub-category for the diagnostic +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpDiagnostic.Create(severity, message, number, range, ?numberPrefix, ?subcategory) + + +

+ +
+
+ Full Usage: + FSharpDiagnostic.Create(severity, message, number, range, ?numberPrefix, ?subcategory) +
+
+ Parameters: +
    + + + severity + + : + FSharpDiagnosticSeverity + +
    + + + message + + : + string + +
    + + + number + + : + int + +
    + + + range + + : + range + +
    + + + ?numberPrefix + + : + string + +
    + + + ?subcategory + + : + string + +
    +
+
+ + Returns: + FSharpDiagnostic + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates a diagnostic, e.g. for reporting from an analyzer +

+
+ +
+
+ + severity + + : + FSharpDiagnosticSeverity +
+
+
+ + message + + : + string +
+
+
+ + number + + : + int +
+
+
+ + range + + : + range +
+
+
+ + ?numberPrefix + + : + string +
+
+
+ + ?subcategory + + : + string +
+
+
+
+
+ + Returns: + + FSharpDiagnostic +
+
+
+
+
+
+ +

+ + + FSharpDiagnostic.NewlineifyErrorString(message) + + +

+ +
+
+ Full Usage: + FSharpDiagnostic.NewlineifyErrorString(message) +
+
+ Parameters: +
    + + + message + + : + string + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Newlines are recognized and replaced with (ASCII 29, the 'group separator'), + which is decoded by the IDE with 'NewlineifyErrorString' back into newlines, so that multi-line errors can be displayed in QuickInfo +

+
+ +
+
+ + message + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + FSharpDiagnostic.NormalizeErrorString(text) + + +

+ +
+
+ Full Usage: + FSharpDiagnostic.NormalizeErrorString(text) +
+
+ Parameters: +
    + + + text + + : + string + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Newlines are recognized and replaced with (ASCII 29, the 'group separator'), + which is decoded by the IDE with 'NewlineifyErrorString' back into newlines, so that multi-line errors can be displayed in QuickInfo +

+
+ +
+
+ + text + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html b/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html new file mode 100644 index 0000000000..ac37b4c610 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-fsharpdiagnostickind.html @@ -0,0 +1,675 @@ + + + + + + + + + + + + + + + + + + FSharpDiagnosticKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpDiagnosticKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpDiagnosticKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Supported kinds of diagnostics by this service. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AddIndexerDot + + +

+ +
+
+ Full Usage: + AddIndexerDot +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RemoveIndexerDot + + +

+ +
+
+ Full Usage: + RemoveIndexerDot +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ReplaceWithSuggestion suggestion + + +

+ +
+
+ Full Usage: + ReplaceWithSuggestion suggestion +
+
+ Parameters: +
    + + + suggestion + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + suggestion + + : + string +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html b/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html new file mode 100644 index 0000000000..c0eeb85a75 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-fsharpdiagnosticoptions.html @@ -0,0 +1,910 @@ + + + + + + + + + + + + + + + + + + FSharpDiagnosticOptions (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpDiagnosticOptions Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpDiagnosticOptions> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + GlobalWarnAsError + + +

+ +
+
+ Full Usage: + GlobalWarnAsError +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + WarnAsError + + +

+ +
+
+ Full Usage: + WarnAsError +
+
+ + Field type: + int list + +
+
+
+
+ 		+
+
+ + Field type: + + int list +
+
+
+
+
+ +

+ + + WarnAsWarn + + +

+ +
+
+ Full Usage: + WarnAsWarn +
+
+ + Field type: + int list + +
+
+
+
+ 		+
+
+ + Field type: + + int list +
+
+
+
+
+ +

+ + + WarnLevel + + +

+ +
+
+ Full Usage: + WarnLevel +
+
+ + Field type: + int + +
+
+
+
+ 		+
+
+ + Field type: + + int +
+
+
+
+
+ +

+ + + WarnOff + + +

+ +
+
+ Full Usage: + WarnOff +
+
+ + Field type: + int list + +
+
+
+
+ 		+
+
+ + Field type: + + int list +
+
+
+
+
+ +

+ + + WarnOn + + +

+ +
+
+ Full Usage: + WarnOn +
+
+ + Field type: + int list + +
+
+
+
+ 		+
+
+ + Field type: + + int list +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CheckXmlDocs + + +

+ +
+
+ Full Usage: + this.CheckXmlDocs +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpDiagnosticOptions.Default + + +

+ +
+
+ Full Usage: + FSharpDiagnosticOptions.Default +
+
+ + Returns: + FSharpDiagnosticOptions + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpDiagnosticOptions +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html b/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html new file mode 100644 index 0000000000..bb369c44b8 --- /dev/null +++ b/reference/fsharp-compiler-diagnostics-fsharpdiagnosticseverity.html @@ -0,0 +1,694 @@ + + + + + + + + + + + + + + + + + + FSharpDiagnosticSeverity (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpDiagnosticSeverity Type +

+
+
+ Namespace: + + FSharp.Compiler.Diagnostics + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpDiagnosticSeverity> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Error + + +

+ +
+
+ Full Usage: + Error +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Hidden + + +

+ +
+
+ Full Usage: + Hidden +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Info + + +

+ +
+
+ Full Usage: + Info +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Warning + + +

+ +
+
+ Full Usage: + Warning +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-diagnostics.html b/reference/fsharp-compiler-diagnostics.html new file mode 100644 index 0000000000..69ceeec3da --- /dev/null +++ b/reference/fsharp-compiler-diagnostics.html @@ -0,0 +1,708 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Diagnostics | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Diagnostics Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + ActivityNames + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ For activities following the dotnet distributed tracing concept + https://learn.microsoft.com/dotnet/core/diagnostics/distributed-tracing-concepts?source=recommendations +

+
+
+

+ + + CompilerDiagnostics + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Exposes compiler diagnostic error messages. +

+
+
+

+ + + ExtendedData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpDiagnostic + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a diagnostic produced by the F# compiler +

+
+
+

+ + + FSharpDiagnosticKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Supported kinds of diagnostics by this service. +

+
+
+

+ + + FSharpDiagnosticOptions + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpDiagnosticSeverity + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-assemblycontent.html b/reference/fsharp-compiler-editorservices-assemblycontent.html new file mode 100644 index 0000000000..577201f3e4 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-assemblycontent.html @@ -0,0 +1,770 @@ + + + + + + + + + + + + + + + + + + AssemblyContent (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ AssemblyContent Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Provides assembly content. +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + GetAssemblyContent withCache contentType fileName assemblies + + +

+ +
+
+ Full Usage: + GetAssemblyContent withCache contentType fileName assemblies +
+
+ Parameters: + +
+ + Returns: + AssemblySymbol list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns (possibly cached) assembly content. +

+
+ +
+
+ + withCache + + : + (IAssemblyContentCache -> AssemblySymbol list) -> AssemblySymbol list +
+
+
+ + contentType + + : + AssemblyContentType +
+
+
+ + fileName + + : + string option +
+
+
+ + assemblies + + : + FSharpAssembly list +
+
+
+
+
+ + Returns: + + AssemblySymbol list +
+
+
+
+
+
+ +

+ + + GetAssemblySignatureContent arg1 arg2 + + +

+ +
+
+ Full Usage: + GetAssemblySignatureContent arg1 arg2 +
+
+ Parameters: + +
+ + Returns: + AssemblySymbol list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Given a `FSharpAssemblySignature`, returns assembly content. +

+
+ +
+
+ + arg0 + + : + AssemblyContentType +
+
+
+ + arg1 + + : + FSharpAssemblySignature +
+
+
+
+
+ + Returns: + + AssemblySymbol list +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-assemblycontenttype.html b/reference/fsharp-compiler-editorservices-assemblycontenttype.html new file mode 100644 index 0000000000..afe47a7032 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-assemblycontenttype.html @@ -0,0 +1,628 @@ + + + + + + + + + + + + + + + + + + AssemblyContentType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ AssemblyContentType Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<AssemblyContentType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Assembly content type. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Full + + +

+ +
+
+ Full Usage: + Full +
+
+
+
+
+ 		+
+ + + +

+ All assembly content. +

+
+
+
+ +

+ + + Public + + +

+ +
+
+ Full Usage: + Public +
+
+
+
+
+ 		+
+ + + +

+ Public assembly content only. +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-assemblysymbol.html b/reference/fsharp-compiler-editorservices-assemblysymbol.html new file mode 100644 index 0000000000..90e187f5f0 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-assemblysymbol.html @@ -0,0 +1,1001 @@ + + + + + + + + + + + + + + + + + + AssemblySymbol (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ AssemblySymbol Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents type, module, member, function or value in a compiled assembly. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AutoOpenParent + + +

+ +
+
+ Full Usage: + AutoOpenParent +
+
+ + Field type: + ShortIdents option + +
+
+
+
+ 		+
+ +
+ + + +

+ Parent module that has `AutoOpen` attribute. +

+
+ +
+
+ + Field type: + + ShortIdents option +
+
+
+
+
+
+ +

+ + + CleanedIdents + + +

+ +
+
+ Full Usage: + CleanedIdents +
+
+ + Field type: + ShortIdents + +
+
+
+
+ 		+
+ +
+ + + +

+ Entity name parts with removed module suffixes (Ns.M1Module.M2Module.M3.entity -> Ns.M1.M2.M3.entity) + and replaced compiled names with display names (FSharpEntity.DisplayName, FSharpValueOrFunction.DisplayName). + Note: *all* parts are cleaned, not the last one. +

+
+ +
+
+ + Field type: + + ShortIdents +
+
+
+
+
+
+ +

+ + + FullName + + +

+ +
+
+ Full Usage: + FullName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Full entity name as it's seen in compiled code (raw FSharpEntity.FullName, FSharpValueOrFunction.FullName). +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + Kind + + +

+ +
+
+ Full Usage: + Kind +
+
+ + Field type: + LookupType -> EntityKind + +
+
+
+
+ 		+
+ +
+ + + +

+ Function that returns `EntityKind` based of given `LookupKind`. +

+
+ +
+
+ + Field type: + + LookupType -> EntityKind +
+
+
+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+ + Field type: + ShortIdents option + +
+
+
+
+ 		+
+ +
+ + + +

+ `FSharpEntity.Namespace`. +

+
+ +
+
+ + Field type: + + ShortIdents option +
+
+
+
+
+
+ +

+ + + NearestRequireQualifiedAccessParent + + +

+ +
+
+ Full Usage: + NearestRequireQualifiedAccessParent +
+
+ + Field type: + ShortIdents option + +
+
+
+
+ 		+
+ +
+ + + +

+ The most narrative parent module that has `RequireQualifiedAccess` attribute. +

+
+ +
+
+ + Field type: + + ShortIdents option +
+
+
+
+
+
+ +

+ + + Symbol + + +

+ +
+
+ Full Usage: + Symbol +
+
+ + Field type: + FSharpSymbol + +
+
+
+
+ 		+
+
+ + Field type: + + FSharpSymbol +
+
+
+
+
+ +

+ + + TopRequireQualifiedAccessParent + + +

+ +
+
+ Full Usage: + TopRequireQualifiedAccessParent +
+
+ + Field type: + ShortIdents option + +
+
+
+
+ 		+
+ +
+ + + +

+ Parent module that has the largest scope and has `RequireQualifiedAccess` attribute. +

+
+ +
+
+ + Field type: + + ShortIdents option +
+
+
+
+
+
+ +

+ + + UnresolvedSymbol + + +

+ +
+
+ Full Usage: + UnresolvedSymbol +
+
+ + Field type: + UnresolvedSymbol + +
+
+
+
+ 		+
+ +
+ + + +

+ Cache display name and namespace, used for completion. +

+
+ +
+
+ + Field type: + + UnresolvedSymbol +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-completioncontext.html b/reference/fsharp-compiler-editorservices-completioncontext.html new file mode 100644 index 0000000000..20ab93d4b3 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-completioncontext.html @@ -0,0 +1,1131 @@ + + + + + + + + + + + + + + + + + + CompletionContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CompletionContext Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AttributeApplication + + +

+ +
+
+ Full Usage: + AttributeApplication +
+
+
+
+
+ 		+
+ + + +

+ Completing an attribute name, outside of the constructor +

+
+
+
+ +

+ + + Inherit(context, path) + + +

+ +
+
+ Full Usage: + Inherit(context, path) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Completing something after the inherit keyword +

+
+ +
+
+ + context + + : + InheritanceContext +
+
+
+ + path + + : + CompletionPath +
+
+
+
+
+
+ +

+ + + Invalid + + +

+ +
+
+ Full Usage: + Invalid +
+
+
+
+
+ 		+
+ + + +

+ Completion context cannot be determined due to errors +

+
+
+
+ +

+ + + MethodOverride enclosingTypeNameRange + + +

+ +
+
+ Full Usage: + MethodOverride enclosingTypeNameRange +
+
+ Parameters: +
    + + + enclosingTypeNameRange + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Completing a method override (e.g. override this.ToStr|) +

+
+ +
+
+ + enclosingTypeNameRange + + : + range +
+
+
+
+
+
+ +

+ + + OpenDeclaration isOpenType + + +

+ +
+
+ Full Usage: + OpenDeclaration isOpenType +
+
+ Parameters: +
    + + + isOpenType + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + isOpenType + + : + bool +
+
+
+
+
+ +

+ + + ParameterList(pos, HashSet<string>) + + +

+ +
+
+ Full Usage: + ParameterList(pos, HashSet<string>) +
+
+ Parameters: +
    + + + Item1 + + : + pos + +
    + + + Item2 + + : + HashSet<string> + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Completing named parameters\setters in parameter list of attributes\constructor\method calls + end of name ast node * list of properties\parameters that were already set +

+
+ +
+
+ + Item1 + + : + pos +
+
+
+ + Item2 + + : + HashSet<string> +
+
+
+
+
+
+ +

+ + + Pattern context + + +

+ +
+
+ Full Usage: + Pattern context +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Completing a pattern in a match clause, member/let binding or lambda +

+
+ +
+
+ + context + + : + PatternContext +
+
+
+
+
+
+ +

+ + + RangeOperator + + +

+ +
+
+ Full Usage: + RangeOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RecordField context + + +

+ +
+
+ Full Usage: + RecordField context +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Completing records field +

+
+ +
+
+ + context + + : + RecordContext +
+
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ Completing a type annotation (e.g. foo (x: |)) + Completing a type application (e.g. typeof) +

+
+
+
+ +

+ + + TypeAbbreviationOrSingleCaseUnion + + +

+ +
+
+ Full Usage: + TypeAbbreviationOrSingleCaseUnion +
+
+
+
+
+ 		+
+ + + +

+ Completing a type abbreviation (e.g. type Long = int6|) + or a single case union without a bar (type SomeUnion = Abc|) +

+
+
+
+ +

+ + + UnionCaseFieldsDeclaration + + +

+ +
+
+ Full Usage: + UnionCaseFieldsDeclaration +
+
+
+
+
+ 		+
+ + + +

+ Completing union case fields declaration (e.g. 'A of stri|' but not 'B of tex|: string') +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-completionitemkind.html b/reference/fsharp-compiler-editorservices-completionitemkind.html new file mode 100644 index 0000000000..ced08e8271 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-completionitemkind.html @@ -0,0 +1,840 @@ + + + + + + + + + + + + + + + + + + CompletionItemKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CompletionItemKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<CompletionItemKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Argument + + +

+ +
+
+ Full Usage: + Argument +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + CustomOperation + + +

+ +
+
+ Full Usage: + CustomOperation +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Event + + +

+ +
+
+ Full Usage: + Event +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Field + + +

+ +
+
+ Full Usage: + Field +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Method isExtension + + +

+ +
+
+ Full Usage: + Method isExtension +
+
+ Parameters: +
    + + + isExtension + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + isExtension + + : + bool +
+
+
+
+
+ +

+ + + Other + + +

+ +
+
+ Full Usage: + Other +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Property + + +

+ +
+
+ Full Usage: + Property +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SuggestedName + + +

+ +
+
+ Full Usage: + SuggestedName +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-declarationlistinfo.html b/reference/fsharp-compiler-editorservices-declarationlistinfo.html new file mode 100644 index 0000000000..5f8ab8b120 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-declarationlistinfo.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + DeclarationListInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DeclarationListInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a set of declarations in F# source code, with information attached ready for display by an editor. + Returned by GetDeclarations. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsError + + +

+ +
+
+ Full Usage: + this.IsError +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsForType + + +

+ +
+
+ Full Usage: + this.IsForType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Items + + +

+ +
+
+ Full Usage: + this.Items +
+
+ + Returns: + DeclarationListItem[] + +
+
+
+
+ 		+
+
+ + Returns: + + DeclarationListItem[] +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + DeclarationListInfo.Empty + + +

+ +
+
+ Full Usage: + DeclarationListInfo.Empty +
+
+ + Returns: + DeclarationListInfo + +
+
+
+
+ 		+
+
+ + Returns: + + DeclarationListInfo +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-declarationlistitem.html b/reference/fsharp-compiler-editorservices-declarationlistitem.html new file mode 100644 index 0000000000..5a6aab64f9 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-declarationlistitem.html @@ -0,0 +1,1094 @@ + + + + + + + + + + + + + + + + + + DeclarationListItem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DeclarationListItem Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a declaration in F# source code, with information attached ready for display by an editor. + Returned by GetDeclarations. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Accessibility + + +

+ +
+
+ Full Usage: + this.Accessibility +
+
+ + Returns: + FSharpAccessibility + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the accessibility of the item +

+
+ +
+
+ + Returns: + + FSharpAccessibility +
+
+
+
+
+
+ +

+ + + this.Description + + +

+ +
+
+ Full Usage: + this.Description +
+
+ + Returns: + ToolTipText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the description +

+
+ +
+
+ + Returns: + + ToolTipText +
+
+
+
+
+
+ +

+ + + this.FullName + + +

+ +
+
+ Full Usage: + this.FullName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.Glyph + + +

+ +
+
+ Full Usage: + this.Glyph +
+
+ + Returns: + FSharpGlyph + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the glyph to use +

+
+ +
+
+ + Returns: + + FSharpGlyph +
+
+
+
+
+
+ +

+ + + this.IsOwnMember + + +

+ +
+
+ Full Usage: + this.IsOwnMember +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsResolved + + +

+ +
+
+ Full Usage: + this.IsResolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Kind + + +

+ +
+
+ Full Usage: + this.Kind +
+
+ + Returns: + CompletionItemKind + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the completion kind of the item +

+
+ +
+
+ + Returns: + + CompletionItemKind +
+
+
+
+
+
+ +

+ + + this.MinorPriority + + +

+ +
+
+ Full Usage: + this.MinorPriority +
+
+ + Returns: + int + +
+
+
+
+ 		+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + this.NameInCode + + +

+ +
+
+ Full Usage: + this.NameInCode +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the text for the declaration as it's to be inserted into source code. + + This is a display name with backticks if necessary. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.NameInList + + +

+ +
+
+ Full Usage: + this.NameInList +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the text to display in the declaration list for the declaration. + + This is a display name without backticks. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.NamespaceToOpen + + +

+ +
+
+ Full Usage: + this.NamespaceToOpen +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+
+ + Returns: + + string option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-entitycache.html b/reference/fsharp-compiler-editorservices-entitycache.html new file mode 100644 index 0000000000..5ffed1f3f6 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-entitycache.html @@ -0,0 +1,731 @@ + + + + + + + + + + + + + + + + + + EntityCache (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ EntityCache Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IAssemblyContentCache +
+
+
+
+

+ Thread safe wrapper over `IAssemblyContentCache`. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + EntityCache() + + +

+ +
+
+ Full Usage: + EntityCache() +
+
+ + Returns: + EntityCache + +
+
+
+
+ 		+
+
+ + Returns: + + EntityCache +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Clear + + +

+ +
+
+ Full Usage: + this.Clear +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Clears the cache. +

+
+
+
+ +

+ + + this.Locking + + +

+ +
+
+ Full Usage: + this.Locking +
+
+ Parameters: + +
+ + Returns: + 'T + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Performs an operation on the cache in thread safe manner. +

+
+ +
+
+ + arg0 + + : + IAssemblyContentCache -> 'T +
+
+
+
+
+ + Returns: + + 'T +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-entitykind.html b/reference/fsharp-compiler-editorservices-entitykind.html new file mode 100644 index 0000000000..d84f76977b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-entitykind.html @@ -0,0 +1,722 @@ + + + + + + + + + + + + + + + + + + EntityKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ EntityKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<EntityKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Attribute + + +

+ +
+
+ Full Usage: + Attribute +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + FunctionOrValue isActivePattern + + +

+ +
+
+ Full Usage: + FunctionOrValue isActivePattern +
+
+ Parameters: +
    + + + isActivePattern + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + isActivePattern + + : + bool +
+
+
+
+
+ +

+ + + Module ModuleKind + + +

+ +
+
+ Full Usage: + Module ModuleKind +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + ModuleKind +
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-finddeclexternalparam.html b/reference/fsharp-compiler-editorservices-finddeclexternalparam.html new file mode 100644 index 0000000000..fbf4ba7107 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-finddeclexternalparam.html @@ -0,0 +1,725 @@ + + + + + + + + + + + + + + + + + + FindDeclExternalParam (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FindDeclExternalParam Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the type of a single method parameter +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsByRef + + +

+ +
+
+ Full Usage: + this.IsByRef +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.ParameterType + + +

+ +
+
+ Full Usage: + this.ParameterType +
+
+ + Returns: + FindDeclExternalType + +
+
+
+
+ 		+
+
+ + Returns: + + FindDeclExternalType +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FindDeclExternalParam.Create(parameterType, isByRef) + + +

+ +
+
+ Full Usage: + FindDeclExternalParam.Create(parameterType, isByRef) +
+
+ Parameters: + +
+ + Returns: + FindDeclExternalParam + +
+
+
+
+ 		+
+
+ + parameterType + + : + FindDeclExternalType +
+
+
+ + isByRef + + : + bool +
+
+
+
+
+ + Returns: + + FindDeclExternalParam +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html b/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html new file mode 100644 index 0000000000..a1989287d7 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-finddeclexternalsymbol.html @@ -0,0 +1,950 @@ + + + + + + + + + + + + + + + + + + FindDeclExternalSymbol (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FindDeclExternalSymbol Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents a symbol in an external (non F#) assembly +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Constructor(typeName, args) + + +

+ +
+
+ Full Usage: + Constructor(typeName, args) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + typeName + + : + string +
+
+
+ + args + + : + FindDeclExternalParam list +
+
+
+
+
+ +

+ + + Event(typeName, name) + + +

+ +
+
+ Full Usage: + Event(typeName, name) +
+
+ Parameters: +
    + + + typeName + + : + string + +
    + + + name + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + typeName + + : + string +
+
+
+ + name + + : + string +
+
+
+
+
+ +

+ + + Field(typeName, name) + + +

+ +
+
+ Full Usage: + Field(typeName, name) +
+
+ Parameters: +
    + + + typeName + + : + string + +
    + + + name + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + typeName + + : + string +
+
+
+ + name + + : + string +
+
+
+
+
+ +

+ + + Method(typeName, name, paramSyms, genericArity) + + +

+ +
+
+ Full Usage: + Method(typeName, name, paramSyms, genericArity) +
+
+ Parameters: +
    + + + typeName + + : + string + +
    + + + name + + : + string + +
    + + + paramSyms + + : + FindDeclExternalParam list + +
    + + + genericArity + + : + int + +
    +
+
+
+
+
+ 		+
+
+ + typeName + + : + string +
+
+
+ + name + + : + string +
+
+
+ + paramSyms + + : + FindDeclExternalParam list +
+
+
+ + genericArity + + : + int +
+
+
+
+
+ +

+ + + Property(typeName, name) + + +

+ +
+
+ Full Usage: + Property(typeName, name) +
+
+ Parameters: +
    + + + typeName + + : + string + +
    + + + name + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + typeName + + : + string +
+
+
+ + name + + : + string +
+
+
+
+
+ +

+ + + Type fullName + + +

+ +
+
+ Full Usage: + Type fullName +
+
+ Parameters: +
    + + + fullName + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + fullName + + : + string +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-finddeclexternaltype.html b/reference/fsharp-compiler-editorservices-finddeclexternaltype.html new file mode 100644 index 0000000000..1882a0dec1 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-finddeclexternaltype.html @@ -0,0 +1,814 @@ + + + + + + + + + + + + + + + + + + FindDeclExternalType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FindDeclExternalType Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FindDeclExternalType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Represents a type in an external (non F#) assembly. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Array inner + + +

+ +
+
+ Full Usage: + Array inner +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Array of type that is defined in non-F# assembly. +

+
+ +
+
+ + inner + + : + FindDeclExternalType +
+
+
+
+
+
+ +

+ + + Pointer inner + + +

+ +
+
+ Full Usage: + Pointer inner +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Pointer defined in non-F# assembly. +

+
+ +
+
+ + inner + + : + FindDeclExternalType +
+
+
+
+
+
+ +

+ + + Type(fullName, genericArgs) + + +

+ +
+
+ Full Usage: + Type(fullName, genericArgs) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Type defined in non-F# assembly. +

+
+ +
+
+ + fullName + + : + string +
+
+
+ + genericArgs + + : + FindDeclExternalType list +
+
+
+
+
+
+ +

+ + + TypeVar typeName + + +

+ +
+
+ Full Usage: + TypeVar typeName +
+
+ Parameters: +
    + + + typeName + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Type variable defined in non-F# assembly. +

+
+ +
+
+ + typeName + + : + string +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-finddeclfailurereason.html b/reference/fsharp-compiler-editorservices-finddeclfailurereason.html new file mode 100644 index 0000000000..acdad02df0 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-finddeclfailurereason.html @@ -0,0 +1,772 @@ + + + + + + + + + + + + + + + + + + FindDeclFailureReason (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FindDeclFailureReason Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FindDeclFailureReason> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Represents the reason why the GetDeclarationLocation operation failed. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + NoSourceCode + + +

+ +
+
+ Full Usage: + NoSourceCode +
+
+
+
+
+ 		+
+ + + +

+ Source code file is not available +

+
+
+
+ +

+ + + ProvidedMember memberName + + +

+ +
+
+ Full Usage: + ProvidedMember memberName +
+
+ Parameters: +
    + + + memberName + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Trying to find declaration of ProvidedMember without TypeProviderDefinitionLocationAttribute +

+
+ +
+
+ + memberName + + : + string +
+
+
+
+
+
+ +

+ + + ProvidedType typeName + + +

+ +
+
+ Full Usage: + ProvidedType typeName +
+
+ Parameters: +
    + + + typeName + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Trying to find declaration of ProvidedType without TypeProviderDefinitionLocationAttribute +

+
+ +
+
+ + typeName + + : + string +
+
+
+
+
+
+ +

+ + + Unknown message + + +

+ +
+
+ Full Usage: + Unknown message +
+
+ Parameters: +
    + + + message + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Generic reason: no particular information about error apart from a message +

+
+ +
+
+ + message + + : + string +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-finddeclresult.html b/reference/fsharp-compiler-editorservices-finddeclresult.html new file mode 100644 index 0000000000..345238d947 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-finddeclresult.html @@ -0,0 +1,749 @@ + + + + + + + + + + + + + + + + + + FindDeclResult (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FindDeclResult Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents the result of the GetDeclarationLocation operation. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + DeclFound location + + +

+ +
+
+ Full Usage: + DeclFound location +
+
+ Parameters: +
    + + + location + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Indicates a declaration location was found +

+
+ +
+
+ + location + + : + range +
+
+
+
+
+
+ +

+ + + DeclNotFound FindDeclFailureReason + + +

+ +
+
+ Full Usage: + DeclNotFound FindDeclFailureReason +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates a declaration location was not found, with an additional reason +

+
+ +
+
+ + Item + + : + FindDeclFailureReason +
+
+
+
+
+
+ +

+ + + ExternalDecl(assembly, externalSym) + + +

+ +
+
+ Full Usage: + ExternalDecl(assembly, externalSym) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates an external declaration was found +

+
+ +
+
+ + assembly + + : + string +
+
+
+ + externalSym + + : + FindDeclExternalSymbol +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-fsharpglyph.html b/reference/fsharp-compiler-editorservices-fsharpglyph.html new file mode 100644 index 0000000000..a71d324740 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-fsharpglyph.html @@ -0,0 +1,1290 @@ + + + + + + + + + + + + + + + + + + FSharpGlyph (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpGlyph Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IEquatable<FSharpGlyph> + , + IStructuralEquatable + , + IComparable<FSharpGlyph> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Constant + + +

+ +
+
+ Full Usage: + Constant +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Delegate + + +

+ +
+
+ Full Usage: + Delegate +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Enum + + +

+ +
+
+ Full Usage: + Enum +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + EnumMember + + +

+ +
+
+ Full Usage: + EnumMember +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Error + + +

+ +
+
+ Full Usage: + Error +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Event + + +

+ +
+
+ Full Usage: + Event +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ExtensionMethod + + +

+ +
+
+ Full Usage: + ExtensionMethod +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Field + + +

+ +
+
+ Full Usage: + Field +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Method + + +

+ +
+
+ Full Usage: + Method +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NameSpace + + +

+ +
+
+ Full Usage: + NameSpace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OverridenMethod + + +

+ +
+
+ Full Usage: + OverridenMethod +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Property + + +

+ +
+
+ Full Usage: + Property +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Struct + + +

+ +
+
+ Full Usage: + Struct +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TypeParameter + + +

+ +
+
+ Full Usage: + TypeParameter +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Typedef + + +

+ +
+
+ Full Usage: + Typedef +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Union + + +

+ +
+
+ Full Usage: + Union +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Variable + + +

+ +
+
+ Full Usage: + Variable +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-iassemblycontentcache.html b/reference/fsharp-compiler-editorservices-iassemblycontentcache.html new file mode 100644 index 0000000000..6ff15fd9e9 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-iassemblycontentcache.html @@ -0,0 +1,722 @@ + + + + + + + + + + + + + + + + + + IAssemblyContentCache (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IAssemblyContentCache Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IAssemblyContentCache +
+
+
+
+

+ Assembly content cache. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Set + + +

+ +
+
+ Full Usage: + this.Set +
+
+ Parameters: + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Store an assembly content. +

+
+ +
+
+ + arg0 + + : + AssemblyPath +
+
+
+ + arg1 + + : + AssemblyContentCacheEntry +
+
+
+
+
+
+ +

+ + + this.TryGet + + +

+ +
+
+ Full Usage: + this.TryGet +
+
+ Parameters: + +
+ + Returns: + AssemblyContentCacheEntry option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Try get an assembly cached content. +

+
+ +
+
+ + arg0 + + : + AssemblyPath +
+
+
+
+
+ + Returns: + + AssemblyContentCacheEntry option +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-inheritancecontext.html b/reference/fsharp-compiler-editorservices-inheritancecontext.html new file mode 100644 index 0000000000..54ee3f8b6d --- /dev/null +++ b/reference/fsharp-compiler-editorservices-inheritancecontext.html @@ -0,0 +1,661 @@ + + + + + + + + + + + + + + + + + + InheritanceContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InheritanceContext Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<InheritanceContext> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Unknown + + +

+ +
+
+ Full Usage: + Unknown +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-insertioncontext.html b/reference/fsharp-compiler-editorservices-insertioncontext.html new file mode 100644 index 0000000000..1f1908952b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-insertioncontext.html @@ -0,0 +1,658 @@ + + + + + + + + + + + + + + + + + + InsertionContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InsertionContext Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Insert open namespace context. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Pos + + +

+ +
+
+ Full Usage: + Pos +
+
+ + Field type: + pos + +
+
+
+
+ 		+
+ +
+ + + +

+ Current position (F# compiler line number). +

+
+ +
+
+ + Field type: + + pos +
+
+
+
+
+
+ +

+ + + ScopeKind + + +

+ +
+
+ Full Usage: + ScopeKind +
+
+ + Field type: + ScopeKind + +
+
+
+
+ 		+
+ +
+ + + +

+ Current scope kind. +

+
+ +
+
+ + Field type: + + ScopeKind +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-insertioncontextentity.html b/reference/fsharp-compiler-editorservices-insertioncontextentity.html new file mode 100644 index 0000000000..ffe59def2b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-insertioncontextentity.html @@ -0,0 +1,817 @@ + + + + + + + + + + + + + + + + + + InsertionContextEntity (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InsertionContextEntity Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<InsertionContextEntity> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Helper data structure representing a symbol, suitable for implementing unresolved identifiers resolution code fixes. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + FullDisplayName + + +

+ +
+
+ Full Usage: + FullDisplayName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Full display name (i.e. last ident plus modules with `RequireQualifiedAccess` attribute prefixed). +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + FullRelativeName + + +

+ +
+
+ Full Usage: + FullRelativeName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Full name, relative to the current scope. +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + LastIdent + + +

+ +
+
+ Full Usage: + LastIdent +
+
+ + Field type: + ShortIdent + +
+
+
+
+ 		+
+ +
+ + + +

+ Last part of the entity's full name. +

+
+ +
+
+ + Field type: + + ShortIdent +
+
+
+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+ + Field type: + string option + +
+
+
+
+ 		+
+ +
+ + + +

+ Namespace that is needed to open to make the entity resolvable in the current scope. +

+
+ +
+
+ + Field type: + + string option +
+
+
+
+
+
+ +

+ + + Qualifier + + +

+ +
+
+ Full Usage: + Qualifier +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Ident parts needed to append to the current ident to make it resolvable in current scope. +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-interfacedata.html b/reference/fsharp-compiler-editorservices-interfacedata.html new file mode 100644 index 0000000000..7abc0674a4 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-interfacedata.html @@ -0,0 +1,774 @@ + + + + + + + + + + + + + + + + + + InterfaceData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InterfaceData Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Capture information about an interface in ASTs +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Interface(interfaceType, memberDefns) + + +

+ +
+
+ Full Usage: + Interface(interfaceType, memberDefns) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + interfaceType + + : + SynType +
+
+
+ + memberDefns + + : + SynMemberDefns option +
+
+
+
+
+ +

+ + + ObjExpr(objType, bindings) + + +

+ +
+
+ Full Usage: + ObjExpr(objType, bindings) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + objType + + : + SynType +
+
+
+ + bindings + + : + SynBinding list +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.TypeParameters + + +

+ +
+
+ Full Usage: + this.TypeParameters +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+
+ + Returns: + + string[] +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-interfacestubgenerator.html b/reference/fsharp-compiler-editorservices-interfacestubgenerator.html new file mode 100644 index 0000000000..f9a66dc6e8 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-interfacestubgenerator.html @@ -0,0 +1,1279 @@ + + + + + + + + + + + + + + + + + + InterfaceStubGenerator (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InterfaceStubGenerator Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + FormatInterface startColumn indentation typeInstances objectIdent methodBody displayContext excludedMemberSignatures arg8 verboseMode + + +

+ +
+
+ Full Usage: + FormatInterface startColumn indentation typeInstances objectIdent methodBody displayContext excludedMemberSignatures arg8 verboseMode +
+
+ Parameters: +
    + + + startColumn + + : + int + +
    + + + indentation + + : + int + +
    + + + typeInstances + + : + string[] + +
    + + + objectIdent + + : + string + +
    + + + methodBody + + : + string + +
    + + + displayContext + + : + FSharpDisplayContext + +
    + + + excludedMemberSignatures + + : + Set<string> + +
    + + + arg7 + + : + FSharpEntity + +
    + + + verboseMode + + : + bool + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Generate stub implementation of an interface at a start column +

+
+ +
+
+ + startColumn + + : + int +
+
+
+ + indentation + + : + int +
+
+
+ + typeInstances + + : + string[] +
+
+
+ + objectIdent + + : + string +
+
+
+ + methodBody + + : + string +
+
+
+ + displayContext + + : + FSharpDisplayContext +
+
+
+ + excludedMemberSignatures + + : + Set<string> +
+
+
+ + arg7 + + : + FSharpEntity +
+
+
+ + verboseMode + + : + bool +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + GetImplementedMemberSignatures getMemberByLocation arg2 arg3 + + +

+ +
+
+ Full Usage: + GetImplementedMemberSignatures getMemberByLocation arg2 arg3 +
+
+ Parameters: + +
+ + Returns: + Async<Set<string>> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get interface member signatures +

+
+ +
+
+ + getMemberByLocation + + : + string * range -> FSharpSymbolUse option +
+
+
+ + arg1 + + : + FSharpDisplayContext +
+
+
+ + arg2 + + : + InterfaceData +
+
+
+
+
+ + Returns: + + Async<Set<string>> +
+
+
+
+
+
+ +

+ + + GetInterfaceMembers entity + + +

+ +
+
+ Full Usage: + GetInterfaceMembers entity +
+
+ Parameters: + +
+ + Returns: + (FSharpMemberOrFunctionOrValue * (FSharpGenericParameter * FSharpType) seq) seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get members in the decreasing order of inheritance chain +

+
+ +
+
+ + entity + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + (FSharpMemberOrFunctionOrValue * (FSharpGenericParameter * FSharpType) seq) seq +
+
+
+
+
+
+ +

+ + + GetMemberNameAndRanges interfaceData + + +

+ +
+
+ Full Usage: + GetMemberNameAndRanges interfaceData +
+
+ Parameters: + +
+ + Returns: + (string * range) list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get associated member names and ranges. + In case of properties, intrinsic ranges might not be correct for the purpose of getting + positions of 'member', which indicate the indentation for generating new members +

+
+ +
+
+ + interfaceData + + : + InterfaceData +
+
+
+
+
+ + Returns: + + (string * range) list +
+
+
+
+
+
+ +

+ + + HasNoInterfaceMember entity + + +

+ +
+
+ Full Usage: + HasNoInterfaceMember entity +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Check whether an interface is empty +

+
+ +
+
+ + entity + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsInterface entity + + +

+ +
+
+ Full Usage: + IsInterface entity +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Check whether an entity is an interface or type abbreviation of an interface +

+
+ +
+
+ + entity + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + TryFindInterfaceDeclaration pos parsedInput + + +

+ +
+
+ Full Usage: + TryFindInterfaceDeclaration pos parsedInput +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + InterfaceData option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Find corresponding interface declaration at a given position +

+
+ +
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + InterfaceData option +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-lookuptype.html b/reference/fsharp-compiler-editorservices-lookuptype.html new file mode 100644 index 0000000000..ad02bec927 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-lookuptype.html @@ -0,0 +1,628 @@ + + + + + + + + + + + + + + + + + + LookupType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ LookupType Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<LookupType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Entity lookup type. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Fuzzy + + +

+ +
+
+ Full Usage: + Fuzzy +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Precise + + +

+ +
+
+ Full Usage: + Precise +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-maybeunresolvedident.html b/reference/fsharp-compiler-editorservices-maybeunresolvedident.html new file mode 100644 index 0000000000..9a0b22f69b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-maybeunresolvedident.html @@ -0,0 +1,640 @@ + + + + + + + + + + + + + + + + + + MaybeUnresolvedIdent (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ MaybeUnresolvedIdent Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<MaybeUnresolvedIdent> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ `ShortIdent` with a flag indicating if it's resolved in some scope. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Ident + + +

+ +
+
+ Full Usage: + Ident +
+
+ + Field type: + ShortIdent + +
+
+
+
+ 		+
+
+ + Field type: + + ShortIdent +
+
+
+
+
+ +

+ + + Resolved + + +

+ +
+
+ Full Usage: + Resolved +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-methodgroup.html b/reference/fsharp-compiler-editorservices-methodgroup.html new file mode 100644 index 0000000000..1e386af269 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-methodgroup.html @@ -0,0 +1,666 @@ + + + + + + + + + + + + + + + + + + MethodGroup (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ MethodGroup Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a group of methods (or other items) returned by GetMethods. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.MethodName + + +

+ +
+
+ Full Usage: + this.MethodName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The shared name of the methods (or other items) in the group +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Methods + + +

+ +
+
+ Full Usage: + this.Methods +
+
+ + Returns: + MethodGroupItem[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The methods (or other items) in the group +

+
+ +
+
+ + Returns: + + MethodGroupItem[] +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-methodgroupitem.html b/reference/fsharp-compiler-editorservices-methodgroupitem.html new file mode 100644 index 0000000000..4c7f2d0a64 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-methodgroupitem.html @@ -0,0 +1,952 @@ + + + + + + + + + + + + + + + + + + MethodGroupItem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ MethodGroupItem Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents one method (or other item) in a method group. The item may represent either a method or + a single, non-overloaded item such as union case or a named function value. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Description + + +

+ +
+
+ Full Usage: + this.Description +
+
+ + Returns: + ToolTipText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The description representation for the method (or other item) +

+
+ +
+
+ + Returns: + + ToolTipText +
+
+
+
+
+
+ +

+ + + this.HasParamArrayArg + + +

+ +
+
+ Full Usage: + this.HasParamArrayArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Does the method support a params list arg? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.HasParameters + + +

+ +
+
+ Full Usage: + this.HasParameters +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Does the method support an arguments list? This is always true except for static type instantiations like TP<42,"foo">. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Parameters + + +

+ +
+
+ Full Usage: + this.Parameters +
+
+ + Returns: + MethodGroupItemParameter[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The parameters of the method in the overload set +

+
+ +
+
+ + Returns: + + MethodGroupItemParameter[] +
+
+
+
+
+
+ +

+ + + this.ReturnTypeText + + +

+ +
+
+ Full Usage: + this.ReturnTypeText +
+
+ + Returns: + TaggedText[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The tagged text for the return type for the method (or other item) +

+
+ +
+
+ + Returns: + + TaggedText[] +
+
+
+
+
+
+ +

+ + + this.StaticParameters + + +

+ +
+
+ Full Usage: + this.StaticParameters +
+
+ + Returns: + MethodGroupItemParameter[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Does the type name or method support a static arguments list, like TP<42,"foo"> or conn.CreateCommand<42, "foo">(arg1, arg2)? +

+
+ +
+
+ + Returns: + + MethodGroupItemParameter[] +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The documentation for the item +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html b/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html new file mode 100644 index 0000000000..3721d87a5e --- /dev/null +++ b/reference/fsharp-compiler-editorservices-methodgroupitemparameter.html @@ -0,0 +1,781 @@ + + + + + + + + + + + + + + + + + + MethodGroupItemParameter (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ MethodGroupItemParameter Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents one parameter for one method (or other item) in a group. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CanonicalTypeTextForSorting + + +

+ +
+
+ Full Usage: + this.CanonicalTypeTextForSorting +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A key that can be used for sorting the parameters, used to help sort overloads. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Display + + +

+ +
+
+ Full Usage: + this.Display +
+
+ + Returns: + TaggedText[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The representation for the parameter including its name, its type and visual indicators of other + information such as whether it is optional. +

+
+ +
+
+ + Returns: + + TaggedText[] +
+
+
+
+
+
+ +

+ + + this.IsOptional + + +

+ +
+
+ Full Usage: + this.IsOptional +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Is the parameter optional +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ParameterName + + +

+ +
+
+ Full Usage: + this.ParameterName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the parameter. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-modulekind.html b/reference/fsharp-compiler-editorservices-modulekind.html new file mode 100644 index 0000000000..2b0838aa7b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-modulekind.html @@ -0,0 +1,640 @@ + + + + + + + + + + + + + + + + + + ModuleKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ModuleKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ModuleKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + HasModuleSuffix + + +

+ +
+
+ Full Usage: + HasModuleSuffix +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + IsAutoOpen + + +

+ +
+
+ Full Usage: + IsAutoOpen +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigablecontainer.html b/reference/fsharp-compiler-editorservices-navigablecontainer.html new file mode 100644 index 0000000000..93a6673560 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigablecontainer.html @@ -0,0 +1,724 @@ + + + + + + + + + + + + + + + + + + NavigableContainer (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigableContainer Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.FullName + + +

+ +
+
+ Full Usage: + this.FullName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The fully qualified name of the container. + For files it returns empty string. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the container or file +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Type + + +

+ +
+
+ Full Usage: + this.Type +
+
+ + Returns: + NavigableContainerType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The kind of container. +

+
+ +
+
+ + Returns: + + NavigableContainerType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigablecontainertype.html b/reference/fsharp-compiler-editorservices-navigablecontainertype.html new file mode 100644 index 0000000000..7b825ddf81 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigablecontainertype.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + NavigableContainerType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigableContainerType Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<NavigableContainerType> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + File + + +

+ +
+
+ Full Usage: + File +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigableitem.html b/reference/fsharp-compiler-editorservices-navigableitem.html new file mode 100644 index 0000000000..ab8ded4d98 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigableitem.html @@ -0,0 +1,790 @@ + + + + + + + + + + + + + + + + + + NavigableItem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigableItem Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Container + + +

+ +
+
+ Full Usage: + Container +
+
+ + Field type: + NavigableContainer + +
+
+
+
+ 		+
+
+ + Field type: + + NavigableContainer +
+
+
+
+
+ +

+ + + IsSignature + + +

+ +
+
+ Full Usage: + IsSignature +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Kind + + +

+ +
+
+ Full Usage: + Kind +
+
+ + Field type: + NavigableItemKind + +
+
+
+
+ 		+
+
+ + Field type: + + NavigableItemKind +
+
+
+
+
+ +

+ + + Name + + +

+ +
+
+ Full Usage: + Name +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + NeedsBackticks + + +

+ +
+
+ Full Usage: + NeedsBackticks +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+ +

+ + + Range + + +

+ +
+
+ Full Usage: + Range +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigableitemkind.html b/reference/fsharp-compiler-editorservices-navigableitemkind.html new file mode 100644 index 0000000000..c7ee72fc74 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigableitemkind.html @@ -0,0 +1,925 @@ + + + + + + + + + + + + + + + + + + NavigableItemKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigableItemKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<NavigableItemKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Constructor + + +

+ +
+
+ Full Usage: + Constructor +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + EnumCase + + +

+ +
+
+ Full Usage: + EnumCase +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Field + + +

+ +
+
+ Full Usage: + Field +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Member + + +

+ +
+
+ Full Usage: + Member +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ModuleAbbreviation + + +

+ +
+
+ Full Usage: + ModuleAbbreviation +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ModuleValue + + +

+ +
+
+ Full Usage: + ModuleValue +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Property + + +

+ +
+
+ Full Usage: + Property +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UnionCase + + +

+ +
+
+ Full Usage: + UnionCase +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigateto.html b/reference/fsharp-compiler-editorservices-navigateto.html new file mode 100644 index 0000000000..d8f0afd1c3 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigateto.html @@ -0,0 +1,609 @@ + + + + + + + + + + + + + + + + + + NavigateTo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigateTo Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + GetNavigableItems arg1 + + +

+ +
+
+ Full Usage: + GetNavigableItems arg1 +
+
+ Parameters: + +
+ + Returns: + NavigableItem[] + +
+
+
+
+ 		+
+
+ + arg0 + + : + ParsedInput +
+
+
+
+
+ + Returns: + + NavigableItem[] +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigation.html b/reference/fsharp-compiler-editorservices-navigation.html new file mode 100644 index 0000000000..57f4f5626b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigation.html @@ -0,0 +1,609 @@ + + + + + + + + + + + + + + + + + + Navigation (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Navigation Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + getNavigation arg1 + + +

+ +
+
+ Full Usage: + getNavigation arg1 +
+
+ Parameters: + +
+ + Returns: + NavigationItems + +
+
+
+
+ 		+
+
+ + arg0 + + : + ParsedInput +
+
+
+
+
+ + Returns: + + NavigationItems +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigationentitykind.html b/reference/fsharp-compiler-editorservices-navigationentitykind.html new file mode 100644 index 0000000000..fe038c0c6c --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigationentitykind.html @@ -0,0 +1,826 @@ + + + + + + + + + + + + + + + + + + NavigationEntityKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigationEntityKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<NavigationEntityKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Enum + + +

+ +
+
+ Full Usage: + Enum +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Record + + +

+ +
+
+ Full Usage: + Record +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Union + + +

+ +
+
+ Full Usage: + Union +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigationitem.html b/reference/fsharp-compiler-editorservices-navigationitem.html new file mode 100644 index 0000000000..32009fb5af --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigationitem.html @@ -0,0 +1,942 @@ + + + + + + + + + + + + + + + + + + NavigationItem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigationItem Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an item to be displayed in the navigation bar +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Access + + +

+ +
+
+ Full Usage: + this.Access +
+
+ + Returns: + SynAccess option + +
+
+
+
+ 		+
+
+ + Returns: + + SynAccess option +
+
+
+
+
+ +

+ + + this.BodyRange + + +

+ +
+
+ Full Usage: + this.BodyRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.EnclosingEntityKind + + +

+ +
+
+ Full Usage: + this.EnclosingEntityKind +
+
+ + Returns: + NavigationEntityKind + +
+
+
+
+ 		+
+
+ + Returns: + + NavigationEntityKind +
+
+
+
+
+ +

+ + + this.Glyph + + +

+ +
+
+ Full Usage: + this.Glyph +
+
+ + Returns: + FSharpGlyph + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpGlyph +
+
+
+
+
+ +

+ + + this.IsAbstract + + +

+ +
+
+ Full Usage: + this.IsAbstract +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsSingleTopLevel + + +

+ +
+
+ Full Usage: + this.IsSingleTopLevel +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Kind + + +

+ +
+
+ Full Usage: + this.Kind +
+
+ + Returns: + NavigationItemKind + +
+
+
+
+ 		+
+
+ + Returns: + + NavigationItemKind +
+
+
+
+
+ +

+ + + this.LogicalName + + +

+ +
+
+ Full Usage: + this.LogicalName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.UniqueName + + +

+ +
+
+ Full Usage: + this.UniqueName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigationitemkind.html b/reference/fsharp-compiler-editorservices-navigationitemkind.html new file mode 100644 index 0000000000..73dfe9ca00 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigationitemkind.html @@ -0,0 +1,859 @@ + + + + + + + + + + + + + + + + + + NavigationItemKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigationItemKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<NavigationItemKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Indicates a kind of item to show in an F# navigation bar +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Field + + +

+ +
+
+ Full Usage: + Field +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Method + + +

+ +
+
+ Full Usage: + Method +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ModuleFile + + +

+ +
+
+ Full Usage: + ModuleFile +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Other + + +

+ +
+
+ Full Usage: + Other +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Property + + +

+ +
+
+ Full Usage: + Property +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigationitems.html b/reference/fsharp-compiler-editorservices-navigationitems.html new file mode 100644 index 0000000000..2efc95bfc6 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigationitems.html @@ -0,0 +1,593 @@ + + + + + + + + + + + + + + + + + + NavigationItems (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigationItems Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents result of 'GetNavigationItems' operation - this contains + all the members and currently selected indices. First level correspond to + types & modules and second level are methods etc. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Declarations + + +

+ +
+
+ Full Usage: + this.Declarations +
+
+ + Returns: + NavigationTopLevelDeclaration[] + +
+
+
+
+ 		+
+
+ + Returns: + + NavigationTopLevelDeclaration[] +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-navigationtopleveldeclaration.html b/reference/fsharp-compiler-editorservices-navigationtopleveldeclaration.html new file mode 100644 index 0000000000..7100b452e2 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-navigationtopleveldeclaration.html @@ -0,0 +1,631 @@ + + + + + + + + + + + + + + + + + + NavigationTopLevelDeclaration (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigationTopLevelDeclaration Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents top-level declarations (that should be in the type drop-down) + with nested declarations (that can be shown in the member drop-down) +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Declaration + + +

+ +
+
+ Full Usage: + Declaration +
+
+ + Field type: + NavigationItem + +
+
+
+
+ 		+
+
+ + Field type: + + NavigationItem +
+
+
+
+
+ +

+ + + Nested + + +

+ +
+
+ Full Usage: + Nested +
+
+ + Field type: + NavigationItem[] + +
+
+
+
+ 		+
+
+ + Field type: + + NavigationItem[] +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-openstatementinsertionpoint.html b/reference/fsharp-compiler-editorservices-openstatementinsertionpoint.html new file mode 100644 index 0000000000..e7931abfcc --- /dev/null +++ b/reference/fsharp-compiler-editorservices-openstatementinsertionpoint.html @@ -0,0 +1,628 @@ + + + + + + + + + + + + + + + + + + OpenStatementInsertionPoint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ OpenStatementInsertionPoint Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<OpenStatementInsertionPoint> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Where open statements should be added. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Nearest + + +

+ +
+
+ Full Usage: + Nearest +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TopLevel + + +

+ +
+
+ Full Usage: + TopLevel +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-parameterlocations.html b/reference/fsharp-compiler-editorservices-parameterlocations.html new file mode 100644 index 0000000000..c517a1ecb7 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-parameterlocations.html @@ -0,0 +1,1121 @@ + + + + + + + + + + + + + + + + + + ParameterLocations (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParameterLocations Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the locations relevant to activating parameter info in an IDE +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ArgumentLocations + + +

+ +
+
+ Full Usage: + this.ArgumentLocations +
+
+ + Returns: + TupledArgumentLocation[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Array of locations for each argument, and a flag if that argument is named +

+
+ +
+
+ + Returns: + + TupledArgumentLocation[] +
+
+
+
+
+
+ +

+ + + this.IsThereACloseParen + + +

+ +
+
+ Full Usage: + this.IsThereACloseParen +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Is false if either this is a call without parens "f x" or the parser recovered as in "f(x,y" +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.LongId + + +

+ +
+
+ Full Usage: + this.LongId +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The text of the long identifier prior to the open-parentheses +

+
+ +
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + this.LongIdEndLocation + + +

+ +
+
+ Full Usage: + this.LongIdEndLocation +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The end location of long identifier prior to the open-parentheses +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.LongIdStartLocation + + +

+ +
+
+ Full Usage: + this.LongIdStartLocation +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start location of long identifier prior to the open-parentheses +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.NamedParamNames + + +

+ +
+
+ Full Usage: + this.NamedParamNames +
+
+ + Returns: + string option[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Either empty or a name if an actual named parameter; f(0,a=4,?b=None) would be [|None; Some "a"; Some "b"|] +

+
+ +
+
+ + Returns: + + string option[] +
+
+
+
+
+
+ +

+ + + this.OpenParenLocation + + +

+ +
+
+ Full Usage: + this.OpenParenLocation +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The location of the open-parentheses +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.TupleEndLocations + + +

+ +
+
+ Full Usage: + this.TupleEndLocations +
+
+ + Returns: + pos[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The locations of commas and close parenthesis (or, last char of last arg, if no final close parenthesis) +

+
+ +
+
+ + Returns: + + pos[] +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ParameterLocations.Find(arg1, arg2) + + +

+ +
+
+ Full Usage: + ParameterLocations.Find(arg1, arg2) +
+
+ Parameters: + +
+ + Returns: + ParameterLocations option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Find the information about parameter info locations at a particular source location +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+ + arg1 + + : + ParsedInput +
+
+
+
+
+ + Returns: + + ParameterLocations option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-parsedinput.html b/reference/fsharp-compiler-editorservices-parsedinput.html new file mode 100644 index 0000000000..01e656ea05 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-parsedinput.html @@ -0,0 +1,1470 @@ + + + + + + + + + + + + + + + + + + ParsedInput (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedInput Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Operations querying the entire syntax tree +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + AdjustInsertionPoint getLineStr ctx + + +

+ +
+
+ Full Usage: + AdjustInsertionPoint getLineStr ctx +
+
+ Parameters: +
    + + + getLineStr + + : + int -> string + +
    + + + ctx + + : + InsertionContext + +
    +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Corrects insertion line number based on kind of scope and text surrounding the insertion point. +

+
+ +
+
+ + getLineStr + + : + int -> string +
+
+
+ + ctx + + : + InsertionContext +
+
+
+
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + FindNearestPointToInsertOpenDeclaration currentLine parsedInput entity insertionPoint + + +

+ +
+
+ Full Usage: + FindNearestPointToInsertOpenDeclaration currentLine parsedInput entity insertionPoint +
+
+ Parameters: + +
+ + Returns: + InsertionContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns `InsertContext` based on current position and symbol idents. +

+
+ +
+
+ + currentLine + + : + int +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+ + entity + + : + ShortIdents +
+
+
+ + insertionPoint + + : + OpenStatementInsertionPoint +
+
+
+
+
+ + Returns: + + InsertionContext +
+
+
+
+
+
+ +

+ + + GetEntityKind (pos, parsedInput) + + +

+ +
+
+ Full Usage: + GetEntityKind (pos, parsedInput) +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + EntityKind option + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + EntityKind option +
+
+
+
+
+ +

+ + + GetFullNameOfSmallestModuleOrNamespaceAtPoint (pos, parsedInput) + + +

+ +
+
+ Full Usage: + GetFullNameOfSmallestModuleOrNamespaceAtPoint (pos, parsedInput) +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + string[] +
+
+
+
+
+ +

+ + + GetLongIdentAt parsedInput pos + + +

+ +
+
+ Full Usage: + GetLongIdentAt parsedInput pos +
+
+ Parameters: +
    + + + parsedInput + + : + ParsedInput + +
    + + + pos + + : + pos + +
    +
+
+ + Returns: + LongIdent option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns long identifier at position. +

+
+ +
+
+ + parsedInput + + : + ParsedInput +
+
+
+ + pos + + : + pos +
+
+
+
+
+ + Returns: + + LongIdent option +
+
+
+
+
+
+ +

+ + + GetRangeOfExprLeftOfDot (pos, parsedInput) + + +

+ +
+
+ Full Usage: + GetRangeOfExprLeftOfDot (pos, parsedInput) +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + range option +
+
+
+
+
+ +

+ + + TryFindExpressionASTLeftOfDotLeftOfCursor (pos, parsedInput) + + +

+ +
+
+ Full Usage: + TryFindExpressionASTLeftOfDotLeftOfCursor (pos, parsedInput) +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + (pos * bool) option + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + (pos * bool) option +
+
+
+
+
+ +

+ + + TryFindExpressionIslandInPosition (pos, parsedInput) + + +

+ +
+
+ Full Usage: + TryFindExpressionIslandInPosition (pos, parsedInput) +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + string option +
+
+
+
+
+ +

+ + + TryFindInsertionContext currentLine parsedInput partiallyQualifiedName insertionPoint + + +

+ +
+
+ Full Usage: + TryFindInsertionContext currentLine parsedInput partiallyQualifiedName insertionPoint +
+
+ Parameters: + +
+ + Returns: + ShortIdents option * ShortIdents option * ShortIdents option * ShortIdents -> (InsertionContextEntity * InsertionContext)[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns `InsertContext` based on current position and symbol idents. +

+
+ +
+
+ + currentLine + + : + int +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+ + partiallyQualifiedName + + : + MaybeUnresolvedIdent[] +
+
+
+ + insertionPoint + + : + OpenStatementInsertionPoint +
+
+
+
+
+ + Returns: + + ShortIdents option * ShortIdents option * ShortIdents option * ShortIdents -> (InsertionContextEntity * InsertionContext)[] +
+
+
+
+
+
+ +

+ + + TryGetCompletionContext (pos, parsedInput, lineStr) + + +

+ +
+
+ Full Usage: + TryGetCompletionContext (pos, parsedInput, lineStr) +
+
+ Parameters: +
    + + + pos + + : + pos + +
    + + + parsedInput + + : + ParsedInput + +
    + + + lineStr + + : + string + +
    +
+
+ + Returns: + CompletionContext option + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+ + lineStr + + : + string +
+
+
+
+
+ + Returns: + + CompletionContext option +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-partiallongname.html b/reference/fsharp-compiler-editorservices-partiallongname.html new file mode 100644 index 0000000000..15ab95bfcb --- /dev/null +++ b/reference/fsharp-compiler-editorservices-partiallongname.html @@ -0,0 +1,863 @@ + + + + + + + + + + + + + + + + + + PartialLongName (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ PartialLongName Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<PartialLongName> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Qualified long name. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EndColumn + + +

+ +
+
+ Full Usage: + EndColumn +
+
+ + Field type: + int + +
+
+
+
+ 		+
+ +
+ + + +

+ The column number at the end of full partial name. +

+
+ +
+
+ + Field type: + + int +
+
+
+
+
+
+ +

+ + + LastDotPos + + +

+ +
+
+ Full Usage: + LastDotPos +
+
+ + Field type: + int option + +
+
+
+
+ 		+
+ +
+ + + +

+ Position of the last dot. +

+
+ +
+
+ + Field type: + + int option +
+
+
+
+
+
+ +

+ + + PartialIdent + + +

+ +
+
+ Full Usage: + PartialIdent +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Last part of long ident. +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+ +

+ + + QualifyingIdents + + +

+ +
+
+ Full Usage: + QualifyingIdents +
+
+ + Field type: + string list + +
+
+
+
+ 		+
+ +
+ + + +

+ Qualifying idents, prior to the last dot, not including the last part. +

+
+ +
+
+ + Field type: + + string list +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + PartialLongName.Empty(endColumn) + + +

+ +
+
+ Full Usage: + PartialLongName.Empty(endColumn) +
+
+ Parameters: +
    + + + endColumn + + : + int + +
    +
+
+ + Returns: + PartialLongName + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Empty partial long name. +

+
+ +
+
+ + endColumn + + : + int +
+
+
+
+
+ + Returns: + + PartialLongName +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-patterncontext.html b/reference/fsharp-compiler-editorservices-patterncontext.html new file mode 100644 index 0000000000..87e6c16ccf --- /dev/null +++ b/reference/fsharp-compiler-editorservices-patterncontext.html @@ -0,0 +1,907 @@ + + + + + + + + + + + + + + + + + + PatternContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ PatternContext Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + NamedUnionCaseField(fieldName, caseIdRange) + + +

+ +
+
+ Full Usage: + NamedUnionCaseField(fieldName, caseIdRange) +
+
+ Parameters: +
    + + + fieldName + + : + string + +
    + + + caseIdRange + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Completing union case field pattern (e.g. fun (Some (Value = v| )) -> ) +

+
+ +
+
+ + fieldName + + : + string +
+
+
+ + caseIdRange + + : + range +
+
+
+
+
+
+ +

+ + + Other + + +

+ +
+
+ Full Usage: + Other +
+
+
+
+
+ 		+
+ + + +

+ Any other position in a pattern that does not need special handling +

+
+
+
+ +

+ + + PositionalUnionCaseField(fieldIndex, isTheOnlyField, caseIdRange) + + +

+ +
+
+ Full Usage: + PositionalUnionCaseField(fieldIndex, isTheOnlyField, caseIdRange) +
+
+ Parameters: +
    + + + fieldIndex + + : + int option + - + Position in the tuple. None if there is no tuple, with only one field outside of parentheses - `Some v|` + +
    + + + isTheOnlyField + + : + bool + - + True when completing the first field in the tuple and no other field is bound - `Case (a|)` but not `Case (a|, b)` + +
    + + + caseIdRange + + : + range + - + Range of the case identifier + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Completing union case field pattern (e.g. fun (Some v| ) -> ) or fun (Some (v| )) -> ). In theory, this could also be parameterized active pattern usage. +

+
+ +
+
+ + fieldIndex + + : + int option +
+
+

+ Position in the tuple. None if there is no tuple, with only one field outside of parentheses - `Some v|` +

+
+
+ + isTheOnlyField + + : + bool +
+
+

+ True when completing the first field in the tuple and no other field is bound - `Case (a|)` but not `Case (a|, b)` +

+
+
+ + caseIdRange + + : + range +
+
+

+ Range of the case identifier +

+
+
+
+
+
+ +

+ + + RecordFieldIdentifier referencedFields + + +

+ +
+
+ Full Usage: + RecordFieldIdentifier referencedFields +
+
+ Parameters: +
    + + + referencedFields + + : + (string * range) list + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Completing a record field identifier in a pattern (e.g. fun { Field1 = a; Fie| } -> ) +

+
+ +
+
+ + referencedFields + + : + (string * range) list +
+
+
+
+
+
+ +

+ + + UnionCaseFieldIdentifier(referencedFields, caseIdRange) + + +

+ +
+
+ Full Usage: + UnionCaseFieldIdentifier(referencedFields, caseIdRange) +
+
+ Parameters: +
    + + + referencedFields + + : + string list + +
    + + + caseIdRange + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Completing union case field identifier in a pattern (e.g. fun (Case (field1 = a; fie| )) -> ) +

+
+ +
+
+ + referencedFields + + : + string list +
+
+
+ + caseIdRange + + : + range +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-quickparse.html b/reference/fsharp-compiler-editorservices-quickparse.html new file mode 100644 index 0000000000..fff3c843de --- /dev/null +++ b/reference/fsharp-compiler-editorservices-quickparse.html @@ -0,0 +1,1096 @@ + + + + + + + + + + + + + + + + + + QuickParse (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ QuickParse Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+ 
 Methods for cheaply and inaccurately parsing F#.
+
+ These methods are very old and are mostly to do with extracting "long identifier islands"
+     A.B.C
+ from F# source code, an approach taken from pre-F# VS samples for implementing intelliense.
+
+ This code should really no longer be needed since the language service has access to
+ parsed F# source code ASTs.  However, the long identifiers are still passed back to GetDeclarations and friends in the
+ F# Compiler Service and it's annoyingly hard to remove their use completely.
+
+ In general it is unlikely much progress will be made by fixing this code - it will be better to
+ extract more information from the F# ASTs.
+
+ It's also surprising how hard even the job of getting long identifier islands can be. For example the code
+ below is inaccurate for long identifier chains involving ``...`` identifiers.  And there are special cases
+ for active pattern names and so on.
+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + CorrectIdentifierToken tokenText tokenTag + + +

+ +
+
+ Full Usage: + CorrectIdentifierToken tokenText tokenTag +
+
+ Parameters: +
    + + + tokenText + + : + string + +
    + + + tokenTag + + : + int + +
    +
+
+ + Returns: + int + +
+
+
+
+ 		+
+
+ + tokenText + + : + string +
+
+
+ + tokenTag + + : + int +
+
+
+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + GetCompleteIdentifierIsland tolerateJustAfter lineStr index + + +

+ +
+
+ Full Usage: + GetCompleteIdentifierIsland tolerateJustAfter lineStr index +
+
+ Parameters: +
    + + + tolerateJustAfter + + : + bool + +
    + + + lineStr + + : + string MaybeNull + +
    + + + index + + : + int + +
    +
+
+ + Returns: + (string * int * bool) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Given a string and a position in that string, find an identifier as
+ expected by `GotoDefinition`. This will work when the cursor is
+ immediately before the identifier, within the identifier, or immediately
+ after the identifier.
+
+ 'tolerateJustAfter' indicates that we tolerate being one character after the identifier, used
+ for goto-definition
+
+ In general, only identifiers composed from upper/lower letters and '.' are supported, but there
+ are a couple of explicitly handled exceptions to allow some common scenarios:
+ - When the name contains only letters and '|' symbol, it may be an active pattern, so we
+   treat it as a valid identifier - e.g. let ( |Identity| ) a = a
+   (but other identifiers that include '|' are not allowed - e.g. '||' operator)
+ - It searches for double tick (``) to see if the identifier could be something like ``a b``
+
+ REVIEW: Also support, e.g., operators, performing the necessary mangling.
+ (i.e., I would like that the name returned here can be passed as-is
+ (post `.`-chopping) to `GetDeclarationLocation.)
+
+ In addition, return the position where a `.` would go if we were making
+ a call to `DeclItemsForNamesAtPosition` for intellisense. This will
+ allow us to use find the correct qualified items rather than resorting
+ to the more expensive and less accurate environment lookup.
+
+ +
+
+ + tolerateJustAfter + + : + bool +
+
+
+ + lineStr + + : + string MaybeNull +
+
+
+ + index + + : + int +
+
+
+
+
+ + Returns: + + (string * int * bool) option +
+
+
+
+
+
+ +

+ + + GetPartialLongName (lineStr, index) + + +

+ +
+
+ Full Usage: + GetPartialLongName (lineStr, index) +
+
+ Parameters: +
    + + + lineStr + + : + string MaybeNull + +
    + + + index + + : + int + +
    +
+
+ + Returns: + string list * string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the partial long name of the identifier to the left of index. +

+
+ +
+
+ + lineStr + + : + string MaybeNull +
+
+
+ + index + + : + int +
+
+
+
+
+ + Returns: + + string list * string +
+
+
+
+
+
+ +

+ + + GetPartialLongNameEx (lineStr, index) + + +

+ +
+
+ Full Usage: + GetPartialLongNameEx (lineStr, index) +
+
+ Parameters: +
    + + + lineStr + + : + string MaybeNull + +
    + + + index + + : + int + +
    +
+
+ + Returns: + PartialLongName + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the partial long name of the identifier to the left of index. + For example, for `System.DateTime.Now` it returns PartialLongName ([|"System"; "DateTime"|], "Now", Some 32), where "32" pos of the last dot. +

+
+ +
+
+ + lineStr + + : + string MaybeNull +
+
+
+ + index + + : + int +
+
+
+
+
+ + Returns: + + PartialLongName +
+
+
+
+
+
+ +

+ + + MagicalAdjustmentConstant + + +

+ +
+
+ Full Usage: + MagicalAdjustmentConstant +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Puts us after the last character. +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + TestMemberOrOverrideDeclaration tokens + + +

+ +
+
+ Full Usage: + TestMemberOrOverrideDeclaration tokens +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Tests whether the user is typing something like "member x." or "override (*comment*) x." +

+
+ +
+
+ + tokens + + : + FSharpTokenInfo[] +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-recordcontext.html b/reference/fsharp-compiler-editorservices-recordcontext.html new file mode 100644 index 0000000000..9219c2f6e2 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-recordcontext.html @@ -0,0 +1,809 @@ + + + + + + + + + + + + + + + + + + RecordContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ RecordContext Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Constructor typeName + + +

+ +
+
+ Full Usage: + Constructor typeName +
+
+ Parameters: +
    + + + typeName + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + typeName + + : + string +
+
+
+
+
+ +

+ + + CopyOnUpdate(range, path) + + +

+ +
+
+ Full Usage: + CopyOnUpdate(range, path) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+ + path + + : + CompletionPath +
+
+
+
+
+ +

+ + + Declaration isInIdentifier + + +

+ +
+
+ Full Usage: + Declaration isInIdentifier +
+
+ Parameters: +
    + + + isInIdentifier + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + isInIdentifier + + : + bool +
+
+
+
+
+ +

+ + + Empty + + +

+ +
+
+ Full Usage: + Empty +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + New(path, isFirstField) + + +

+ +
+
+ Full Usage: + New(path, isFirstField) +
+
+ Parameters: +
    + + + path + + : + CompletionPath + +
    + + + isFirstField + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + path + + : + CompletionPath +
+
+
+ + isFirstField + + : + bool +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-scopekind.html b/reference/fsharp-compiler-editorservices-scopekind.html new file mode 100644 index 0000000000..8425cf5a41 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-scopekind.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + ScopeKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ScopeKind Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ScopeKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Kind of lexical scope. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + HashDirective + + +

+ +
+
+ Full Usage: + HashDirective +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NestedModule + + +

+ +
+
+ Full Usage: + NestedModule +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OpenDeclaration + + +

+ +
+
+ Full Usage: + OpenDeclaration +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TopModule + + +

+ +
+
+ Full Usage: + TopModule +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-semanticclassificationitem.html b/reference/fsharp-compiler-editorservices-semanticclassificationitem.html new file mode 100644 index 0000000000..5380b0e26d --- /dev/null +++ b/reference/fsharp-compiler-editorservices-semanticclassificationitem.html @@ -0,0 +1,716 @@ + + + + + + + + + + + + + + + + + + SemanticClassificationItem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SemanticClassificationItem Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ All Interfaces: + IStructuralEquatable +
+
+ Kind: Struct +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Range + + +

+ +
+
+ Full Usage: + Range +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+ + Field type: + SemanticClassificationType + +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + SemanticClassificationItem(arg1) + + +

+ +
+
+ Full Usage: + SemanticClassificationItem(arg1) +
+
+ Parameters: + +
+ + Returns: + SemanticClassificationItem + +
+
+
+
+ 		+
+
+ + arg0 + + : + range * SemanticClassificationType +
+
+
+
+
+ + Returns: + + SemanticClassificationItem +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-semanticclassificationtype.html b/reference/fsharp-compiler-editorservices-semanticclassificationtype.html new file mode 100644 index 0000000000..089ba4dc1e --- /dev/null +++ b/reference/fsharp-compiler-editorservices-semanticclassificationtype.html @@ -0,0 +1,2122 @@ + + + + + + + + + + + + + + + + + + SemanticClassificationType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SemanticClassificationType Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ A kind that determines what range in a source's text is semantically classified as after type-checking. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ComputationExpression + + +

+ +
+
+ Full Usage: + ComputationExpression +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + ConstructorForReferenceType + + +

+ +
+
+ Full Usage: + ConstructorForReferenceType +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + ConstructorForValueType + + +

+ +
+
+ Full Usage: + ConstructorForValueType +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Delegate + + +

+ +
+
+ Full Usage: + Delegate +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + DisposableLocalValue + + +

+ +
+
+ Full Usage: + DisposableLocalValue +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + DisposableTopLevelValue + + +

+ +
+
+ Full Usage: + DisposableTopLevelValue +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + DisposableType + + +

+ +
+
+ Full Usage: + DisposableType +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Enumeration + + +

+ +
+
+ Full Usage: + Enumeration +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Event + + +

+ +
+
+ Full Usage: + Event +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + ExtensionMethod + + +

+ +
+
+ Full Usage: + ExtensionMethod +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Field + + +

+ +
+
+ Full Usage: + Field +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Function + + +

+ +
+
+ Full Usage: + Function +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + IntrinsicFunction + + +

+ +
+
+ Full Usage: + IntrinsicFunction +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Literal + + +

+ +
+
+ Full Usage: + Literal +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + LocalValue + + +

+ +
+
+ Full Usage: + LocalValue +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Method + + +

+ +
+
+ Full Usage: + Method +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + MutableRecordField + + +

+ +
+
+ Full Usage: + MutableRecordField +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + MutableVar + + +

+ +
+
+ Full Usage: + MutableVar +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + NamedArgument + + +

+ +
+
+ Full Usage: + NamedArgument +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Operator + + +

+ +
+
+ Full Usage: + Operator +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Plaintext + + +

+ +
+
+ Full Usage: + Plaintext +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Printf + + +

+ +
+
+ Full Usage: + Printf +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Property + + +

+ +
+
+ Full Usage: + Property +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + RecordField + + +

+ +
+
+ Full Usage: + RecordField +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + RecordFieldAsFunction + + +

+ +
+
+ Full Usage: + RecordFieldAsFunction +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + ReferenceType + + +

+ +
+
+ Full Usage: + ReferenceType +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + TypeArgument + + +

+ +
+
+ Full Usage: + TypeArgument +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + TypeDef + + +

+ +
+
+ Full Usage: + TypeDef +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + UnionCase + + +

+ +
+
+ Full Usage: + UnionCase +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + UnionCaseField + + +

+ +
+
+ Full Usage: + UnionCaseField +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + Value + + +

+ +
+
+ Full Usage: + Value +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+ +

+ + + ValueType + + +

+ +
+
+ Full Usage: + ValueType +
+
+ + Field type: + SemanticClassificationType + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + SemanticClassificationType +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-semanticclassificationview.html b/reference/fsharp-compiler-editorservices-semanticclassificationview.html new file mode 100644 index 0000000000..a0da0d4adb --- /dev/null +++ b/reference/fsharp-compiler-editorservices-semanticclassificationview.html @@ -0,0 +1,617 @@ + + + + + + + + + + + + + + + + + + SemanticClassificationView (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SemanticClassificationView Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Provides a read only view to iterate over the semantic classification contents. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ForEach + + +

+ +
+
+ Full Usage: + this.ForEach +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Iterate through the stored SemanticClassificationItem entries from the store and apply the passed function on each entry. +

+
+ +
+
+ + arg0 + + : + SemanticClassificationItem -> unit +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-shortidents.html b/reference/fsharp-compiler-editorservices-shortidents.html new file mode 100644 index 0000000000..e362ca8dbe --- /dev/null +++ b/reference/fsharp-compiler-editorservices-shortidents.html @@ -0,0 +1,549 @@ + + + + + + + + + + + + + + + + + + ShortIdents (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ShortIdents Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Abbreviation For: + ShortIdent[] +
+
+ Base Type: + Array +
+
+ All Interfaces: + IList + , + ICollection + , + IStructuralComparable + , + IStructuralEquatable + , + ICloneable + , + IList<ShortIdent> + , + ICollection<ShortIdent> + , + IEnumerable<ShortIdent> + , + IEnumerable +
+
+
+
+

+ An array of `ShortIdent`. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-simplifynames-simplifiablerange.html b/reference/fsharp-compiler-editorservices-simplifynames-simplifiablerange.html new file mode 100644 index 0000000000..b911ecd867 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-simplifynames-simplifiablerange.html @@ -0,0 +1,664 @@ + + + + + + + + + + + + + + + + + + SimplifiableRange (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SimplifiableRange Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + SimplifyNames + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Data for use in finding unnecessarily-qualified names and generating diagnostics to simplify them +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Range + + +

+ +
+
+ Full Usage: + Range +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The range of a name that can be simplified +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + RelativeName + + +

+ +
+
+ Full Usage: + RelativeName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ The relative name that can be applied to a simplifiable name +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-simplifynames.html b/reference/fsharp-compiler-editorservices-simplifynames.html new file mode 100644 index 0000000000..e1900507fb --- /dev/null +++ b/reference/fsharp-compiler-editorservices-simplifynames.html @@ -0,0 +1,689 @@ + + + + + + + + + + + + + + + + + + SimplifyNames (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SimplifyNames Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + SimplifiableRange + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Data for use in finding unnecessarily-qualified names and generating diagnostics to simplify them +

+
+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + getSimplifiableNames (checkFileResults, getSourceLineStr) + + +

+ +
+
+ Full Usage: + getSimplifiableNames (checkFileResults, getSourceLineStr) +
+
+ Parameters: +
    + + + checkFileResults + + : + FSharpCheckFileResults + +
    + + + getSourceLineStr + + : + int -> string + +
    +
+
+ + Returns: + Async<SimplifiableRange seq> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all ranges that can be simplified in a file +

+
+ +
+
+ + checkFileResults + + : + FSharpCheckFileResults +
+
+
+ + getSourceLineStr + + : + int -> string +
+
+
+
+
+ + Returns: + + Async<SimplifiableRange seq> +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-structure-collapse.html b/reference/fsharp-compiler-editorservices-structure-collapse.html new file mode 100644 index 0000000000..ca3d7cf53b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-structure-collapse.html @@ -0,0 +1,636 @@ + + + + + + + + + + + + + + + + + + Collapse (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Collapse Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Structure + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<Collapse> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Collapse indicates the way a range/snapshot should be collapsed. `Same` is for a scope inside + some kind of scope delimiter, e.g. `[| ... |]`, `[ ... ]`, `{ ... }`, etc. `Below` is for expressions + following a binding or the right hand side of a pattern, e.g. `let x = ...` +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Below + + +

+ +
+
+ Full Usage: + Below +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Same + + +

+ +
+
+ Full Usage: + Same +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-structure-scope.html b/reference/fsharp-compiler-editorservices-structure-scope.html new file mode 100644 index 0000000000..73d273e53b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-structure-scope.html @@ -0,0 +1,2086 @@ + + + + + + + + + + + + + + + + + + Scope (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Scope Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Structure + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<Scope> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Tag to identify the construct that can be stored alongside its associated ranges +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ArrayOrList + + +

+ +
+
+ Full Usage: + ArrayOrList +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Attribute + + +

+ +
+
+ Full Usage: + Attribute +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Comment + + +

+ +
+
+ Full Usage: + Comment +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ComputationExpr + + +

+ +
+
+ Full Usage: + ComputationExpr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Do + + +

+ +
+
+ Full Usage: + Do +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ElseInIfThenElse + + +

+ +
+
+ Full Usage: + ElseInIfThenElse +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + EnumCase + + +

+ +
+
+ Full Usage: + EnumCase +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + FinallyInTryFinally + + +

+ +
+
+ Full Usage: + FinallyInTryFinally +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + For + + +

+ +
+
+ Full Usage: + For +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HashDirective + + +

+ +
+
+ Full Usage: + HashDirective +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + IfThenElse + + +

+ +
+
+ Full Usage: + IfThenElse +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Lambda + + +

+ +
+
+ Full Usage: + Lambda +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LetOrUse + + +

+ +
+
+ Full Usage: + LetOrUse +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LetOrUseBang + + +

+ +
+
+ Full Usage: + LetOrUseBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Match + + +

+ +
+
+ Full Usage: + Match +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + MatchBang + + +

+ +
+
+ Full Usage: + MatchBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + MatchClause + + +

+ +
+
+ Full Usage: + MatchClause +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + MatchLambda + + +

+ +
+
+ Full Usage: + MatchLambda +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Member + + +

+ +
+
+ Full Usage: + Member +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + New + + +

+ +
+
+ Full Usage: + New +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ObjExpr + + +

+ +
+
+ Full Usage: + ObjExpr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Open + + +

+ +
+
+ Full Usage: + Open +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Quote + + +

+ +
+
+ Full Usage: + Quote +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Record + + +

+ +
+
+ Full Usage: + Record +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RecordDefn + + +

+ +
+
+ Full Usage: + RecordDefn +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RecordField + + +

+ +
+
+ Full Usage: + RecordField +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SpecialFunc + + +

+ +
+
+ Full Usage: + SpecialFunc +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ThenInIfThenElse + + +

+ +
+
+ Full Usage: + ThenInIfThenElse +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TryFinally + + +

+ +
+
+ Full Usage: + TryFinally +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TryInTryFinally + + +

+ +
+
+ Full Usage: + TryInTryFinally +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TryInTryWith + + +

+ +
+
+ Full Usage: + TryInTryWith +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TryWith + + +

+ +
+
+ Full Usage: + TryWith +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Tuple + + +

+ +
+
+ Full Usage: + Tuple +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TypeExtension + + +

+ +
+
+ Full Usage: + TypeExtension +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UnionCase + + +

+ +
+
+ Full Usage: + UnionCase +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UnionDefn + + +

+ +
+
+ Full Usage: + UnionDefn +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Val + + +

+ +
+
+ Full Usage: + Val +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + While + + +

+ +
+
+ Full Usage: + While +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + WithInTryWith + + +

+ +
+
+ Full Usage: + WithInTryWith +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + XmlDocComment + + +

+ +
+
+ Full Usage: + XmlDocComment +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + YieldOrReturn + + +

+ +
+
+ Full Usage: + YieldOrReturn +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + YieldOrReturnBang + + +

+ +
+
+ Full Usage: + YieldOrReturnBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-structure-scoperange.html b/reference/fsharp-compiler-editorservices-structure-scoperange.html new file mode 100644 index 0000000000..5580ddf03b --- /dev/null +++ b/reference/fsharp-compiler-editorservices-structure-scoperange.html @@ -0,0 +1,743 @@ + + + + + + + + + + + + + + + + + + ScopeRange (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ScopeRange Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Structure + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Stores the range for a construct, the sub-range that should be collapsed for outlinging, + a tag for the construct type, and a tag for the collapse style +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Collapse + + +

+ +
+
+ Full Usage: + Collapse +
+
+ + Field type: + Collapse + +
+
+
+
+ 		+
+
+ + Field type: + + Collapse +
+
+
+
+
+ +

+ + + CollapseRange + + +

+ +
+
+ Full Usage: + CollapseRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ TextSpan in BlockSpan +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + Range + + +

+ +
+
+ Full Usage: + Range +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ HintSpan in BlockSpan +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + Scope + + +

+ +
+
+ Full Usage: + Scope +
+
+ + Field type: + Scope + +
+
+
+
+ 		+
+
+ + Field type: + + Scope +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-structure.html b/reference/fsharp-compiler-editorservices-structure.html new file mode 100644 index 0000000000..cb78c70df1 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-structure.html @@ -0,0 +1,746 @@ + + + + + + + + + + + + + + + + + + Structure (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Structure Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + Collapse + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Collapse indicates the way a range/snapshot should be collapsed. `Same` is for a scope inside + some kind of scope delimiter, e.g. `[| ... |]`, `[ ... ]`, `{ ... }`, etc. `Below` is for expressions + following a binding or the right hand side of a pattern, e.g. `let x = ...` +

+
+
+

+ + + Scope + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Tag to identify the construct that can be stored alongside its associated ranges +

+
+
+

+ + + ScopeRange + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Stores the range for a construct, the sub-range that should be collapsed for outlinging, + a tag for the construct type, and a tag for the collapse style +

+
+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + getOutliningRanges sourceLines parsedInput + + +

+ +
+
+ Full Usage: + getOutliningRanges sourceLines parsedInput +
+
+ Parameters: +
    + + + sourceLines + + : + string[] + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + ScopeRange seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns outlining ranges for given parsed input. +

+
+ +
+
+ + sourceLines + + : + string[] +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + ScopeRange seq +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-tooltipelement.html b/reference/fsharp-compiler-editorservices-tooltipelement.html new file mode 100644 index 0000000000..228b9b0277 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-tooltipelement.html @@ -0,0 +1,866 @@ + + + + + + + + + + + + + + + + + + ToolTipElement (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ToolTipElement Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ A single tool tip display element +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + CompositionError errorText + + +

+ +
+
+ Full Usage: + CompositionError errorText +
+
+ Parameters: +
    + + + errorText + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An error occurred formatting this element +

+
+ +
+
+ + errorText + + : + string +
+
+
+
+
+
+ +

+ + + Group elements + + +

+ +
+
+ Full Usage: + Group elements +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A single type, method, etc with comment. May represent a method overload group. +

+
+ +
+
+ + elements + + : + ToolTipElementData list +
+
+
+
+
+
+ +

+ + + None + + +

+ +
+
+ Full Usage: + None +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ToolTipElement.Single(layout, xml, ?typeMapping, ?paramName, ?remarks, ?symbol) + + +

+ +
+
+ Full Usage: + ToolTipElement.Single(layout, xml, ?typeMapping, ?paramName, ?remarks, ?symbol) +
+
+ Parameters: + +
+ + Returns: + ToolTipElement + +
+
+
+
+ 		+
+
+ + layout + + : + TaggedText[] +
+
+
+ + xml + + : + FSharpXmlDoc +
+
+
+ + ?typeMapping + + : + TaggedText[] list +
+
+
+ + ?paramName + + : + string +
+
+
+ + ?remarks + + : + TaggedText[] +
+
+
+ + ?symbol + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + ToolTipElement +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-tooltipelementdata.html b/reference/fsharp-compiler-editorservices-tooltipelementdata.html new file mode 100644 index 0000000000..aca1145691 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-tooltipelementdata.html @@ -0,0 +1,826 @@ + + + + + + + + + + + + + + + + + + ToolTipElementData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ToolTipElementData Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ A single data tip display element +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + MainDescription + + +

+ +
+
+ Full Usage: + MainDescription +
+
+ + Field type: + TaggedText[] + +
+
+
+
+ 		+
+
+ + Field type: + + TaggedText[] +
+
+
+
+
+ +

+ + + ParamName + + +

+ +
+
+ Full Usage: + ParamName +
+
+ + Field type: + string option + +
+
+
+
+ 		+
+ +
+ + + +

+ Parameter name +

+
+ +
+
+ + Field type: + + string option +
+
+
+
+
+
+ +

+ + + Remarks + + +

+ +
+
+ Full Usage: + Remarks +
+
+ + Field type: + TaggedText[] option + +
+
+
+
+ 		+
+ +
+ + + +

+ Extra text, goes at the end +

+
+ +
+
+ + Field type: + + TaggedText[] option +
+
+
+
+
+
+ +

+ + + Symbol + + +

+ +
+
+ Full Usage: + Symbol +
+
+ + Field type: + FSharpSymbol option + +
+
+
+
+ 		+
+
+ + Field type: + + FSharpSymbol option +
+
+
+
+
+ +

+ + + TypeMapping + + +

+ +
+
+ Full Usage: + TypeMapping +
+
+ + Field type: + TaggedText[] list + +
+
+
+
+ 		+
+ +
+ + + +

+ typar instantiation text, to go after xml +

+
+ +
+
+ + Field type: + + TaggedText[] list +
+
+
+
+
+
+ +

+ + + XmlDoc + + +

+ +
+
+ Full Usage: + XmlDoc +
+
+ + Field type: + FSharpXmlDoc + +
+
+
+
+ 		+
+
+ + Field type: + + FSharpXmlDoc +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-tooltiptext.html b/reference/fsharp-compiler-editorservices-tooltiptext.html new file mode 100644 index 0000000000..80fb66f715 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-tooltiptext.html @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + ToolTipText (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ToolTipText Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Information for building a tool tip box. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ToolTipText ToolTipElement list + + +

+ +
+
+ Full Usage: + ToolTipText ToolTipElement list +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A list of data tip elements to display. +

+
+ +
+
+ + Item + + : + ToolTipElement list +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-tupledargumentlocation.html b/reference/fsharp-compiler-editorservices-tupledargumentlocation.html new file mode 100644 index 0000000000..b8c5fc0d11 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-tupledargumentlocation.html @@ -0,0 +1,634 @@ + + + + + + + + + + + + + + + + + + TupledArgumentLocation (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ TupledArgumentLocation Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents the location of a tupled argument, which can optionally be a named argument. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ArgumentRange + + +

+ +
+
+ Full Usage: + ArgumentRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+ +

+ + + IsNamedArgument + + +

+ +
+
+ Full Usage: + IsNamedArgument +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+
+ + Field type: + + bool +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-unnecessaryparentheses.html b/reference/fsharp-compiler-editorservices-unnecessaryparentheses.html new file mode 100644 index 0000000000..1aedab9678 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-unnecessaryparentheses.html @@ -0,0 +1,649 @@ + + + + + + + + + + + + + + + + + + UnnecessaryParentheses (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ UnnecessaryParentheses Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + getUnnecessaryParentheses getSourceLineStr parsedInput + + +

+ +
+
+ Full Usage: + getUnnecessaryParentheses getSourceLineStr parsedInput +
+
+ Parameters: +
    + + + getSourceLineStr + + : + int -> string + +
    + + + parsedInput + + : + ParsedInput + +
    +
+
+ + Returns: + Async<range seq> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the ranges of all unnecessary pairs of parentheses in a file. + + Note that this may include pairs of nested ranges each of whose + lack of necessity depends on the other's presence, such + that it is valid to remove either set of parentheses but not both, e.g.: + + (x.M(y)).N → (x.M y).N ↮ x.M(y).N +

+
+ +
+
+ + getSourceLineStr + + : + int -> string +
+
+
+ + parsedInput + + : + ParsedInput +
+
+
+
+
+ + Returns: + + Async<range seq> +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-unresolvedsymbol.html b/reference/fsharp-compiler-editorservices-unresolvedsymbol.html new file mode 100644 index 0000000000..4fd4c7c2da --- /dev/null +++ b/reference/fsharp-compiler-editorservices-unresolvedsymbol.html @@ -0,0 +1,679 @@ + + + + + + + + + + + + + + + + + + UnresolvedSymbol (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ UnresolvedSymbol Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<UnresolvedSymbol> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + DisplayName + + +

+ +
+
+ Full Usage: + DisplayName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + FullName + + +

+ +
+
+ Full Usage: + FullName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+
+ + Field type: + + string +
+
+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+ + Field type: + string[] + +
+
+
+
+ 		+
+
+ + Field type: + + string[] +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-unuseddeclarations.html b/reference/fsharp-compiler-editorservices-unuseddeclarations.html new file mode 100644 index 0000000000..318e00a056 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-unuseddeclarations.html @@ -0,0 +1,643 @@ + + + + + + + + + + + + + + + + + + UnusedDeclarations (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ UnusedDeclarations Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + getUnusedDeclarations (checkFileResults, isScriptFile) + + +

+ +
+
+ Full Usage: + getUnusedDeclarations (checkFileResults, isScriptFile) +
+
+ Parameters: + +
+ + Returns: + Async<range seq> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all unused declarations in a file +

+
+ +
+
+ + checkFileResults + + : + FSharpCheckFileResults +
+
+
+ + isScriptFile + + : + bool +
+
+
+
+
+ + Returns: + + Async<range seq> +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-unusedopens.html b/reference/fsharp-compiler-editorservices-unusedopens.html new file mode 100644 index 0000000000..83999dc177 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-unusedopens.html @@ -0,0 +1,643 @@ + + + + + + + + + + + + + + + + + + UnusedOpens (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ UnusedOpens Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + getUnusedOpens (checkFileResults, getSourceLineStr) + + +

+ +
+
+ Full Usage: + getUnusedOpens (checkFileResults, getSourceLineStr) +
+
+ Parameters: +
    + + + checkFileResults + + : + FSharpCheckFileResults + +
    + + + getSourceLineStr + + : + int -> string + +
    +
+
+ + Returns: + Async<range list> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all unused open declarations in a file +

+
+ +
+
+ + checkFileResults + + : + FSharpCheckFileResults +
+
+
+ + getSourceLineStr + + : + int -> string +
+
+
+
+
+ + Returns: + + Async<range list> +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-xmldocable.html b/reference/fsharp-compiler-editorservices-xmldocable.html new file mode 100644 index 0000000000..eebb41c6e9 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-xmldocable.html @@ -0,0 +1,641 @@ + + + + + + + + + + + + + + + + + + XmlDocable (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ XmlDocable Type +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<XmlDocable> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Represent an Xml documentation block in source code +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + XmlDocable(line, indent, paramNames) + + +

+ +
+
+ Full Usage: + XmlDocable(line, indent, paramNames) +
+
+ Parameters: +
    + + + line + + : + int + +
    + + + indent + + : + int + +
    + + + paramNames + + : + string list + +
    +
+
+
+
+
+ 		+
+
+ + line + + : + int +
+
+
+ + indent + + : + int +
+
+
+ + paramNames + + : + string list +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-xmldoccomment.html b/reference/fsharp-compiler-editorservices-xmldoccomment.html new file mode 100644 index 0000000000..685be875d5 --- /dev/null +++ b/reference/fsharp-compiler-editorservices-xmldoccomment.html @@ -0,0 +1,630 @@ + + + + + + + + + + + + + + + + + + XmlDocComment (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ XmlDocComment Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + IsBlank arg1 + + +

+ +
+
+ Full Usage: + IsBlank arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + int option + +
+ Modifiers: + inline +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ if it's a blank XML comment with trailing "<", returns Some (index of the "<"), otherwise returns None +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + int option +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices-xmldocparser.html b/reference/fsharp-compiler-editorservices-xmldocparser.html new file mode 100644 index 0000000000..cc94492f3d --- /dev/null +++ b/reference/fsharp-compiler-editorservices-xmldocparser.html @@ -0,0 +1,643 @@ + + + + + + + + + + + + + + + + + + XmlDocParser (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ XmlDocParser Module +

+
+
+ Namespace: + + FSharp.Compiler.EditorServices + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + GetXmlDocables (arg1, input) + + +

+ +
+
+ Full Usage: + GetXmlDocables (arg1, input) +
+
+ Parameters: + +
+ + Returns: + XmlDocable list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the list of Xml documentation from current source code +

+
+ +
+
+ + arg0 + + : + ISourceText +
+
+
+ + input + + : + ParsedInput +
+
+
+
+
+ + Returns: + + XmlDocable list +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-editorservices.html b/reference/fsharp-compiler-editorservices.html new file mode 100644 index 0000000000..4686a25a3a --- /dev/null +++ b/reference/fsharp-compiler-editorservices.html @@ -0,0 +1,2238 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.EditorServices | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.EditorServices Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + AssemblyContent + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Provides assembly content. +

+
+
+

+ + + AssemblyContentType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Assembly content type. +

+
+
+

+ + + AssemblySymbol + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents type, module, member, function or value in a compiled assembly. +

+
+
+

+ + + CompletionContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + CompletionItemKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + DeclarationListInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a set of declarations in F# source code, with information attached ready for display by an editor. + Returned by GetDeclarations. +

+
+
+

+ + + DeclarationListItem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a declaration in F# source code, with information attached ready for display by an editor. + Returned by GetDeclarations. +

+
+
+

+ + + EntityCache + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Thread safe wrapper over `IAssemblyContentCache`. +

+
+
+

+ + + EntityKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FindDeclExternalParam + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the type of a single method parameter +

+
+
+

+ + + FindDeclExternalSymbol + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a symbol in an external (non F#) assembly +

+
+
+

+ + + FindDeclExternalType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a type in an external (non F#) assembly. +

+
+
+

+ + + FindDeclFailureReason + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the reason why the GetDeclarationLocation operation failed. +

+
+
+

+ + + FindDeclResult + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the result of the GetDeclarationLocation operation. +

+
+
+

+ + + FSharpGlyph + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + IAssemblyContentCache + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Assembly content cache. +

+
+
+

+ + + InheritanceContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + InsertionContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Insert open namespace context. +

+
+
+

+ + + InsertionContextEntity + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Helper data structure representing a symbol, suitable for implementing unresolved identifiers resolution code fixes. +

+
+
+

+ + + InterfaceData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Capture information about an interface in ASTs +

+
+
+

+ + + InterfaceStubGenerator + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + LookupType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Entity lookup type. +

+
+
+

+ + + MaybeUnresolvedIdent + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ `ShortIdent` with a flag indicating if it's resolved in some scope. +

+
+
+

+ + + MethodGroup + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a group of methods (or other items) returned by GetMethods. +

+
+
+

+ + + MethodGroupItem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents one method (or other item) in a method group. The item may represent either a method or + a single, non-overloaded item such as union case or a named function value. +

+
+
+

+ + + MethodGroupItemParameter + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents one parameter for one method (or other item) in a group. +

+
+
+

+ + + ModuleKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigableContainer + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigableContainerType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigableItem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigableItemKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigateTo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + Navigation + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigationEntityKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + NavigationItem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an item to be displayed in the navigation bar +

+
+
+

+ + + NavigationItemKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicates a kind of item to show in an F# navigation bar +

+
+
+

+ + + NavigationItems + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents result of 'GetNavigationItems' operation - this contains + all the members and currently selected indices. First level correspond to + types & modules and second level are methods etc. +

+
+
+

+ + + NavigationTopLevelDeclaration + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents top-level declarations (that should be in the type drop-down) + with nested declarations (that can be shown in the member drop-down) +

+
+
+

+ + + OpenStatementInsertionPoint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Where open statements should be added. +

+
+
+

+ + + ParameterLocations + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the locations relevant to activating parameter info in an IDE +

+
+
+

+ + + ParsedInput + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Operations querying the entire syntax tree +

+
+
+

+ + + PartialLongName + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Qualified long name. +

+
+
+

+ + + PatternContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + QuickParse + + +

+ 		+
+
+ +
+
+ +
+ + + + 
 Methods for cheaply and inaccurately parsing F#.
+
+ These methods are very old and are mostly to do with extracting "long identifier islands"
+     A.B.C
+ from F# source code, an approach taken from pre-F# VS samples for implementing intelliense.
+
+ This code should really no longer be needed since the language service has access to
+ parsed F# source code ASTs.  However, the long identifiers are still passed back to GetDeclarations and friends in the
+ F# Compiler Service and it's annoyingly hard to remove their use completely.
+
+ In general it is unlikely much progress will be made by fixing this code - it will be better to
+ extract more information from the F# ASTs.
+
+ It's also surprising how hard even the job of getting long identifier islands can be. For example the code
+ below is inaccurate for long identifier chains involving ``...`` identifiers.  And there are special cases
+ for active pattern names and so on.
+
+
+

+ + + RecordContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ScopeKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Kind of lexical scope. +

+
+
+

+ + + SemanticClassificationItem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SemanticClassificationType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A kind that determines what range in a source's text is semantically classified as after type-checking. +

+
+
+

+ + + SemanticClassificationView + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Provides a read only view to iterate over the semantic classification contents. +

+
+
+

+ + + ShortIdents + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ An array of `ShortIdent`. +

+
+
+

+ + + SimplifyNames + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + Structure + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ToolTipElement + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A single tool tip display element +

+
+
+

+ + + ToolTipElementData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A single data tip display element +

+
+
+

+ + + ToolTipText + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Information for building a tool tip box. +

+
+
+

+ + + TupledArgumentLocation + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the location of a tupled argument, which can optionally be a named argument. +

+
+
+

+ + + UnnecessaryParentheses + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + UnresolvedSymbol + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + UnusedDeclarations + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + UnusedOpens + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + XmlDocable + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represent an Xml documentation block in source code +

+
+
+

+ + + XmlDocComment + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + XmlDocParser + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakclient.html b/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakclient.html new file mode 100644 index 0000000000..0de5a35ebe --- /dev/null +++ b/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakclient.html @@ -0,0 +1,680 @@ + + + + + + + + + + + + + + + + + + CtrlBreakClient (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CtrlBreakClient Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + CtrlBreakHandlers + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IDisposable +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + CtrlBreakClient(channelName) + + +

+ +
+
+ Full Usage: + CtrlBreakClient(channelName) +
+
+ Parameters: +
    + + + channelName + + : + string + +
    +
+
+ + Returns: + CtrlBreakClient + +
+
+
+
+ 		+
+
+ + channelName + + : + string +
+
+
+
+
+ + Returns: + + CtrlBreakClient +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Interrupt + + +

+ +
+
+ Full Usage: + this.Interrupt +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html b/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html new file mode 100644 index 0000000000..83bba74ad3 --- /dev/null +++ b/reference/fsharp-compiler-interactive-ctrlbreakhandlers-ctrlbreakservice.html @@ -0,0 +1,718 @@ + + + + + + + + + + + + + + + + + + CtrlBreakService (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CtrlBreakService Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + CtrlBreakHandlers + +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + CtrlBreakService(channelName) + + +

+ +
+
+ Full Usage: + CtrlBreakService(channelName) +
+
+ Parameters: +
    + + + channelName + + : + string + +
    +
+
+ + Returns: + CtrlBreakService + +
+
+
+
+ 		+
+
+ + channelName + + : + string +
+
+
+
+
+ + Returns: + + CtrlBreakService +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Interrupt + + +

+ +
+
+ Full Usage: + this.Interrupt +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +

+ + + this.Run + + +

+ +
+
+ Full Usage: + this.Run +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-ctrlbreakhandlers.html b/reference/fsharp-compiler-interactive-ctrlbreakhandlers.html new file mode 100644 index 0000000000..1ab117bb92 --- /dev/null +++ b/reference/fsharp-compiler-interactive-ctrlbreakhandlers.html @@ -0,0 +1,594 @@ + + + + + + + + + + + + + + + + + + CtrlBreakHandlers (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CtrlBreakHandlers Module +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + CtrlBreakClient + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + CtrlBreakService + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-compilerinputstream.html b/reference/fsharp-compiler-interactive-shell-compilerinputstream.html new file mode 100644 index 0000000000..decd9281bd --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-compilerinputstream.html @@ -0,0 +1,686 @@ + + + + + + + + + + + + + + + + + + CompilerInputStream (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CompilerInputStream Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + Stream +
+
+ All Interfaces: + IAsyncDisposable + , + IDisposable +
+
+
+
+

+ Defines a read-only input stream used to feed content to the hosted F# Interactive dynamic compiler. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + CompilerInputStream() + + +

+ +
+
+ Full Usage: + CompilerInputStream() +
+
+ + Returns: + CompilerInputStream + +
+
+
+
+ 		+
+
+ + Returns: + + CompilerInputStream +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Add + + +

+ +
+
+ Full Usage: + this.Add +
+
+ Parameters: +
    + + + str + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Feeds content into the stream. +

+
+ +
+
+ + str + + : + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-compileroutputstream.html b/reference/fsharp-compiler-interactive-shell-compileroutputstream.html new file mode 100644 index 0000000000..11fdf6034c --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-compileroutputstream.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + CompilerOutputStream (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CompilerOutputStream Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + Stream +
+
+ All Interfaces: + IAsyncDisposable + , + IDisposable +
+
+
+
+

+ Defines a write-only stream used to capture output of the hosted F# Interactive dynamic compiler. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + CompilerOutputStream() + + +

+ +
+
+ Full Usage: + CompilerOutputStream() +
+
+ + Returns: + CompilerOutputStream + +
+
+
+
+ 		+
+
+ + Returns: + + CompilerOutputStream +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Read + + +

+ +
+
+ Full Usage: + this.Read +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html b/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html new file mode 100644 index 0000000000..496aa6f74c --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-evaluationeventargs.html @@ -0,0 +1,843 @@ + + + + + + + + + + + + + + + + + + EvaluationEventArgs (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ EvaluationEventArgs Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + EventArgs +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.FsiValue + + +

+ +
+
+ Full Usage: + this.FsiValue +
+
+ + Returns: + FsiValue option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The value of the symbol defined, if any +

+
+ +
+
+ + Returns: + + FsiValue option +
+
+
+
+
+
+ +

+ + + this.ImplementationDeclaration + + +

+ +
+
+ Full Usage: + this.ImplementationDeclaration +
+
+ + Returns: + FSharpImplementationFileDeclaration + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The details of the expression defined +

+
+ +
+
+ + Returns: + + FSharpImplementationFileDeclaration +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The display name of the symbol defined +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Symbol + + +

+ +
+
+ Full Usage: + this.Symbol +
+
+ + Returns: + FSharpSymbol + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The symbol defined +

+
+ +
+
+ + Returns: + + FSharpSymbol +
+
+
+
+
+
+ +

+ + + this.SymbolUse + + +

+ +
+
+ Full Usage: + this.SymbolUse +
+
+ + Returns: + FSharpSymbolUse + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The FSharpSymbolUse for the symbol defined +

+
+ +
+
+ + Returns: + + FSharpSymbolUse +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-fsiboundvalue.html b/reference/fsharp-compiler-interactive-shell-fsiboundvalue.html new file mode 100644 index 0000000000..804c54d9fc --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-fsiboundvalue.html @@ -0,0 +1,672 @@ + + + + + + + + + + + + + + + + + + FsiBoundValue (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FsiBoundValue Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an evaluated F# value that is bound to an identifier +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The identifier of the value +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Value + + +

+ +
+
+ Full Usage: + this.Value +
+
+ + Returns: + FsiValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The evaluated F# value +

+
+ +
+
+ + Returns: + + FsiValue +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-fsicompilationexception.html b/reference/fsharp-compiler-interactive-shell-fsicompilationexception.html new file mode 100644 index 0000000000..a77edca6f1 --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-fsicompilationexception.html @@ -0,0 +1,696 @@ + + + + + + + + + + + + + + + + + + FsiCompilationException (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FsiCompilationException Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + Exception +
+
+ All Interfaces: + ISerializable +
+
+
+
+

+ Thrown when there was an error compiling the given code in FSI. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + FsiCompilationException(arg1, arg2) + + +

+ +
+
+ Full Usage: + FsiCompilationException(arg1, arg2) +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    + + + arg1 + + : + FSharpDiagnostic[] option + +
    +
+
+ + Returns: + FsiCompilationException + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+ + arg1 + + : + FSharpDiagnostic[] option +
+
+
+
+
+ + Returns: + + FsiCompilationException +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ErrorInfos + + +

+ +
+
+ Full Usage: + this.ErrorInfos +
+
+ + Returns: + FSharpDiagnostic[] option + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpDiagnostic[] option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html b/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html new file mode 100644 index 0000000000..be44efde11 --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-fsievaluationsession.html @@ -0,0 +1,3007 @@ + + + + + + + + + + + + + + + + + + FsiEvaluationSession (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FsiEvaluationSession Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IDisposable +
+
+
+
+

+ Represents an F# Interactive evaluation session. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AddBoundValue + + +

+ +
+
+ Full Usage: + this.AddBoundValue +
+
+ Parameters: +
    + + + name + + : + string + +
    + + + value + + : + obj + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates a root-level value with the given name and .NET object. + If the .NET object contains types from assemblies that are not referenced in the interactive session, it will try to implicitly resolve them by default configuration. + Name must be a valid identifier. +

+
+ +
+
+ + name + + : + string +
+
+
+ + value + + : + obj +
+
+
+
+
+
+ +

+ + + this.CurrentPartialAssemblySignature + + +

+ +
+
+ Full Usage: + this.CurrentPartialAssemblySignature +
+
+ + Returns: + FSharpAssemblySignature + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a handle to the resolved view of the current signature of the incrementally generated assembly. +

+
+ +
+
+ + Returns: + + FSharpAssemblySignature +
+
+
+
+
+
+ +

+ + + this.DynamicAssemblies + + +

+ +
+
+ Full Usage: + this.DynamicAssemblies +
+
+ + Returns: + Assembly[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all the dynamically generated assemblies +

+
+ +
+
+ + Returns: + + Assembly[] +
+
+
+
+
+
+ +

+ + + this.EvalExpression + + +

+ +
+
+ Full Usage: + this.EvalExpression +
+
+ Parameters: +
    + + + code + + : + string + +
    + + + scriptFileName + + : + string + +
    +
+
+ + Returns: + FsiValue option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors are sent to the output writer. Parsing is performed on the current thread, and execution is performed + synchronously on the 'main' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. + The scriptFileName parameter is used to report errors including this file name. +

+
+ +
+
+ + code + + : + string +
+
+
+ + scriptFileName + + : + string +
+
+
+
+
+ + Returns: + + FsiValue option +
+
+
+
+
+
+ +

+ + + this.EvalExpression + + +

+ +
+
+ Full Usage: + this.EvalExpression +
+
+ Parameters: +
    + + + code + + : + string + +
    +
+
+ + Returns: + FsiValue option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors are sent to the output writer. Parsing is performed on the current thread, and execution is performed + synchronously on the 'main' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + code + + : + string +
+
+
+
+
+ + Returns: + + FsiValue option +
+
+
+
+
+
+ +

+ + + this.EvalExpressionNonThrowing + + +

+ +
+
+ Full Usage: + this.EvalExpressionNonThrowing +
+
+ Parameters: +
    + + + code + + : + string + +
    + + + scriptFileName + + : + string + +
    +
+
+ + Returns: + Choice<FsiValue option, exn> * FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors and warnings are collected apart from any exception arising from execution + which is returned via a Choice. Parsing is performed on the current thread, and execution is performed + synchronously on the 'main' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. + The scriptFileName parameter is used to report errors including this file name. +

+
+ +
+
+ + code + + : + string +
+
+
+ + scriptFileName + + : + string +
+
+
+
+
+ + Returns: + + Choice<FsiValue option, exn> * FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.EvalExpressionNonThrowing + + +

+ +
+
+ Full Usage: + this.EvalExpressionNonThrowing +
+
+ Parameters: +
    + + + code + + : + string + +
    +
+
+ + Returns: + Choice<FsiValue option, exn> * FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors and warnings are collected apart from any exception arising from execution + which is returned via a Choice. Parsing is performed on the current thread, and execution is performed + synchronously on the 'main' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + code + + : + string +
+
+
+
+
+ + Returns: + + Choice<FsiValue option, exn> * FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.EvalInteraction + + +

+ +
+
+ Full Usage: + this.EvalInteraction +
+
+ Parameters: +
    + + + code + + : + string + +
    + + + scriptFileName + + : + string + +
    + + + ?cancellationToken + + : + CancellationToken + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors are sent to the output writer, a 'true' return value indicates there + were no errors overall. Execution is performed on the 'Run()' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. + The scriptFileName parameter is used to report errors including this file name. +

+
+ +
+
+ + code + + : + string +
+
+
+ + scriptFileName + + : + string +
+
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+
+ +

+ + + this.EvalInteraction + + +

+ +
+
+ Full Usage: + this.EvalInteraction +
+
+ Parameters: +
    + + + code + + : + string + +
    + + + ?cancellationToken + + : + CancellationToken + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors are sent to the output writer, a 'true' return value indicates there + were no errors overall. Execution is performed on the 'Run()' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + code + + : + string +
+
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+
+ +

+ + + this.EvalInteractionNonThrowing + + +

+ +
+
+ Full Usage: + this.EvalInteractionNonThrowing +
+
+ Parameters: +
    + + + code + + : + string + +
    + + + scriptFileName + + : + string + +
    + + + ?cancellationToken + + : + CancellationToken + +
    +
+
+ + Returns: + Choice<FsiValue option, exn> * FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors and warnings are collected apart from any exception arising from execution + which is returned via a Choice. Execution is performed on the 'Run()' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. + The scriptFileName parameter is used to report errors including this file name. +

+
+ +
+
+ + code + + : + string +
+
+
+ + scriptFileName + + : + string +
+
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+ + Returns: + + Choice<FsiValue option, exn> * FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.EvalInteractionNonThrowing + + +

+ +
+
+ Full Usage: + this.EvalInteractionNonThrowing +
+
+ Parameters: +
    + + + code + + : + string + +
    + + + ?cancellationToken + + : + CancellationToken + +
    +
+
+ + Returns: + Choice<FsiValue option, exn> * FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the code as if it had been entered as one or more interactions, with an + implicit termination at the end of the input. Stop on first error, discarding the rest + of the input. Errors and warnings are collected apart from any exception arising from execution + which is returned via a Choice. Execution is performed on the 'Run()' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + code + + : + string +
+
+
+ + ?cancellationToken + + : + CancellationToken +
+
+
+
+
+ + Returns: + + Choice<FsiValue option, exn> * FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.EvalScript + + +

+ +
+
+ Full Usage: + this.EvalScript +
+
+ Parameters: +
    + + + filePath + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the given script. Stop on first error, discarding the rest + of the script. Errors are sent to the output writer, a 'true' return value indicates there + were no errors overall. Execution is performed on the 'Run()' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + filePath + + : + string +
+
+
+
+
+
+ +

+ + + this.EvalScriptNonThrowing + + +

+ +
+
+ Full Usage: + this.EvalScriptNonThrowing +
+
+ Parameters: +
    + + + filePath + + : + string + +
    +
+
+ + Returns: + Choice<unit, exn> * FSharpDiagnostic[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Execute the given script. Stop on first error, discarding the rest + of the script. Errors and warnings are collected apart from any exception arising from execution + which is returned via a Choice. Execution is performed on the 'Run()' thread. + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + filePath + + : + string +
+
+
+
+
+ + Returns: + + Choice<unit, exn> * FSharpDiagnostic[] +
+
+
+
+
+
+ +

+ + + this.FormatValue + + +

+ +
+
+ Full Usage: + this.FormatValue +
+
+ Parameters: +
    + + + reflectionValue + + : + obj + +
    + + + reflectionType + + : + Type + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format a value to a string using the current PrintDepth, PrintLength etc settings provided by the active fsi configuration object +

+
+ +
+
+ + reflectionValue + + : + obj +
+
+
+ + reflectionType + + : + Type +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetBoundValues + + +

+ +
+
+ Full Usage: + this.GetBoundValues +
+
+ + Returns: + FsiBoundValue list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the root-level values that are bound to an identifier +

+
+ +
+
+ + Returns: + + FsiBoundValue list +
+
+
+
+
+
+ +

+ + + this.GetCompletions + + +

+ +
+
+ Full Usage: + this.GetCompletions +
+
+ Parameters: +
    + + + longIdent + + : + string + +
    +
+
+ + Returns: + string seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A host calls this to get the completions for a long identifier, e.g. in the console + + Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered + by input from 'stdin'. +

+
+ +
+
+ + longIdent + + : + string +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+
+ +

+ + + this.InteractiveChecker + + +

+ +
+
+ Full Usage: + this.InteractiveChecker +
+
+ + Returns: + FSharpChecker + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The single, global interactive checker to use in conjunction with other operations + on the FsiEvaluationSession. + + If you are using an FsiEvaluationSession in this process, you should only use this InteractiveChecker + for additional checking operations. +

+
+ +
+
+ + Returns: + + FSharpChecker +
+
+
+
+
+
+ +

+ + + this.Interrupt + + +

+ +
+
+ Full Usage: + this.Interrupt +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ A host calls this to request an interrupt on the evaluation thread. +

+
+
+
+ +

+ + + this.IsGui + + +

+ +
+
+ Full Usage: + this.IsGui +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A host calls this to determine if the --gui parameter is active +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.LCID + + +

+ +
+
+ Full Usage: + this.LCID +
+
+ + Returns: + int option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A host calls this to get the active language ID if provided by fsi-server-lcid +

+
+ +
+
+ + Returns: + + int option +
+
+
+
+
+
+ +

+ + + this.ParseAndCheckInteraction + + +

+ +
+
+ Full Usage: + this.ParseAndCheckInteraction +
+
+ Parameters: +
    + + + code + + : + string + +
    +
+
+ + Returns: + FSharpParseFileResults * FSharpCheckFileResults * FSharpCheckProjectResults + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Typecheck the given script fragment in the type checking context implied by the current state + of F# Interactive. The results can be used to access intellisense, perform resolutions, + check brace matching and other information. + + Operations may be run concurrently with other requests to the InteractiveChecker. +

+
+ +
+
+ + code + + : + string +
+
+
+
+
+ + Returns: + + FSharpParseFileResults * FSharpCheckFileResults * FSharpCheckProjectResults +
+
+
+
+
+
+ +

+ + + this.PartialAssemblySignatureUpdated + + +

+ +
+
+ Full Usage: + this.PartialAssemblySignatureUpdated +
+
+ + Returns: + IEvent<unit> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Raised when an interaction is successfully typechecked and executed, resulting in an update to the + type checking state. + + This event is triggered after parsing and checking, either via input from 'stdin', or via a call to EvalInteraction. +

+
+ +
+
+ + Returns: + + IEvent<unit> +
+
+
+
+
+
+ +

+ + + this.ReportUnhandledException + + +

+ +
+
+ Full Usage: + this.ReportUnhandledException +
+
+ Parameters: +
    + + + exn + + : + exn + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A host calls this to report an unhandled exception in a standard way, e.g. an exception on the GUI thread gets printed to stderr +

+
+ +
+
+ + exn + + : + exn +
+
+
+
+
+
+ +

+ + + this.Run + + +

+ +
+
+ Full Usage: + this.Run +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + + 
 Load the dummy interaction, load the initial files, and,
+ if interacting, start the background thread to read the standard input.
+
+ Performs these steps:
+    - Load the dummy interaction, if any
+    - Set up exception handling, if any
+    - Load the initial files, if any
+    - Start the background thread to read the standard input, if any
+    - Sit in the GUI event loop indefinitely, if needed
+
+
+
+ +

+ + + this.TryFindBoundValue + + +

+ +
+
+ Full Usage: + this.TryFindBoundValue +
+
+ Parameters: +
    + + + name + + : + string + +
    +
+
+ + Returns: + FsiBoundValue option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Tries to find a root-level value that is bound to the given identifier +

+
+ +
+
+ + name + + : + string +
+
+
+
+
+ + Returns: + + FsiBoundValue option +
+
+
+
+
+
+ +

+ + + this.ValueBound + + +

+ +
+
+ Full Usage: + this.ValueBound +
+
+ + Returns: + IEvent<obj * Type * string> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Event fires when a root-level value is bound to an identifier, e.g., via `let x = ...`. +

+
+ +
+
+ + Returns: + + IEvent<obj * Type * string> +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FsiEvaluationSession.Create(fsiConfig, argv, inReader, outWriter, errorWriter, ?collectible, ?legacyReferenceResolver) + + +

+ +
+
+ Full Usage: + FsiEvaluationSession.Create(fsiConfig, argv, inReader, outWriter, errorWriter, ?collectible, ?legacyReferenceResolver) +
+
+ Parameters: +
    + + + fsiConfig + + : + FsiEvaluationSessionHostConfig + - + The dynamic configuration of the evaluation session + +
    + + + argv + + : + string[] + - + The command line arguments for the evaluation session + +
    + + + inReader + + : + TextReader + - + Read input from the given reader + +
    + + + outWriter + + : + TextWriter + - + Write output to the given writer + +
    + + + errorWriter + + : + TextWriter + - + Write errors to the given writer + +
    + + + ?collectible + + : + bool + - + Optionally make the dynamic assembly for the session collectible + +
    + + + ?legacyReferenceResolver + + : + LegacyReferenceResolver + - + An optional resolver for legacy MSBuild references + +
    +
+
+ + Returns: + FsiEvaluationSession + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create an FsiEvaluationSession, reading from the given text input, writing to the given text output and error writers +

+
+ +
+
+ + fsiConfig + + : + FsiEvaluationSessionHostConfig +
+
+

+ The dynamic configuration of the evaluation session +

+
+
+ + argv + + : + string[] +
+
+

+ The command line arguments for the evaluation session +

+
+
+ + inReader + + : + TextReader +
+
+

+ Read input from the given reader +

+
+
+ + outWriter + + : + TextWriter +
+
+

+ Write output to the given writer +

+
+
+ + errorWriter + + : + TextWriter +
+
+

+ Write errors to the given writer +

+
+
+ + ?collectible + + : + bool +
+
+

+ Optionally make the dynamic assembly for the session collectible +

+
+
+ + ?legacyReferenceResolver + + : + LegacyReferenceResolver +
+
+

+ An optional resolver for legacy MSBuild references +

+
+
+
+
+ + Returns: + + FsiEvaluationSession +
+
+
+
+
+
+ +

+ + + FsiEvaluationSession.GetDefaultConfiguration() + + +

+ +
+
+ Full Usage: + FsiEvaluationSession.GetDefaultConfiguration() +
+
+ + Returns: + FsiEvaluationSessionHostConfig + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a configuration that uses a private inbuilt implementation of the 'fsi' object and does not + implicitly reference FSharp.Compiler.Interactive.Settings.dll. +

+
+ +
+
+ + Returns: + + FsiEvaluationSessionHostConfig +
+
+
+
+
+
+ +

+ + + FsiEvaluationSession.GetDefaultConfiguration(fsiObj) + + +

+ +
+
+ Full Usage: + FsiEvaluationSession.GetDefaultConfiguration(fsiObj) +
+
+ Parameters: +
    + + + fsiObj + + : + obj + +
    +
+
+ + Returns: + FsiEvaluationSessionHostConfig + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a configuration that uses the 'fsi' object (normally from FSharp.Compiler.Interactive.Settings.dll, + an object from another DLL with identical characteristics) to provide an implementation of the configuration. + FSharp.Compiler.Interactive.Settings.dll is referenced by default. +

+
+ +
+
+ + fsiObj + + : + obj +
+
+
+
+
+ + Returns: + + FsiEvaluationSessionHostConfig +
+
+
+
+
+
+ +

+ + + FsiEvaluationSession.GetDefaultConfiguration(fsiObj, useFsiAuxLib) + + +

+ +
+
+ Full Usage: + FsiEvaluationSession.GetDefaultConfiguration(fsiObj, useFsiAuxLib) +
+
+ Parameters: +
    + + + fsiObj + + : + obj + +
    + + + useFsiAuxLib + + : + bool + +
    +
+
+ + Returns: + FsiEvaluationSessionHostConfig + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a configuration that uses the 'fsi' object (normally from FSharp.Compiler.Interactive.Settings.dll, + an object from another DLL with identical characteristics) to provide an implementation of the configuration. + The flag indicates if FSharp.Compiler.Interactive.Settings.dll is referenced by default. +

+
+ +
+
+ + fsiObj + + : + obj +
+
+
+ + useFsiAuxLib + + : + bool +
+
+
+
+
+ + Returns: + + FsiEvaluationSessionHostConfig +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html b/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html new file mode 100644 index 0000000000..8b0fac6ee9 --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-fsievaluationsessionhostconfig.html @@ -0,0 +1,1748 @@ + + + + + + + + + + + + + + + + + + FsiEvaluationSessionHostConfig (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FsiEvaluationSessionHostConfig Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + FsiEvaluationSessionHostConfig() + + +

+ +
+
+ Full Usage: + FsiEvaluationSessionHostConfig() +
+
+ + Returns: + FsiEvaluationSessionHostConfig + +
+
+
+
+ 		+
+
+ + Returns: + + FsiEvaluationSessionHostConfig +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AddedPrinters + + +

+ +
+
+ Full Usage: + this.AddedPrinters +
+
+ + Returns: + Choice<(Type * (obj -> string)), (Type * (obj -> obj))> list + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + Choice<(Type * (obj -> string)), (Type * (obj -> obj))> list +
+
+
+
+
+
+ +

+ + + this.EventLoopInvoke + + +

+ +
+
+ Full Usage: + this.EventLoopInvoke +
+
+ Parameters: +
    + + + codeToRun + + : + unit -> 'T + +
    +
+
+ + Returns: + 'T + +
+ Modifiers: + abstract +
+ Type parameters: + 'T +
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Request that the given operation be run synchronously on the event loop. +

+
+ +
+
+ + codeToRun + + : + unit -> 'T +
+
+
+
+
+ + Returns: + + 'T +
+
+
+
+
+
+ +

+ + + this.EventLoopRun + + +

+ +
+
+ Full Usage: + this.EventLoopRun +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host to enter a dispatch loop like Application.Run(). + Only called if --gui option is used (which is the default). + Gets called towards the end of startup and every time a ThreadAbort escaped to the backup driver loop. + Return true if a 'restart' is required, which is a bit meaningless. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.EventLoopScheduleRestart + + +

+ +
+
+ Full Usage: + this.EventLoopScheduleRestart +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Schedule a restart for the event loop. +

+
+
+
+ +

+ + + this.FloatingPointFormat + + +

+ +
+
+ Full Usage: + this.FloatingPointFormat +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.FormatProvider + + +

+ +
+
+ Full Usage: + this.FormatProvider +
+
+ + Returns: + IFormatProvider + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + IFormatProvider +
+
+
+
+
+
+ +

+ + + this.GetOptionalConsoleReadLine + + +

+ +
+
+ Full Usage: + this.GetOptionalConsoleReadLine +
+
+ Parameters: +
    + + + probeToSeeIfConsoleWorks + + : + bool + +
    +
+
+ + Returns: + (unit -> string) option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+

Indicate a special console "readline" reader for the evaluation session, if any.

 

A "console" gets used if --readline is specified (the default on Windows + .NET); and --fsi-server is not + given (always combine with --readline-), and OptionalConsoleReadLine is given. + When a console is used, special rules apply to "peekahead", which allows early typing on the console. + Peekahead happens if --peekahead- is not specified (the default). + In this case, a prompt is printed early, a background thread is created and + the OptionalConsoleReadLine is used to read the first line. + If a console is not used, then inReader.Peek() is called early instead. +

 

Further lines are read using OptionalConsoleReadLine(). + If not provided, lines are read using inReader.ReadLine().

 

+

+
+ +
+
+ + probeToSeeIfConsoleWorks + + : + bool +
+
+
+
+
+ + Returns: + + (unit -> string) option +
+
+
+
+
+
+ +

+ + + this.OnEvaluation + + +

+ +
+
+ Full Usage: + this.OnEvaluation +
+
+ + Returns: + IEvent<EvaluationEventArgs> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Hook for listening for evaluation bindings +

+
+ +
+
+ + Returns: + + IEvent<EvaluationEventArgs> +
+
+
+
+
+
+ +

+ + + this.PrintDepth + + +

+ +
+
+ Full Usage: + this.PrintDepth +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.PrintLength + + +

+ +
+
+ Full Usage: + this.PrintLength +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.PrintSize + + +

+ +
+
+ Full Usage: + this.PrintSize +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.PrintWidth + + +

+ +
+
+ Full Usage: + this.PrintWidth +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.ReportUserCommandLineArgs + + +

+ +
+
+ Full Usage: + this.ReportUserCommandLineArgs +
+
+ Parameters: +
    + + + arg0 + + : + string[] + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The evaluation session calls this to report the preferred view of the command line arguments after + stripping things like "/use:file.fsx", "-r:Foo.dll" etc. +

+
+ +
+
+ + arg0 + + : + string[] +
+
+
+
+
+
+ +

+ + + this.ShowDeclarationValues + + +

+ +
+
+ Full Usage: + this.ShowDeclarationValues +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ShowIEnumerable + + +

+ +
+
+ Full Usage: + this.ShowIEnumerable +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ShowProperties + + +

+ +
+
+ Full Usage: + this.ShowProperties +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Called by the evaluation session to ask the host for parameters to format text for output +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.StartServer + + +

+ +
+
+ Full Usage: + this.StartServer +
+
+ Parameters: +
    + + + fsiServerName + + : + string + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The evaluation session calls this at an appropriate point in the startup phase if the --fsi-server parameter was given +

+
+ +
+
+ + fsiServerName + + : + string +
+
+
+
+
+
+ +

+ + + this.UseFsiAuxLib + + +

+ +
+
+ Full Usage: + this.UseFsiAuxLib +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Implicitly reference FSharp.Compiler.Interactive.Settings.dll +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-fsivalue.html b/reference/fsharp-compiler-interactive-shell-fsivalue.html new file mode 100644 index 0000000000..1b48ad9f5f --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-fsivalue.html @@ -0,0 +1,729 @@ + + + + + + + + + + + + + + + + + + FsiValue (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FsiValue Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an evaluated F# value +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.FSharpType + + +

+ +
+
+ Full Usage: + this.FSharpType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The type of the value, from the point of view of the F# type system +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.ReflectionType + + +

+ +
+
+ Full Usage: + this.ReflectionType +
+
+ + Returns: + Type + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The type of the value, from the point of view of the .NET type system +

+
+ +
+
+ + Returns: + + Type +
+
+
+
+
+
+ +

+ + + this.ReflectionValue + + +

+ +
+
+ Full Usage: + this.ReflectionValue +
+
+ + Returns: + obj + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The value, as an object +

+
+ +
+
+ + Returns: + + obj +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html b/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html new file mode 100644 index 0000000000..69b862d359 --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-settings-ieventloop.html @@ -0,0 +1,757 @@ + + + + + + + + + + + + + + + + + + IEventLoop (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IEventLoop Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Settings + +
+
+ Base Type: + obj +
+
+ All Interfaces: + IEventLoop +
+
+
+
+ 
An event loop used by the currently executing F# Interactive session to execute code
+ in the context of a GUI or another event-based system.
+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Invoke + + +

+ +
+
+ Full Usage: + this.Invoke +
+
+ Parameters: +
    + + + arg0 + + : + unit -> 'T + +
    +
+
+ + Returns: + 'T + + The result of the operation. +
+ Modifiers: + abstract +
+ Type parameters: + 'T +
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Request that the given operation be run synchronously on the event loop. +

+
+ +
+
+ + arg0 + + : + unit -> 'T +
+
+
+
+
+ + Returns: + + 'T +
+
+

+ The result of the operation. +

+
+
+
+
+
+ +

+ + + this.Run + + +

+ +
+
+ Full Usage: + this.Run +
+
+ + Returns: + bool + + True if the event loop was restarted; false otherwise. +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Run the event loop. +

+
+ +
+
+ + Returns: + + bool +
+
+

+ True if the event loop was restarted; false otherwise. +

+
+
+
+
+
+ +

+ + + this.ScheduleRestart + + +

+ +
+
+ Full Usage: + this.ScheduleRestart +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Schedule a restart for the event loop. +

+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html b/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html new file mode 100644 index 0000000000..b2e2688c2f --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-settings-interactivesettings.html @@ -0,0 +1,1119 @@ + + + + + + + + + + + + + + + + + + InteractiveSettings (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InteractiveSettings Type +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Settings + +
+
+ Base Type: + obj +
+
+
+
+

+ Operations supported by the currently executing F# Interactive session. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AddPrintTransformer + + +

+ +
+
+ Full Usage: + this.AddPrintTransformer +
+
+ Parameters: +
    + + + arg0 + + : + 'T -> obj + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Register a print transformer that controls the output of the interactive session. +

+
+ +
+
+ + arg0 + + : + 'T -> obj +
+
+
+
+
+
+ +

+ + + this.AddPrinter + + +

+ +
+
+ Full Usage: + this.AddPrinter +
+
+ Parameters: +
    + + + arg0 + + : + 'T -> string + +
    +
+
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Register a printer that controls the output of the interactive session. +

+
+ +
+
+ + arg0 + + : + 'T -> string +
+
+
+
+
+
+ +

+ + + this.CommandLineArgs + + +

+ +
+
+ Full Usage: + this.CommandLineArgs +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + + 
The command line arguments after ignoring the arguments relevant to the interactive
+ environment and replacing the first argument with the name of the last script file,
+ if any. Thus 'fsi.exe test1.fs test2.fs -- hello goodbye' will give arguments
+ 'test2.fs', 'hello', 'goodbye'.  This value will normally be different to those
+ returned by System.Environment.GetCommandLineArgs.
+
+
+
+ +

+ + + this.EventLoop + + +

+ +
+
+ Full Usage: + this.EventLoop +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Gets or sets a the current event loop being used to process interactions. +

+
+
+
+ +

+ + + this.FloatingPointFormat + + +

+ +
+
+ Full Usage: + this.FloatingPointFormat +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Get or set the floating point format used in the output of the interactive session. +

+
+
+
+ +

+ + + this.FormatProvider + + +

+ +
+
+ Full Usage: + this.FormatProvider +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Get or set the format provider used in the output of the interactive session. +

+
+
+
+ +

+ + + this.PrintDepth + + +

+ +
+
+ Full Usage: + this.PrintDepth +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Get or set the print depth of the interactive session. +

+
+
+
+ +

+ + + this.PrintLength + + +

+ +
+
+ Full Usage: + this.PrintLength +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Get or set the total print length of the interactive session. +

+
+
+
+ +

+ + + this.PrintSize + + +

+ +
+
+ Full Usage: + this.PrintSize +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Get or set the total print size of the interactive session. +

+
+
+
+ +

+ + + this.PrintWidth + + +

+ +
+
+ Full Usage: + this.PrintWidth +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ Get or set the print width of the interactive session. +

+
+
+
+ +

+ + + this.ShowDeclarationValues + + +

+ +
+
+ Full Usage: + this.ShowDeclarationValues +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ When set to 'false', disables the display of declaration values in the output of the interactive session. +

+
+
+
+ +

+ + + this.ShowIEnumerable + + +

+ +
+
+ Full Usage: + this.ShowIEnumerable +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ When set to 'false', disables the display of sequences in the output of the interactive session. +

+
+
+
+ +

+ + + this.ShowProperties + + +

+ +
+
+ Full Usage: + this.ShowProperties +
+
+
+
+
+ 		+
+
+ +
+
+ +
+ + + +

+ When set to 'false', disables the display of properties of evaluated objects in the output of the interactive session. +

+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell-settings.html b/reference/fsharp-compiler-interactive-shell-settings.html new file mode 100644 index 0000000000..8469002e48 --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell-settings.html @@ -0,0 +1,686 @@ + + + + + + + + + + + + + + + + + + Settings (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Settings Module +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Parent Module: + + Shell + +
+
+
+
+

+ A default implementation of the 'fsi' object, used by GetDefaultConfiguration() +

+
+
+
+

+ Types +

+ + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + IEventLoop + + +

+ 		+
+
+ +
+
+ +
+ + + + 
An event loop used by the currently executing F# Interactive session to execute code
+ in the context of a GUI or another event-based system.
+
+
+

+ + + InteractiveSettings + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Operations supported by the currently executing F# Interactive session. +

+
+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + fsi + + +

+ +
+
+ Full Usage: + fsi +
+
+ + Returns: + InteractiveSettings + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A default implementation of the 'fsi' object, used by GetDefaultConfiguration(). Note this + is a different object to FSharp.Compiler.Interactive.Settings.fsi in FSharp.Compiler.Interactive.Settings.dll, + which can be used as an alternative implementation of the interactive settings if passed as a parameter + to GetDefaultConfiguration(fsiObj). +

+
+ +
+
+ + Returns: + + InteractiveSettings +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive-shell.html b/reference/fsharp-compiler-interactive-shell.html new file mode 100644 index 0000000000..12edfb04f5 --- /dev/null +++ b/reference/fsharp-compiler-interactive-shell.html @@ -0,0 +1,783 @@ + + + + + + + + + + + + + + + + + + Shell (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Shell Module +

+
+
+ Namespace: + + FSharp.Compiler.Interactive + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Types and nested modules +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + Settings + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A default implementation of the 'fsi' object, used by GetDefaultConfiguration() +

+
+
+

+ + + CompilerInputStream + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Defines a read-only input stream used to feed content to the hosted F# Interactive dynamic compiler. +

+
+
+

+ + + CompilerOutputStream + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Defines a write-only stream used to capture output of the hosted F# Interactive dynamic compiler. +

+
+
+

+ + + EvaluationEventArgs + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FsiBoundValue + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an evaluated F# value that is bound to an identifier +

+
+
+

+ + + FsiCompilationException + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Thrown when there was an error compiling the given code in FSI. +

+
+
+

+ + + FsiEvaluationSession + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an F# Interactive evaluation session. +

+
+
+

+ + + FsiEvaluationSessionHostConfig + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FsiValue + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an evaluated F# value +

+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-interactive.html b/reference/fsharp-compiler-interactive.html new file mode 100644 index 0000000000..ac4d8483a9 --- /dev/null +++ b/reference/fsharp-compiler-interactive.html @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Interactive | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Interactive Namespace +

+
+ + + + + + + + + + + + + + + + + +
+ Modules + + Description +
+

+ + + CtrlBreakHandlers + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + Shell + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-bytememory.html b/reference/fsharp-compiler-io-bytememory.html new file mode 100644 index 0000000000..a88d1e347c --- /dev/null +++ b/reference/fsharp-compiler-io-bytememory.html @@ -0,0 +1,1877 @@ + + + + + + + + + + + + + + + + + + ByteMemory (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ByteMemory Type +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ A view over bytes. + May be backed by managed or unmanaged memory, or memory mapped file. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AsReadOnly + + +

+ +
+
+ Full Usage: + this.AsReadOnly +
+
+ + Returns: + ReadOnlyByteMemory + +
+
+
+
+ 		+
+
+ + Returns: + + ReadOnlyByteMemory +
+
+
+
+
+ +

+ + + this.AsReadOnlyStream + + +

+ +
+
+ Full Usage: + this.AsReadOnlyStream +
+
+ + Returns: + Stream + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a stream representation of the backing memory. + Disposing this will not free up any of the backing memory. + Stream cannot be written to. +

+
+ +
+
+ + Returns: + + Stream +
+
+
+
+
+
+ +

+ + + this.AsStream + + +

+ +
+
+ Full Usage: + this.AsStream +
+
+ + Returns: + Stream + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a stream representation of the backing memory. + Disposing this will not free up any of the backing memory. +

+
+ +
+
+ + Returns: + + Stream +
+
+
+
+
+
+ +

+ + + this.Copy + + +

+ +
+
+ Full Usage: + this.Copy +
+
+ Parameters: +
    + + + srcOffset + + : + int + +
    + + + dest + + : + byte[] + +
    + + + destOffset + + : + int + +
    + + + count + + : + int + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + srcOffset + + : + int +
+
+
+ + dest + + : + byte[] +
+
+
+ + destOffset + + : + int +
+
+
+ + count + + : + int +
+
+
+
+
+ +

+ + + this.CopyTo + + +

+ +
+
+ Full Usage: + this.CopyTo +
+
+ Parameters: +
    + + + arg0 + + : + Stream + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + arg0 + + : + Stream +
+
+
+
+
+ +

+ + + this[arg1] + + +

+ +
+
+ Full Usage: + this[arg1] +
+
+ Parameters: +
    + + + arg0 + + : + int + +
    +
+
+ + Returns: + byte + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + arg0 + + : + int +
+
+
+
+
+ + Returns: + + byte +
+
+
+
+
+ +

+ + + this.Length + + +

+ +
+
+ Full Usage: + this.Length +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + this.ReadAllBytes + + +

+ +
+
+ Full Usage: + this.ReadAllBytes +
+
+ + Returns: + byte[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + byte[] +
+
+
+
+
+ +

+ + + this.ReadBytes + + +

+ +
+
+ Full Usage: + this.ReadBytes +
+
+ Parameters: +
    + + + pos + + : + int + +
    + + + count + + : + int + +
    +
+
+ + Returns: + byte[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + pos + + : + int +
+
+
+ + count + + : + int +
+
+
+
+
+ + Returns: + + byte[] +
+
+
+
+
+ +

+ + + this.ReadInt32 + + +

+ +
+
+ Full Usage: + this.ReadInt32 +
+
+ Parameters: +
    + + + pos + + : + int + +
    +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + pos + + : + int +
+
+
+
+
+ + Returns: + + int +
+
+
+
+
+ +

+ + + this.ReadUInt16 + + +

+ +
+
+ Full Usage: + this.ReadUInt16 +
+
+ Parameters: +
    + + + pos + + : + int + +
    +
+
+ + Returns: + uint16 + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + pos + + : + int +
+
+
+
+
+ + Returns: + + uint16 +
+
+
+
+
+ +

+ + + this.ReadUtf8String + + +

+ +
+
+ Full Usage: + this.ReadUtf8String +
+
+ Parameters: +
    + + + pos + + : + int + +
    + + + count + + : + int + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + pos + + : + int +
+
+
+ + count + + : + int +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.Slice + + +

+ +
+
+ Full Usage: + this.Slice +
+
+ Parameters: +
    + + + pos + + : + int + +
    + + + count + + : + int + +
    +
+
+ + Returns: + ByteMemory + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + pos + + : + int +
+
+
+ + count + + : + int +
+
+
+
+
+ + Returns: + + ByteMemory +
+
+
+
+
+ +

+ + + this.ToArray + + +

+ +
+
+ Full Usage: + this.ToArray +
+
+ + Returns: + byte[] + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + byte[] +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + ByteMemory.Empty + + +

+ +
+
+ Full Usage: + ByteMemory.Empty +
+
+ + Returns: + ByteMemory + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Empty byte memory. +

+
+ +
+
+ + Returns: + + ByteMemory +
+
+
+
+
+
+ +

+ + + ByteMemory.FromArray(bytes) + + +

+ +
+
+ Full Usage: + ByteMemory.FromArray(bytes) +
+
+ Parameters: +
    + + + bytes + + : + byte[] + +
    +
+
+ + Returns: + ByteMemory + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates a ByteMemory object that is backed by a byte array. +

+
+ +
+
+ + bytes + + : + byte[] +
+
+
+
+
+ + Returns: + + ByteMemory +
+
+
+
+
+
+ +

+ + + ByteMemory.FromArray(bytes, offset, length) + + +

+ +
+
+ Full Usage: + ByteMemory.FromArray(bytes, offset, length) +
+
+ Parameters: +
    + + + bytes + + : + byte[] + +
    + + + offset + + : + int + +
    + + + length + + : + int + +
    +
+
+ + Returns: + ByteMemory + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates a ByteMemory object that is backed by a byte array with the specified offset and length. +

+
+ +
+
+ + bytes + + : + byte[] +
+
+
+ + offset + + : + int +
+
+
+ + length + + : + int +
+
+
+
+
+ + Returns: + + ByteMemory +
+
+
+
+
+
+ +

+ + + ByteMemory.FromMemoryMappedFile(arg1) + + +

+ +
+
+ Full Usage: + ByteMemory.FromMemoryMappedFile(arg1) +
+
+ Parameters: + +
+ + Returns: + ByteMemory + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a ByteMemory object that has a backing memory mapped file. +

+
+ +
+
+ + arg0 + + : + MemoryMappedFile +
+
+
+
+
+ + Returns: + + ByteMemory +
+
+
+
+
+
+ +

+ + + ByteMemory.FromUnsafePointer(addr, length, holder) + + +

+ +
+
+ Full Usage: + ByteMemory.FromUnsafePointer(addr, length, holder) +
+
+ Parameters: +
    + + + addr + + : + nativeint + +
    + + + length + + : + int + +
    + + + holder + + : + obj + +
    +
+
+ + Returns: + ByteMemory + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates a ByteMemory object that is backed by a raw pointer. + Use with care. +

+
+ +
+
+ + addr + + : + nativeint +
+
+
+ + length + + : + int +
+
+
+ + holder + + : + obj +
+
+
+
+
+ + Returns: + + ByteMemory +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-defaultassemblyloader.html b/reference/fsharp-compiler-io-defaultassemblyloader.html new file mode 100644 index 0000000000..40d435318b --- /dev/null +++ b/reference/fsharp-compiler-io-defaultassemblyloader.html @@ -0,0 +1,595 @@ + + + + + + + + + + + + + + + + + + DefaultAssemblyLoader (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DefaultAssemblyLoader Type +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IAssemblyLoader +
+
+
+
+

+ Default implementation for IAssemblyLoader +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + DefaultAssemblyLoader() + + +

+ +
+
+ Full Usage: + DefaultAssemblyLoader() +
+
+ + Returns: + DefaultAssemblyLoader + +
+
+
+
+ 		+
+
+ + Returns: + + DefaultAssemblyLoader +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-defaultfilesystem.html b/reference/fsharp-compiler-io-defaultfilesystem.html new file mode 100644 index 0000000000..70d4eb87bf --- /dev/null +++ b/reference/fsharp-compiler-io-defaultfilesystem.html @@ -0,0 +1,2113 @@ + + + + + + + + + + + + + + + + + + DefaultFileSystem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DefaultFileSystem Type +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFileSystem +
+
+
+
+

+ Represents a default (memory-mapped) implementation of the file system +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + DefaultFileSystem() + + +

+ +
+
+ Full Usage: + DefaultFileSystem() +
+
+ + Returns: + DefaultFileSystem + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a default implementation of the file system +

+
+ +
+
+ + Returns: + + DefaultFileSystem +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AssemblyLoader + + +

+ +
+
+ Full Usage: + this.AssemblyLoader +
+
+ + Returns: + IAssemblyLoader + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + IAssemblyLoader +
+
+
+
+
+ +

+ + + this.ChangeExtensionShim + + +

+ +
+
+ Full Usage: + this.ChangeExtensionShim +
+
+ Parameters: +
    + + + path + + : + string + +
    + + + extension + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+ + extension + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.CopyShim + + +

+ +
+
+ Full Usage: + this.CopyShim +
+
+ Parameters: +
    + + + src + + : + string + +
    + + + dest + + : + string + +
    + + + overwrite + + : + bool + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + src + + : + string +
+
+
+ + dest + + : + string +
+
+
+ + overwrite + + : + bool +
+
+
+
+
+ +

+ + + this.DirectoryCreateShim + + +

+ +
+
+ Full Usage: + this.DirectoryCreateShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.DirectoryDeleteShim + + +

+ +
+
+ Full Usage: + this.DirectoryDeleteShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ +

+ + + this.DirectoryExistsShim + + +

+ +
+
+ Full Usage: + this.DirectoryExistsShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.EnumerateDirectoriesShim + + +

+ +
+
+ Full Usage: + this.EnumerateDirectoriesShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+ +

+ + + this.EnumerateFilesShim + + +

+ +
+
+ Full Usage: + this.EnumerateFilesShim +
+
+ Parameters: +
    + + + path + + : + string + +
    + + + pattern + + : + string + +
    +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+ + pattern + + : + string +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+ +

+ + + this.FileDeleteShim + + +

+ +
+
+ Full Usage: + this.FileDeleteShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+
+
+ +

+ + + this.FileExistsShim + + +

+ +
+
+ Full Usage: + this.FileExistsShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.GetCreationTimeShim + + +

+ +
+
+ Full Usage: + this.GetCreationTimeShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + DateTime + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + DateTime +
+
+
+
+
+ +

+ + + this.GetDirectoryNameShim + + +

+ +
+
+ Full Usage: + this.GetDirectoryNameShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.GetFullFilePathInDirectoryShim + + +

+ +
+
+ Full Usage: + this.GetFullFilePathInDirectoryShim +
+
+ Parameters: +
    + + + dir + + : + string + +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + dir + + : + string +
+
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.GetFullPathShim + + +

+ +
+
+ Full Usage: + this.GetFullPathShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.GetLastWriteTimeShim + + +

+ +
+
+ Full Usage: + this.GetLastWriteTimeShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + DateTime + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + DateTime +
+
+
+
+
+ +

+ + + this.GetTempPathShim + + +

+ +
+
+ Full Usage: + this.GetTempPathShim +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.IsInvalidPathShim + + +

+ +
+
+ Full Usage: + this.IsInvalidPathShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsPathRootedShim + + +

+ +
+
+ Full Usage: + this.IsPathRootedShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsStableFileHeuristic + + +

+ +
+
+ Full Usage: + this.IsStableFileHeuristic +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.NormalizePathShim + + +

+ +
+
+ Full Usage: + this.NormalizePathShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.OpenFileForReadShim + + +

+ +
+
+ Full Usage: + this.OpenFileForReadShim +
+
+ Parameters: +
    + + + filePath + + : + string + +
    + + + ?useMemoryMappedFile + + : + bool + +
    + + + ?shouldShadowCopy + + : + bool + +
    +
+
+ + Returns: + Stream + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + filePath + + : + string +
+
+
+ + ?useMemoryMappedFile + + : + bool +
+
+
+ + ?shouldShadowCopy + + : + bool +
+
+
+
+
+ + Returns: + + Stream +
+
+
+
+
+ +

+ + + this.OpenFileForWriteShim + + +

+ +
+
+ Full Usage: + this.OpenFileForWriteShim +
+
+ Parameters: +
    + + + filePath + + : + string + +
    + + + ?fileMode + + : + FileMode + +
    + + + ?fileAccess + + : + FileAccess + +
    + + + ?fileShare + + : + FileShare + +
    +
+
+ + Returns: + Stream + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + filePath + + : + string +
+
+
+ + ?fileMode + + : + FileMode +
+
+
+ + ?fileAccess + + : + FileAccess +
+
+
+ + ?fileShare + + : + FileShare +
+
+
+
+
+ + Returns: + + Stream +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-filesystemautoopens.html b/reference/fsharp-compiler-io-filesystemautoopens.html new file mode 100644 index 0000000000..77d45e19d6 --- /dev/null +++ b/reference/fsharp-compiler-io-filesystemautoopens.html @@ -0,0 +1,605 @@ + + + + + + + + + + + + + + + + + + FileSystemAutoOpens (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FileSystemAutoOpens Module +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + FileSystem + + +

+ +
+
+ Full Usage: + FileSystem +
+
+ + Returns: + IFileSystem + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The global hook into the file system +

+
+ +
+
+ + Returns: + + IFileSystem +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-iassemblyloader.html b/reference/fsharp-compiler-io-iassemblyloader.html new file mode 100644 index 0000000000..f3003509a8 --- /dev/null +++ b/reference/fsharp-compiler-io-iassemblyloader.html @@ -0,0 +1,720 @@ + + + + + + + + + + + + + + + + + + IAssemblyLoader (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IAssemblyLoader Type +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IAssemblyLoader +
+
+
+
+

+ Type which we use to load assemblies. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AssemblyLoad + + +

+ +
+
+ Full Usage: + this.AssemblyLoad +
+
+ Parameters: + +
+ + Returns: + Assembly + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Used to load a dependency for F# Interactive and in an unused corner-case of type provider loading +

+
+ +
+
+ + assemblyName + + : + AssemblyName +
+
+
+
+
+ + Returns: + + Assembly +
+
+
+
+
+
+ +

+ + + this.AssemblyLoadFrom + + +

+ +
+
+ Full Usage: + this.AssemblyLoadFrom +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + Assembly + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Used to load type providers and located assemblies in F# Interactive +

+
+ +
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + Assembly +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-ifilesystem.html b/reference/fsharp-compiler-io-ifilesystem.html new file mode 100644 index 0000000000..a0b4dbe5c0 --- /dev/null +++ b/reference/fsharp-compiler-io-ifilesystem.html @@ -0,0 +1,2385 @@ + + + + + + + + + + + + + + + + + + IFileSystem (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IFileSystem Type +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IFileSystem +
+
+
+
+

+ Represents a shim for the file system +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AssemblyLoader + + +

+ +
+
+ Full Usage: + this.AssemblyLoader +
+
+ + Returns: + IAssemblyLoader + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + Returns: + + IAssemblyLoader +
+
+
+
+
+ +

+ + + this.ChangeExtensionShim + + +

+ +
+
+ Full Usage: + this.ChangeExtensionShim +
+
+ Parameters: +
    + + + path + + : + string + +
    + + + extension + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Path.ChangeExtension +

+
+ +
+
+ + path + + : + string +
+
+
+ + extension + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.CopyShim + + +

+ +
+
+ Full Usage: + this.CopyShim +
+
+ Parameters: +
    + + + src + + : + string + +
    + + + dest + + : + string + +
    + + + overwrite + + : + bool + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + src + + : + string +
+
+
+ + dest + + : + string +
+
+
+ + overwrite + + : + bool +
+
+
+
+
+ +

+ + + this.DirectoryCreateShim + + +

+ +
+
+ Full Usage: + this.DirectoryCreateShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Directory.Exists, but returns a string, the FullName of the resulting + DirectoryInfo. +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.DirectoryDeleteShim + + +

+ +
+
+ Full Usage: + this.DirectoryDeleteShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Directory.Delete +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+
+ +

+ + + this.DirectoryExistsShim + + +

+ +
+
+ Full Usage: + this.DirectoryExistsShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Directory.Exists +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.EnumerateDirectoriesShim + + +

+ +
+
+ Full Usage: + this.EnumerateDirectoriesShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Directory.EnumerateDirectories +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+
+ +

+ + + this.EnumerateFilesShim + + +

+ +
+
+ Full Usage: + this.EnumerateFilesShim +
+
+ Parameters: +
    + + + path + + : + string + +
    + + + pattern + + : + string + +
    +
+
+ + Returns: + string seq + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Directory.EnumerateFiles +

+
+ +
+
+ + path + + : + string +
+
+
+ + pattern + + : + string +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+
+ +

+ + + this.FileDeleteShim + + +

+ +
+
+ Full Usage: + this.FileDeleteShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over File.Delete +

+
+ +
+
+ + fileName + + : + string +
+
+
+
+
+
+ +

+ + + this.FileExistsShim + + +

+ +
+
+ Full Usage: + this.FileExistsShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over File.Exists +

+
+ +
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.GetCreationTimeShim + + +

+ +
+
+ Full Usage: + this.GetCreationTimeShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + DateTime + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + DateTime +
+
+
+
+
+ +

+ + + this.GetDirectoryNameShim + + +

+ +
+
+ Full Usage: + this.GetDirectoryNameShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim for getting directory name from path +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetFullFilePathInDirectoryShim + + +

+ +
+
+ Full Usage: + this.GetFullFilePathInDirectoryShim +
+
+ Parameters: +
    + + + dir + + : + string + +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Take in a directory, filename, and return canonicalized path to the file name in directory. + If file name path is rooted, ignores directory and returns file name path. + Otherwise, combines directory with file name and gets full path via GetFullPathShim(string). +

+
+ +
+
+ + dir + + : + string +
+
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetFullPathShim + + +

+ +
+
+ Full Usage: + this.GetFullPathShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Take in a file name with an absolute path, and return the same file name + but canonicalized with respect to extra path separators (e.g. C:\\\\foo.txt) + and '..' portions +

+
+ +
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetLastWriteTimeShim + + +

+ +
+
+ Full Usage: + this.GetLastWriteTimeShim +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + DateTime + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Utc time of the last modification +

+
+ +
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + DateTime +
+
+
+
+
+
+ +

+ + + this.GetTempPathShim + + +

+ +
+
+ Full Usage: + this.GetTempPathShim +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Path.GetTempPath +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.IsInvalidPathShim + + +

+ +
+
+ Full Usage: + this.IsInvalidPathShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Path.IsInvalidPath +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPathRootedShim + + +

+ +
+
+ Full Usage: + this.IsPathRootedShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A shim over Path.IsPathRooted +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsStableFileHeuristic + + +

+ +
+
+ Full Usage: + this.IsStableFileHeuristic +
+
+ Parameters: +
    + + + fileName + + : + string + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Used to determine if a file will not be subject to deletion during the lifetime of a typical client process. +

+
+ +
+
+ + fileName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.NormalizePathShim + + +

+ +
+
+ Full Usage: + this.NormalizePathShim +
+
+ Parameters: +
    + + + path + + : + string + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Removes relative parts from any full paths +

+
+ +
+
+ + path + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.OpenFileForReadShim + + +

+ +
+
+ Full Usage: + this.OpenFileForReadShim +
+
+ Parameters: +
    + + + filePath + + : + string + +
    + + + ?useMemoryMappedFile + + : + bool + +
    + + + ?shouldShadowCopy + + : + bool + +
    +
+
+ + Returns: + Stream + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Open the file for read, returns ByteMemory, uses either FileStream (for smaller files) or MemoryMappedFile (for potentially big files, such as dlls). +

+
+ +
+
+ + filePath + + : + string +
+
+
+ + ?useMemoryMappedFile + + : + bool +
+
+
+ + ?shouldShadowCopy + + : + bool +
+
+
+
+
+ + Returns: + + Stream +
+
+
+
+
+
+ +

+ + + this.OpenFileForWriteShim + + +

+ +
+
+ Full Usage: + this.OpenFileForWriteShim +
+
+ Parameters: +
    + + + filePath + + : + string + +
    + + + ?fileMode + + : + FileMode + +
    + + + ?fileAccess + + : + FileAccess + +
    + + + ?fileShare + + : + FileShare + +
    +
+
+ + Returns: + Stream + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Open the file for writing. Returns a Stream. +

+
+ +
+
+ + filePath + + : + string +
+
+
+ + ?fileMode + + : + FileMode +
+
+
+ + ?fileAccess + + : + FileAccess +
+
+
+ + ?fileShare + + : + FileShare +
+
+
+
+
+ + Returns: + + Stream +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io-streamextensions.html b/reference/fsharp-compiler-io-streamextensions.html new file mode 100644 index 0000000000..48d718567d --- /dev/null +++ b/reference/fsharp-compiler-io-streamextensions.html @@ -0,0 +1,1269 @@ + + + + + + + + + + + + + + + + + + StreamExtensions (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ StreamExtensions Module +

+
+
+ Namespace: + + FSharp.Compiler.IO + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+
+

+ Type extensions +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type extension + + Description +
+
+ +

+ + + this.AsByteMemory + + +

+ +
+
+ Full Usage: + this.AsByteMemory +
+
+ Parameters: +
    + + + () + + : + unit + +
    +
+
+ + Returns: + ByteMemory + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + () + + : + unit +
+
+
+
+
+ + Returns: + + ByteMemory +
+
+
+
+
+ +

+ + + this.GetReader + + +

+ +
+
+ Full Usage: + this.GetReader +
+
+ Parameters: +
    + + + codePage + + : + int option + +
    + + + ?retryLocked + + : + bool + +
    +
+
+ + Returns: + StreamReader + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + codePage + + : + int option +
+
+
+ + ?retryLocked + + : + bool +
+
+
+
+
+ + Returns: + + StreamReader +
+
+
+
+
+ +

+ + + this.GetWriter + + +

+ +
+
+ Full Usage: + this.GetWriter +
+
+ Parameters: +
    + + + ?encoding + + : + Encoding + +
    +
+
+ + Returns: + TextWriter + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + ?encoding + + : + Encoding +
+
+
+
+
+ + Returns: + + TextWriter +
+
+
+
+
+ +

+ + + this.ReadAllBytes + + +

+ +
+
+ Full Usage: + this.ReadAllBytes +
+
+ Parameters: +
    + + + () + + : + unit + +
    +
+
+ + Returns: + byte[] + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + () + + : + unit +
+
+
+
+
+ + Returns: + + byte[] +
+
+
+
+
+ +

+ + + this.ReadAllLines + + +

+ +
+
+ Full Usage: + this.ReadAllLines +
+
+ Parameters: +
    + + + ?encoding + + : + Encoding + +
    +
+
+ + Returns: + string array + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + ?encoding + + : + Encoding +
+
+
+
+
+ + Returns: + + string array +
+
+
+
+
+ +

+ + + this.ReadAllText + + +

+ +
+
+ Full Usage: + this.ReadAllText +
+
+ Parameters: +
    + + + ?encoding + + : + Encoding + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + ?encoding + + : + Encoding +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.ReadBytes + + +

+ +
+
+ Full Usage: + this.ReadBytes +
+
+ Parameters: +
    + + + start + + : + int + +
    + + + len + + : + int + +
    +
+
+ + Returns: + byte[] + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + start + + : + int +
+
+
+ + len + + : + int +
+
+
+
+
+ + Returns: + + byte[] +
+
+
+
+
+ +

+ + + this.ReadLines + + +

+ +
+
+ Full Usage: + this.ReadLines +
+
+ Parameters: +
    + + + ?encoding + + : + Encoding + +
    +
+
+ + Returns: + string seq + +
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + ?encoding + + : + Encoding +
+
+
+
+
+ + Returns: + + string seq +
+
+
+
+
+ +

+ + + this.Write + + +

+ +
+
+ Full Usage: + this.Write +
+
+ Parameters: +
    + + + data + + : + 'a + +
    +
+
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + data + + : + 'a +
+
+
+
+
+ +

+ + + this.WriteAllLines + + +

+ +
+
+ Full Usage: + this.WriteAllLines +
+
+ Parameters: +
    + + + contents + + : + string seq + +
    + + + ?encoding + + : + Encoding + +
    +
+
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + contents + + : + string seq +
+
+
+ + ?encoding + + : + Encoding +
+
+
+
+
+ +

+ + + this.WriteAllText + + +

+ +
+
+ Full Usage: + this.WriteAllText +
+
+ Parameters: +
    + + + text + + : + string + +
    +
+
+
+
+
+ 		+

+ Extended Type: + Stream +

+
+
+ + text + + : + string +
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-io.html b/reference/fsharp-compiler-io.html new file mode 100644 index 0000000000..da1ad14a60 --- /dev/null +++ b/reference/fsharp-compiler-io.html @@ -0,0 +1,708 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.IO | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.IO Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + ByteMemory + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A view over bytes. + May be backed by managed or unmanaged memory, or memory mapped file. +

+
+
+

+ + + DefaultAssemblyLoader + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Default implementation for IAssemblyLoader +

+
+
+

+ + + DefaultFileSystem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a default (memory-mapped) implementation of the file system +

+
+
+

+ + + FileSystemAutoOpens + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + IAssemblyLoader + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Type which we use to load assemblies. +

+
+
+

+ + + IFileSystem + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a shim for the file system +

+
+
+

+ + + StreamExtensions + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpabstractparameter.html b/reference/fsharp-compiler-symbols-fsharpabstractparameter.html new file mode 100644 index 0000000000..c47d2b0e3b --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpabstractparameter.html @@ -0,0 +1,894 @@ + + + + + + + + + + + + + + + + + + FSharpAbstractParameter (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAbstractParameter Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a parameter in an abstract method of a class or interface +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + IList<FSharpAttribute> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The declared attributes of the parameter +

+
+ +
+
+ + Returns: + + IList<FSharpAttribute> +
+
+
+
+
+
+ +

+ + + this.IsInArg + + +

+ +
+
+ Full Usage: + this.IsInArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is an in argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsOptionalArg + + +

+ +
+
+ Full Usage: + this.IsOptionalArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is an optional argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsOutArg + + +

+ +
+
+ Full Usage: + this.IsOutArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is an out argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The optional name of the parameter +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.Type + + +

+ +
+
+ Full Usage: + this.Type +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The declared or inferred type of the parameter +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpabstractsignature.html b/reference/fsharp-compiler-symbols-fsharpabstractsignature.html new file mode 100644 index 0000000000..b325ef852a --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpabstractsignature.html @@ -0,0 +1,894 @@ + + + + + + + + + + + + + + + + + + FSharpAbstractSignature (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAbstractSignature Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the signature of an abstract slot of a class or interface +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AbstractArguments + + +

+ +
+
+ Full Usage: + this.AbstractArguments +
+
+ + Returns: + IList<IList<FSharpAbstractParameter>> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the arguments of the abstract slot +

+
+ +
+
+ + Returns: + + IList<IList<FSharpAbstractParameter>> +
+
+
+
+
+
+ +

+ + + this.AbstractReturnType + + +

+ +
+
+ Full Usage: + this.AbstractReturnType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the return type of the abstract slot +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.DeclaringType + + +

+ +
+
+ Full Usage: + this.DeclaringType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaring type of the abstract slot +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.DeclaringTypeGenericParameters + + +

+ +
+
+ Full Usage: + this.DeclaringTypeGenericParameters +
+
+ + Returns: + IList<FSharpGenericParameter> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the generic arguments of the type defining the abstract slot +

+
+ +
+
+ + Returns: + + IList<FSharpGenericParameter> +
+
+
+
+
+
+ +

+ + + this.MethodGenericParameters + + +

+ +
+
+ Full Usage: + this.MethodGenericParameters +
+
+ + Returns: + IList<FSharpGenericParameter> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the generic arguments of the abstract slot +

+
+ +
+
+ + Returns: + + IList<FSharpGenericParameter> +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the abstract slot +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpaccessibility.html b/reference/fsharp-compiler-symbols-fsharpaccessibility.html new file mode 100644 index 0000000000..6e865aba67 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpaccessibility.html @@ -0,0 +1,780 @@ + + + + + + + + + + + + + + + + + + FSharpAccessibility (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAccessibility Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Indicates the accessibility of a symbol, as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsInternal + + +

+ +
+
+ Full Usage: + this.IsInternal +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the symbol has internal accessibility. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPrivate + + +

+ +
+
+ Full Usage: + this.IsPrivate +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the symbol has private accessibility. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsProtected + + +

+ +
+
+ Full Usage: + this.IsProtected +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the symbol has protected accessibility. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPublic + + +

+ +
+
+ Full Usage: + this.IsPublic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the symbol has public accessibility. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpaccessibilityrights.html b/reference/fsharp-compiler-symbols-fsharpaccessibilityrights.html new file mode 100644 index 0000000000..3f5912f3db --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpaccessibilityrights.html @@ -0,0 +1,525 @@ + + + + + + + + + + + + + + + + + + FSharpAccessibilityRights (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAccessibilityRights Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the rights of a compilation to access symbols +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html b/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html new file mode 100644 index 0000000000..b42c54695e --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpactivepatterncase.html @@ -0,0 +1,894 @@ + + + + + + + + + + + + + + + + + + FSharpActivePatternCase (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpActivePatternCase Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a single case within an active pattern +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The location of declaration of the active pattern case +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.Group + + +

+ +
+
+ Full Usage: + this.Group +
+
+ + Returns: + FSharpActivePatternGroup + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The group of active pattern cases this belongs to +

+
+ +
+
+ + Returns: + + FSharpActivePatternGroup +
+
+
+
+
+
+ +

+ + + this.Index + + +

+ +
+
+ Full Usage: + this.Index +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Index of the case in the pattern group +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the active pattern case +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation for the entity +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+ +

+ + + this.XmlDocSig + + +

+ +
+
+ Full Usage: + this.XmlDocSig +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ XML documentation signature for the active pattern case, used for .xml file lookup for compiled code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html b/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html new file mode 100644 index 0000000000..e4394953f2 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpactivepatterngroup.html @@ -0,0 +1,837 @@ + + + + + + + + + + + + + + + + + + FSharpActivePatternGroup (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpActivePatternGroup Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents all cases within an active pattern +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DeclaringEntity + + +

+ +
+
+ Full Usage: + this.DeclaringEntity +
+
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Try to get the entity in which the active pattern is declared +

+
+ +
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+
+ +

+ + + this.IsTotal + + +

+ +
+
+ Full Usage: + this.IsTotal +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is a total active pattern +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The whole group name +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.Names + + +

+ +
+
+ Full Usage: + this.Names +
+
+ + Returns: + IList<string> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The names of the active pattern cases +

+
+ +
+
+ + Returns: + + IList<string> +
+
+
+
+
+
+ +

+ + + this.OverallType + + +

+ +
+
+ Full Usage: + this.OverallType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the type indicating signature of the active pattern +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html b/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html new file mode 100644 index 0000000000..f7d3c624df --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpanonrecordtypedetails.html @@ -0,0 +1,780 @@ + + + + + + + + + + + + + + + + + + FSharpAnonRecordTypeDetails (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAnonRecordTypeDetails Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ A subtype of FSharpSymbol that represents a record or union case field as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Assembly + + +

+ +
+
+ Full Usage: + this.Assembly +
+
+ + Returns: + FSharpAssembly + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The assembly where the compiled form of the anonymous type is defined +

+
+ +
+
+ + Returns: + + FSharpAssembly +
+
+
+
+
+
+ +

+ + + this.CompiledName + + +

+ +
+
+ Full Usage: + this.CompiledName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the compiled form of the anonymous type +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.EnclosingCompiledTypeNames + + +

+ +
+
+ Full Usage: + this.EnclosingCompiledTypeNames +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Names of any enclosing types of the compiled form of the anonymous type (if the anonymous type was defined as a nested type) +

+
+ +
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + this.SortedFieldNames + + +

+ +
+
+ Full Usage: + this.SortedFieldNames +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The sorted labels of the anonymous type +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpassembly.html b/reference/fsharp-compiler-symbols-fsharpassembly.html new file mode 100644 index 0000000000..102fa756f3 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpassembly.html @@ -0,0 +1,837 @@ + + + + + + + + + + + + + + + + + + FSharpAssembly (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAssembly Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an assembly as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Contents + + +

+ +
+
+ Full Usage: + this.Contents +
+
+ + Returns: + FSharpAssemblySignature + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The contents of the this assembly +

+
+ +
+
+ + Returns: + + FSharpAssemblySignature +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The file name for the assembly, if any +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.IsProviderGenerated + + +

+ +
+
+ Full Usage: + this.IsProviderGenerated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the assembly was generated by a type provider and is due for static linking +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The qualified name of the assembly +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.SimpleName + + +

+ +
+
+ Full Usage: + this.SimpleName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The simple name for the assembly +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpassemblycontents.html b/reference/fsharp-compiler-symbols-fsharpassemblycontents.html new file mode 100644 index 0000000000..04ba57ba0f --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpassemblycontents.html @@ -0,0 +1,609 @@ + + + + + + + + + + + + + + + + + + FSharpAssemblyContents (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAssemblyContents Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the definitional contents of an assembly, as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ImplementationFiles + + +

+ +
+
+ Full Usage: + this.ImplementationFiles +
+
+ + Returns: + FSharpImplementationFileContents list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The contents of the implementation files in the assembly +

+
+ +
+
+ + Returns: + + FSharpImplementationFileContents list +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpassemblysignature.html b/reference/fsharp-compiler-symbols-fsharpassemblysignature.html new file mode 100644 index 0000000000..5b696b6f63 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpassemblysignature.html @@ -0,0 +1,803 @@ + + + + + + + + + + + + + + + + + + FSharpAssemblySignature (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAssemblySignature Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an inferred signature of part of an assembly as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + IList<FSharpAttribute> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declared attributes for the assembly. + Only available when parsing an entire project. +

+
+ +
+
+ + Returns: + + IList<FSharpAttribute> +
+
+
+
+
+
+ +

+ + + this.Entities + + +

+ +
+
+ Full Usage: + this.Entities +
+
+ + Returns: + IList<FSharpEntity> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The (non-nested) module and type definitions in this signature +

+
+ +
+
+ + Returns: + + IList<FSharpEntity> +
+
+
+
+
+
+ +

+ + + this.FindEntityByPath + + +

+ +
+
+ Full Usage: + this.FindEntityByPath +
+
+ Parameters: +
    + + + arg0 + + : + string list + +
    +
+
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Find entity using compiled names +

+
+ +
+
+ + arg0 + + : + string list +
+
+
+
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+
+ +

+ + + this.TryGetEntities + + +

+ +
+
+ Full Usage: + this.TryGetEntities +
+
+ + Returns: + FSharpEntity seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Safe version of `Entities`. +

+
+ +
+
+ + Returns: + + FSharpEntity seq +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpattribute.html b/reference/fsharp-compiler-symbols-fsharpattribute.html new file mode 100644 index 0000000000..5dfd24d9c0 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpattribute.html @@ -0,0 +1,973 @@ + + + + + + + + + + + + + + + + + + FSharpAttribute (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpAttribute Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a custom attribute attached to F# source code or a compiler .NET component +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AttributeType + + +

+ +
+
+ Full Usage: + this.AttributeType +
+
+ + Returns: + FSharpEntity + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The type of the attribute +

+
+ +
+
+ + Returns: + + FSharpEntity +
+
+
+
+
+
+ +

+ + + this.ConstructorArguments + + +

+ +
+
+ Full Usage: + this.ConstructorArguments +
+
+ + Returns: + IList<FSharpType * obj> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The arguments to the constructor for the attribute +

+
+ +
+
+ + Returns: + + IList<FSharpType * obj> +
+
+
+
+
+
+ +

+ + + this.Format + + +

+ +
+
+ Full Usage: + this.Format +
+
+ Parameters: + +
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the attribute using the rules of the given display context +

+
+ +
+
+ + context + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.IsAttribute + + +

+ +
+
+ Full Usage: + this.IsAttribute +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if attribute matchies the full name of the given type parameter +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnresolved + + +

+ +
+
+ Full Usage: + this.IsUnresolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the attribute type is in an unresolved assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.NamedArguments + + +

+ +
+
+ Full Usage: + this.NamedArguments +
+
+ + Returns: + IList<FSharpType * string * bool * obj> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The named arguments for the attribute +

+
+ +
+
+ + Returns: + + IList<FSharpType * string * bool * obj> +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the range of the name of the attribute +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpdelegatesignature.html b/reference/fsharp-compiler-symbols-fsharpdelegatesignature.html new file mode 100644 index 0000000000..40e4dcaf23 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpdelegatesignature.html @@ -0,0 +1,666 @@ + + + + + + + + + + + + + + + + + + FSharpDelegateSignature (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpDelegateSignature Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a delegate signature in an F# symbol +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DelegateArguments + + +

+ +
+
+ Full Usage: + this.DelegateArguments +
+
+ + Returns: + IList<string option * FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the argument types of the delegate signature +

+
+ +
+
+ + Returns: + + IList<string option * FSharpType> +
+
+
+
+
+
+ +

+ + + this.DelegateReturnType + + +

+ +
+
+ Full Usage: + this.DelegateReturnType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the return type of the delegate signature +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html b/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html new file mode 100644 index 0000000000..fa5c56aab8 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpdisplaycontext.html @@ -0,0 +1,790 @@ + + + + + + + + + + + + + + + + + + FSharpDisplayContext (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpDisplayContext Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the information needed to format types and other information in a style + suitable for use in F# source text at a particular source location. + + Acquired via GetDisplayEnvAtLocationAlternate and similar methods. May be passed + to the Format method on FSharpType and other methods. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.WithPrefixGenericParameters + + +

+ +
+
+ Full Usage: + this.WithPrefixGenericParameters +
+
+ + Returns: + FSharpDisplayContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Causes type signatures to be formatted with prefix-style generic parameters, + for example `list`. +

+
+ +
+
+ + Returns: + + FSharpDisplayContext +
+
+
+
+
+
+ +

+ + + this.WithShortTypeNames + + +

+ +
+
+ Full Usage: + this.WithShortTypeNames +
+
+ Parameters: +
    + + + arg0 + + : + bool + +
    +
+
+ + Returns: + FSharpDisplayContext + +
+
+
+
+ 		+
+
+ + arg0 + + : + bool +
+
+
+
+
+ + Returns: + + FSharpDisplayContext +
+
+
+
+
+ +

+ + + this.WithSuffixGenericParameters + + +

+ +
+
+ Full Usage: + this.WithSuffixGenericParameters +
+
+ + Returns: + FSharpDisplayContext + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Causes type signatures to be formatted with suffix-style generic parameters, + for example `int list` +

+
+ +
+
+ + Returns: + + FSharpDisplayContext +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpDisplayContext.Empty + + +

+ +
+
+ Full Usage: + FSharpDisplayContext.Empty +
+
+ + Returns: + FSharpDisplayContext + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpDisplayContext +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpentity.html b/reference/fsharp-compiler-symbols-fsharpentity.html new file mode 100644 index 0000000000..2d1db30f65 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpentity.html @@ -0,0 +1,4034 @@ + + + + + + + + + + + + + + + + + + FSharpEntity (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpEntity Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a type definition or module as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AbbreviatedType + + +

+ +
+
+ Full Usage: + this.AbbreviatedType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the type abbreviated by an F# type abbreviation +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.AccessPath + + +

+ +
+
+ Full Usage: + this.AccessPath +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the path used to address the entity (e.g. "Namespace.Module1.NestedModule2"). Gives + "global" for items not in a namespace. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ActivePatternCases + + +

+ +
+
+ Full Usage: + this.ActivePatternCases +
+
+ + Returns: + FSharpActivePatternCase list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all active pattern cases defined in all active patterns in the module. +

+
+ +
+
+ + Returns: + + FSharpActivePatternCase list +
+
+
+
+
+
+ +

+ + + this.AllCompilationPaths + + +

+ +
+
+ Full Usage: + this.AllCompilationPaths +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all compilation paths, taking `Module` suffixes into account. +

+
+ +
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + this.AllInterfaces + + +

+ +
+
+ Full Usage: + this.AllInterfaces +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all the interface implementations, by walking the type hierarchy +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+ +

+ + + this.ArrayRank + + +

+ +
+
+ Full Usage: + this.ArrayRank +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the rank of an array type +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.AsType + + +

+ +
+
+ Full Usage: + this.AsType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Instantiates FSharpType +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.BaseType + + +

+ +
+
+ Full Usage: + this.BaseType +
+
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the base type, if any +

+
+ +
+
+ + Returns: + + FSharpType option +
+
+
+
+
+
+ +

+ + + this.BasicQualifiedName + + +

+ +
+
+ Full Usage: + this.BasicQualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The fully qualified name of the type or module without strong assembly name. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.CompiledName + + +

+ +
+
+ Full Usage: + this.CompiledName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the compiled name of the type or module, possibly with `n mangling. This is identical to LogicalName + unless the CompiledName attribute is used. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaration location for the type constructor +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.DeclaredInterfaces + + +

+ +
+
+ Full Usage: + this.DeclaredInterfaces +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declared interface implementations +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+ +

+ + + this.DeclaringEntity + + +

+ +
+
+ Full Usage: + this.DeclaringEntity +
+
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the enclosing entity for the definition +

+
+ +
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+
+ +

+ + + this.DisplayName + + +

+ +
+
+ Full Usage: + this.DisplayName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the type or module as displayed in F# code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.FSharpDelegateSignature + + +

+ +
+
+ Full Usage: + this.FSharpDelegateSignature +
+
+ + Returns: + FSharpDelegateSignature + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is a delegate with the given Invoke signature +

+
+ +
+
+ + Returns: + + FSharpDelegateSignature +
+
+
+
+
+
+ +

+ + + this.FSharpFields + + +

+ +
+
+ Full Usage: + this.FSharpFields +
+
+ + Returns: + IList<FSharpField> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the fields of a record, class, struct or enum from the perspective of the F# language. + This includes static fields, the 'val' bindings in classes and structs, and the value definitions in enums. + For classes, the list may include compiler generated fields implied by the use of primary constructors. +

+
+ +
+
+ + Returns: + + IList<FSharpField> +
+
+
+
+
+
+ +

+ + + this.FullName + + +

+ +
+
+ Full Usage: + this.FullName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the full name of the type or module +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GenericParameters + + +

+ +
+
+ Full Usage: + this.GenericParameters +
+
+ + Returns: + IList<FSharpGenericParameter> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the generic parameters, possibly including unit-of-measure parameters +

+
+ +
+
+ + Returns: + + IList<FSharpGenericParameter> +
+
+
+
+
+
+ +

+ + + this.GetPublicNestedEntities + + +

+ +
+
+ Full Usage: + this.GetPublicNestedEntities +
+
+ + Returns: + FSharpEntity seq + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Public nested entities (methods, functions, values, nested modules). +

+
+ +
+
+ + Returns: + + FSharpEntity seq +
+
+
+
+
+
+ +

+ + + this.HasAssemblyCodeRepresentation + + +

+ +
+
+ Full Usage: + this.HasAssemblyCodeRepresentation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is implemented through a mapping to IL assembly code. This is only + true for types in FSharp.Core.dll +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.HasFSharpModuleSuffix + + +

+ +
+
+ Full Usage: + this.HasFSharpModuleSuffix +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsAbstractClass + + +

+ +
+
+ Full Usage: + this.IsAbstractClass +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is an abstract class +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsArrayType + + +

+ +
+
+ Full Usage: + this.IsArrayType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is an array type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsAttributeType + + +

+ +
+
+ Full Usage: + this.IsAttributeType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Check if the entity inherits from System.Attribute in its type hierarchy +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsByRef + + +

+ +
+
+ Full Usage: + this.IsByRef +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if is the 'byref<_>' type definition used for byref types in F#-compiled assemblies +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsClass + + +

+ +
+
+ Full Usage: + this.IsClass +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a class type definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsDelegate + + +

+ +
+
+ Full Usage: + this.IsDelegate +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a delegate type definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEnum + + +

+ +
+
+ Full Usage: + this.IsEnum +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is an enum type definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFSharp + + +

+ +
+
+ Full Usage: + this.IsFSharp +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a reference to something in an F#-compiled assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFSharpAbbreviation + + +

+ +
+
+ Full Usage: + this.IsFSharpAbbreviation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a measure, type or exception abbreviation +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFSharpExceptionDeclaration + + +

+ +
+
+ Full Usage: + this.IsFSharpExceptionDeclaration +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates an F# exception declaration +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFSharpModule + + +

+ +
+
+ Full Usage: + this.IsFSharpModule +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is an F# module definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFSharpRecord + + +

+ +
+
+ Full Usage: + this.IsFSharpRecord +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is record type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFSharpUnion + + +

+ +
+
+ Full Usage: + this.IsFSharpUnion +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is union type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsInterface + + +

+ +
+
+ Full Usage: + this.IsInterface +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is an interface type definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMeasure + + +

+ +
+
+ Full Usage: + this.IsMeasure +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a measure definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsNamespace + + +

+ +
+
+ Full Usage: + this.IsNamespace +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a part of a namespace path +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsOpaque + + +

+ +
+
+ Full Usage: + this.IsOpaque +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a type definition for a reference type where the implementation details are hidden by a signature +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsProvided + + +

+ +
+
+ Full Usage: + this.IsProvided +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a provided type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsProvidedAndErased + + +

+ +
+
+ Full Usage: + this.IsProvidedAndErased +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is an erased provided type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsProvidedAndGenerated + + +

+ +
+
+ Full Usage: + this.IsProvidedAndGenerated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a generated provided type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsStaticInstantiation + + +

+ +
+
+ Full Usage: + this.IsStaticInstantiation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a 'fake' symbol related to a static instantiation of a type provider +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnresolved + + +

+ +
+
+ Full Usage: + this.IsUnresolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is in an unresolved assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsValueType + + +

+ +
+
+ Full Usage: + this.IsValueType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the entity is a struct or enum +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.LogicalName + + +

+ +
+
+ Full Usage: + this.LogicalName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the type or module, possibly with `n mangling +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.MembersFunctionsAndValues + + +

+ +
+
+ Full Usage: + this.MembersFunctionsAndValues +
+
+ + Returns: + IList<FSharpMemberOrFunctionOrValue> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the properties, events and methods of a type definitions, or the functions and values of a module +

+
+ +
+
+ + Returns: + + IList<FSharpMemberOrFunctionOrValue> +
+
+
+
+
+
+ +

+ + + this.Namespace + + +

+ +
+
+ Full Usage: + this.Namespace +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the namespace containing the type or module, if any. Use 'None' for item not in a namespace. +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.NestedEntities + + +

+ +
+
+ Full Usage: + this.NestedEntities +
+
+ + Returns: + IList<FSharpEntity> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the modules and types defined in a module, or the nested types of a type +

+
+ +
+
+ + Returns: + + IList<FSharpEntity> +
+
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the fully qualified name of the type or module +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.RepresentationAccessibility + + +

+ +
+
+ Full Usage: + this.RepresentationAccessibility +
+
+ + Returns: + FSharpAccessibility + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declared accessibility of the representation, not taking signatures into account +

+
+ +
+
+ + Returns: + + FSharpAccessibility +
+
+
+
+
+
+ +

+ + + this.StaticParameters + + +

+ +
+
+ Full Usage: + this.StaticParameters +
+
+ + Returns: + IList<FSharpStaticParameter> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the static parameters for a provided type +

+
+ +
+
+ + Returns: + + IList<FSharpStaticParameter> +
+
+
+
+
+
+ +

+ + + this.TryFullName + + +

+ +
+
+ Full Usage: + this.TryFullName +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the full name of the type or module if it is available +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.TryGetFullCompiledName + + +

+ +
+
+ Full Usage: + this.TryGetFullCompiledName +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Safe version of `CompiledName`. +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.TryGetFullDisplayName + + +

+ +
+
+ Full Usage: + this.TryGetFullDisplayName +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Safe version of `DisplayName`. +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.TryGetFullName + + +

+ +
+
+ Full Usage: + this.TryGetFullName +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Safe version of `FullName`. +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.TryGetMembersFunctionsAndValues + + +

+ +
+
+ Full Usage: + this.TryGetMembersFunctionsAndValues +
+
+ + Returns: + IList<FSharpMemberOrFunctionOrValue> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Safe version of `GetMembersFunctionsAndValues`. +

+
+ +
+
+ + Returns: + + IList<FSharpMemberOrFunctionOrValue> +
+
+
+
+
+
+ +

+ + + this.TryGetMetadataText + + +

+ +
+
+ Full Usage: + this.TryGetMetadataText +
+
+ + Returns: + ISourceText option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the source text of the entity's signature to be used as metadata. +

+
+ +
+
+ + Returns: + + ISourceText option +
+
+
+
+
+
+ +

+ + + this.UnionCases + + +

+ +
+
+ Full Usage: + this.UnionCases +
+
+ + Returns: + IList<FSharpUnionCase> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the cases of a union type +

+
+ +
+
+ + Returns: + + IList<FSharpUnionCase> +
+
+
+
+
+
+ +

+ + + this.UsesPrefixDisplay + + +

+ +
+
+ Full Usage: + this.UsesPrefixDisplay +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type prefers the "tycon" syntax for display etc. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation for the entity +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+ +

+ + + this.XmlDocSig + + +

+ +
+
+ Full Usage: + this.XmlDocSig +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation signature for the entity, used for .xml file lookup for compiled code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpexpr.html b/reference/fsharp-compiler-symbols-fsharpexpr.html new file mode 100644 index 0000000000..bd92b44a12 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpexpr.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + FSharpExpr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpExpr Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a checked and reduced expression, as seen by the F# language. The active patterns + in 'FSharp.Compiler.SourceCodeServices' can be used to analyze information about the expression. + + Pattern matching is reduced to decision trees and conditional tests. Some other + constructs may be represented in reduced form. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ImmediateSubExpressions + + +

+ +
+
+ Full Usage: + this.ImmediateSubExpressions +
+
+ + Returns: + FSharpExpr list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The immediate sub-expressions of the expression. +

+
+ +
+
+ + Returns: + + FSharpExpr list +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The range of the expression +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.Type + + +

+ +
+
+ Full Usage: + this.Type +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The type of the expression +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpexprpatterns.html b/reference/fsharp-compiler-symbols-fsharpexprpatterns.html new file mode 100644 index 0000000000..3fc8ea4b18 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpexprpatterns.html @@ -0,0 +1,4344 @@ + + + + + + + + + + + + + + + + + + FSharpExprPatterns (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpExprPatterns Module +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ A collection of active patterns to analyze expressions +

+
+
+
+
+
+

+ Active patterns +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Active pattern + + Description +
+
+ +

+ + + (|AddressOf|_|) arg1 + + +

+ +
+
+ Full Usage: + (|AddressOf|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpExpr option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which take the address of a location +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + FSharpExpr option +
+
+
+
+
+
+ +

+ + + (|AddressSet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|AddressSet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which set the contents of an address +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|AnonRecordGet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|AnonRecordGet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpType * int) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions getting a field from an anonymous record. The integer represents the + index into the sorted fields of the anonymous record. +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpType * int) option +
+
+
+
+
+
+ +

+ + + (|Application|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Application|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpType list * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are the application of function values +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpType list * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|BaseValue|_|) arg1 + + +

+ +
+
+ Full Usage: + (|BaseValue|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are uses of the 'base' value +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + FSharpType option +
+
+
+
+
+
+ +

+ + + (|CallWithWitnesses|_|) arg1 + + +

+ +
+
+ Full Usage: + (|CallWithWitnesses|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Like Call but also indicates witness arguments +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|Call|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Call|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are calls to members or module-defined functions. When calling curried functions and members the + arguments are collapsed to a single collection of arguments, as done in the compiled version of these. +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|Coerce|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Coerce|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which coerce the type of a value +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|Const|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Const|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (obj * FSharpType) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches constant expressions, including signed and unsigned integers, strings, characters, booleans, arrays + of bytes and arrays of unit16. +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (obj * FSharpType) option +
+
+
+
+
+
+ +

+ + + (|DebugPoint|_|) arg1 + + +

+ +
+
+ Full Usage: + (|DebugPoint|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (DebugPointAtLeafExpr * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches debug points at leaf expressions in control flow +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (DebugPointAtLeafExpr * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|DecisionTreeSuccess|_|) arg1 + + +

+ +
+
+ Full Usage: + (|DecisionTreeSuccess|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (int * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Special expressions at the end of a conditional decision structure in the decision expression node of a DecisionTree . + The given expressions are passed as values to the decision tree target. +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (int * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|DecisionTree|_|) arg1 + + +

+ +
+
+ Full Usage: + (|DecisionTree|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions with a decision expression, each branch of which ends in DecisionTreeSuccess passing control and values to one of the targets. +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list) option +
+
+
+
+
+
+ +

+ + + (|DefaultValue|_|) arg1 + + +

+ +
+
+ Full Usage: + (|DefaultValue|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches default-value expressions, including null expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + FSharpType option +
+
+
+
+
+
+ +

+ + + (|FSharpFieldGet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FSharpFieldGet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr option * FSharpType * FSharpField) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which get a field from a record or class +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr option * FSharpType * FSharpField) option +
+
+
+
+
+
+ +

+ + + (|FSharpFieldSet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FSharpFieldSet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr option * FSharpType * FSharpField * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which set a field in a record or class +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr option * FSharpType * FSharpField * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|FastIntegerForLoop|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FastIntegerForLoop|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpExpr * FSharpExpr * bool * DebugPointAtFor * DebugPointAtInOrTo) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches fast-integer loops (up or down) +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpExpr * FSharpExpr * bool * DebugPointAtFor * DebugPointAtInOrTo) option +
+
+
+
+
+
+ +

+ + + (|ILAsm|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ILAsm|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (string * FSharpType list * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are IL assembly code +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (string * FSharpType list * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|ILFieldGet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ILFieldGet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr option * FSharpType * string) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which fetch a field from a .NET type +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr option * FSharpType * string) option +
+
+
+
+
+
+ +

+ + + (|ILFieldSet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ILFieldSet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr option * FSharpType * string * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which set a field in a .NET type +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr option * FSharpType * string * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|IfThenElse|_|) arg1 + + +

+ +
+
+ Full Usage: + (|IfThenElse|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpExpr * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are conditionals +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpExpr * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|Lambda|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Lambda|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpMemberOrFunctionOrValue * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are lambda abstractions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpMemberOrFunctionOrValue * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|LetRec|_|) arg1 + + +

+ +
+
+ Full Usage: + (|LetRec|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + ((FSharpMemberOrFunctionOrValue * FSharpExpr * DebugPointAtBinding) list * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are let-rec definitions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + ((FSharpMemberOrFunctionOrValue * FSharpExpr * DebugPointAtBinding) list * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|Let|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Let|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + ((FSharpMemberOrFunctionOrValue * FSharpExpr * DebugPointAtBinding) * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are let definitions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + ((FSharpMemberOrFunctionOrValue * FSharpExpr * DebugPointAtBinding) * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|NewAnonRecord|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewAnonRecord|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches anonymous record expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|NewArray|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewArray|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches array expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|NewDelegate|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewDelegate|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which create an instance of a delegate type +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|NewObject|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewObject|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are calls to object constructors +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|NewRecord|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewRecord|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches record expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|NewTuple|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewTuple|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches tuple expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|NewUnionCase|_|) arg1 + + +

+ +
+
+ Full Usage: + (|NewUnionCase|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpUnionCase * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which create an object corresponding to a union case +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpUnionCase * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|ObjectExpr|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ObjectExpr|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr * FSharpObjectExprOverride list * (FSharpType * FSharpObjectExprOverride list) list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches object expressions, returning the base type, the base call, the overrides and the interface implementations +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr * FSharpObjectExprOverride list * (FSharpType * FSharpObjectExprOverride list) list) option +
+
+
+
+
+
+ +

+ + + (|Quote|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Quote|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpExpr option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are quotation literals +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + FSharpExpr option +
+
+
+
+
+
+ +

+ + + (|Sequential|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Sequential|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches sequential expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|ThisValue|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ThisValue|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are uses of the 'this' value +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + FSharpType option +
+
+
+
+
+
+ +

+ + + (|TraitCall|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TraitCall|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType list * string * SynMemberFlags * FSharpType list * FSharpType list * FSharpExpr list) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions for an unresolved call to a trait +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType list * string * SynMemberFlags * FSharpType list * FSharpType list * FSharpExpr list) option +
+
+
+
+
+
+ +

+ + + (|TryFinally|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TryFinally|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpExpr * DebugPointAtTry * DebugPointAtFinally) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches try/finally expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpExpr * DebugPointAtTry * DebugPointAtFinally) option +
+
+
+
+
+
+ +

+ + + (|TryWith|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TryWith|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * DebugPointAtTry * DebugPointAtWith) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches try/with expressions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * DebugPointAtTry * DebugPointAtWith) option +
+
+
+
+
+
+ +

+ + + (|TupleGet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TupleGet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * int * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which get a value from a tuple +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * int * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|TypeLambda|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TypeLambda|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpGenericParameter list * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are type abstractions +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpGenericParameter list * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|TypeTest|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TypeTest|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpType * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which test the runtime type of a value +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpType * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|UnionCaseGet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|UnionCaseGet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which get a field from a union case +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField) option +
+
+
+
+
+
+ +

+ + + (|UnionCaseSet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|UnionCaseSet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which set a field from a union case (only used in FSharp.Core itself) +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|UnionCaseTag|_|) arg1 + + +

+ +
+
+ Full Usage: + (|UnionCaseTag|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpType) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which gets the tag for a union case +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpType) option +
+
+
+
+
+
+ +

+ + + (|UnionCaseTest|_|) arg1 + + +

+ +
+
+ Full Usage: + (|UnionCaseTest|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpType * FSharpUnionCase) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which test if an expression corresponds to a particular union case +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpType * FSharpUnionCase) option +
+
+
+
+
+
+ +

+ + + (|ValueSet|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ValueSet|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpMemberOrFunctionOrValue * FSharpExpr) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which set the contents of a mutable variable +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpMemberOrFunctionOrValue * FSharpExpr) option +
+
+
+
+
+
+ +

+ + + (|Value|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Value|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpMemberOrFunctionOrValue option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches expressions which are uses of values +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + FSharpMemberOrFunctionOrValue option +
+
+
+
+
+
+ +

+ + + (|WhileLoop|_|) arg1 + + +

+ +
+
+ Full Usage: + (|WhileLoop|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpExpr * FSharpExpr * DebugPointAtWhile) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Matches while loops +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + (FSharpExpr * FSharpExpr * DebugPointAtWhile) option +
+
+
+
+
+
+ +

+ + + (|WitnessArg|_|) arg1 + + +

+ +
+
+ Full Usage: + (|WitnessArg|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + int option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a witness argument index from the witness arguments supplied to the enclosing method +

+
+ +
+
+ + arg0 + + : + FSharpExpr +
+
+
+
+
+ + Returns: + + int option +
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpfield.html b/reference/fsharp-compiler-symbols-fsharpfield.html new file mode 100644 index 0000000000..1b5bc08fab --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpfield.html @@ -0,0 +1,1750 @@ + + + + + + + + + + + + + + + + + + FSharpField (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpField Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a record or union case field as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AnonRecordFieldDetails + + +

+ +
+
+ Full Usage: + this.AnonRecordFieldDetails +
+
+ + Returns: + FSharpAnonRecordTypeDetails * FSharpType[] * int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ If the field is from an anonymous record type then get the details of the field including the index in the sorted array of fields +

+
+ +
+
+ + Returns: + + FSharpAnonRecordTypeDetails * FSharpType[] * int +
+
+
+
+
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaration location of the field +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.DeclaringEntity + + +

+ +
+
+ Full Usage: + this.DeclaringEntity +
+
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaring entity of this field, if any. Fields from anonymous types do not have a declaring entity +

+
+ +
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+
+ +

+ + + this.DeclaringUnionCase + + +

+ +
+
+ Full Usage: + this.DeclaringUnionCase +
+
+ + Returns: + FSharpUnionCase option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns the declaring union case symbol +

+
+ +
+
+ + Returns: + + FSharpUnionCase option +
+
+
+
+
+
+ +

+ + + this.FieldAttributes + + +

+ +
+
+ Full Usage: + this.FieldAttributes +
+
+ + Returns: + IList<FSharpAttribute> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the attributes attached to generated field +

+
+ +
+
+ + Returns: + + IList<FSharpAttribute> +
+
+
+
+
+
+ +

+ + + this.FieldType + + +

+ +
+
+ Full Usage: + this.FieldType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the type of the field, w.r.t. the generic parameters of the enclosing type constructor +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.IsAnonRecordField + + +

+ +
+
+ Full Usage: + this.IsAnonRecordField +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Is this a field from an anonymous record type? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsCompilerGenerated + + +

+ +
+
+ Full Usage: + this.IsCompilerGenerated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a compiler generated field, not visible to Intellisense or name resolution +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsDefaultValue + + +

+ +
+
+ Full Usage: + this.IsDefaultValue +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the field declared is declared 'DefaultValue' +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsLiteral + + +

+ +
+
+ Full Usage: + this.IsLiteral +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the field has a literal value +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMutable + + +

+ +
+
+ Full Usage: + this.IsMutable +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the field is declared 'static' +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsNameGenerated + + +

+ +
+
+ Full Usage: + this.IsNameGenerated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the field name was generated by compiler (e.g. ItemN names in union cases and DataN in exceptions). + This API returns true for source defined symbols only. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsStatic + + +

+ +
+
+ Full Usage: + this.IsStatic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a static field +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnionCaseField + + +

+ +
+
+ Full Usage: + this.IsUnionCaseField +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the field is declared in a union case +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnresolved + + +

+ +
+
+ Full Usage: + this.IsUnresolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the record field is for a type in an unresolved assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsVolatile + + +

+ +
+
+ Full Usage: + this.IsVolatile +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the field is declared volatile +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.LiteralValue + + +

+ +
+
+ Full Usage: + this.LiteralValue +
+
+ + Returns: + obj option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the default initialization info, for static literals +

+
+ +
+
+ + Returns: + + obj option +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the field +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.PropertyAttributes + + +

+ +
+
+ Full Usage: + this.PropertyAttributes +
+
+ + Returns: + IList<FSharpAttribute> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the attributes attached to generated property +

+
+ +
+
+ + Returns: + + IList<FSharpAttribute> +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation for the entity +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+ +

+ + + this.XmlDocSig + + +

+ +
+
+ Full Usage: + this.XmlDocSig +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation signature for .xml file lookup for the field, used for .xml file lookup for compiled code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpgenericparameter.html b/reference/fsharp-compiler-symbols-fsharpgenericparameter.html new file mode 100644 index 0000000000..4aeae3f7ca --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpgenericparameter.html @@ -0,0 +1,951 @@ + + + + + + + + + + + + + + + + + + FSharpGenericParameter (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpGenericParameter Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a generic parameter for an FSharpSymbol +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Constraints + + +

+ +
+
+ Full Usage: + this.Constraints +
+
+ + Returns: + IList<FSharpGenericParameterConstraint> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declared or inferred constraints for the type parameter +

+
+ +
+
+ + Returns: + + IList<FSharpGenericParameterConstraint> +
+
+
+
+
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the range of the generic parameter +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.IsCompilerGenerated + + +

+ +
+
+ Full Usage: + this.IsCompilerGenerated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a compiler generated type parameter +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMeasure + + +

+ +
+
+ Full Usage: + this.IsMeasure +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a measure variable +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsSolveAtCompileTime + + +

+ +
+
+ Full Usage: + this.IsSolveAtCompileTime +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a statically resolved type variable +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the generic parameter +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation for the entity +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html b/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html new file mode 100644 index 0000000000..c8f46eefb3 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpgenericparameterconstraint.html @@ -0,0 +1,1635 @@ + + + + + + + + + + + + + + + + + + FSharpGenericParameterConstraint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpGenericParameterConstraint Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a constraint on a generic type parameter +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CoercesToTarget + + +

+ +
+
+ Full Usage: + this.CoercesToTarget +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets further information about a coerces-to constraint +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.DefaultsToConstraintData + + +

+ +
+
+ Full Usage: + this.DefaultsToConstraintData +
+
+ + Returns: + FSharpGenericParameterDefaultsToConstraint + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets further information about a defaults-to constraint +

+
+ +
+
+ + Returns: + + FSharpGenericParameterDefaultsToConstraint +
+
+
+
+
+
+ +

+ + + this.DelegateConstraintData + + +

+ +
+
+ Full Usage: + this.DelegateConstraintData +
+
+ + Returns: + FSharpGenericParameterDelegateConstraint + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets further information about a delegate constraint +

+
+ +
+
+ + Returns: + + FSharpGenericParameterDelegateConstraint +
+
+
+
+
+
+ +

+ + + this.EnumConstraintTarget + + +

+ +
+
+ Full Usage: + this.EnumConstraintTarget +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets further information about an enumeration constraint +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.IsCoercesToConstraint + + +

+ +
+
+ Full Usage: + this.IsCoercesToConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type is a subtype of the given type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsComparisonConstraint + + +

+ +
+
+ Full Usage: + this.IsComparisonConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type supports F# generic comparison +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsDefaultsToConstraint + + +

+ +
+
+ Full Usage: + this.IsDefaultsToConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a default value for an inference type variable should it be neither generalized nor solved +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsDelegateConstraint + + +

+ +
+
+ Full Usage: + this.IsDelegateConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type is a delegate from the given tuple of args to the given return type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEnumConstraint + + +

+ +
+
+ Full Usage: + this.IsEnumConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type is an enum with the given underlying +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEqualityConstraint + + +

+ +
+
+ Full Usage: + this.IsEqualityConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type supports F# generic equality +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMemberConstraint + + +

+ +
+
+ Full Usage: + this.IsMemberConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type has a member with the given signature +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsNonNullableValueTypeConstraint + + +

+ +
+
+ Full Usage: + this.IsNonNullableValueTypeConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type is a non-Nullable value type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsReferenceTypeConstraint + + +

+ +
+
+ Full Usage: + this.IsReferenceTypeConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type is a reference type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsRequiresDefaultConstructorConstraint + + +

+ +
+
+ Full Usage: + this.IsRequiresDefaultConstructorConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type has a parameterless constructor +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsSimpleChoiceConstraint + + +

+ +
+
+ Full Usage: + this.IsSimpleChoiceConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that is a type is a simple choice between one of the given ground types. Used by printf format strings. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsSupportsNullConstraint + + +

+ +
+
+ Full Usage: + this.IsSupportsNullConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type has a 'null' value +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnmanagedConstraint + + +

+ +
+
+ Full Usage: + this.IsUnmanagedConstraint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates a constraint that a type is an unmanaged type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.MemberConstraintData + + +

+ +
+
+ Full Usage: + this.MemberConstraintData +
+
+ + Returns: + FSharpGenericParameterMemberConstraint + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets further information about a member constraint +

+
+ +
+
+ + Returns: + + FSharpGenericParameterMemberConstraint +
+
+
+
+
+
+ +

+ + + this.SimpleChoices + + +

+ +
+
+ Full Usage: + this.SimpleChoices +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets further information about a choice constraint +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpgenericparameterdefaultstoconstraint.html b/reference/fsharp-compiler-symbols-fsharpgenericparameterdefaultstoconstraint.html new file mode 100644 index 0000000000..0b5ecad173 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpgenericparameterdefaultstoconstraint.html @@ -0,0 +1,666 @@ + + + + + + + + + + + + + + + + + + FSharpGenericParameterDefaultsToConstraint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpGenericParameterDefaultsToConstraint Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents further information about a 'defaults to' constraint on a generic type parameter +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DefaultsToPriority + + +

+ +
+
+ Full Usage: + this.DefaultsToPriority +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the priority off the 'defaults to' constraint +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.DefaultsToTarget + + +

+ +
+
+ Full Usage: + this.DefaultsToTarget +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the default type associated with the 'defaults to' constraint +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpgenericparameterdelegateconstraint.html b/reference/fsharp-compiler-symbols-fsharpgenericparameterdelegateconstraint.html new file mode 100644 index 0000000000..f44f2f710d --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpgenericparameterdelegateconstraint.html @@ -0,0 +1,666 @@ + + + + + + + + + + + + + + + + + + FSharpGenericParameterDelegateConstraint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpGenericParameterDelegateConstraint Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents further information about a delegate constraint on a generic type parameter +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DelegateReturnType + + +

+ +
+
+ Full Usage: + this.DelegateReturnType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the return type required by the constraint +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.DelegateTupledArgumentType + + +

+ +
+
+ Full Usage: + this.DelegateTupledArgumentType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the tupled argument type required by the constraint +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html b/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html new file mode 100644 index 0000000000..8484750cf3 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpgenericparametermemberconstraint.html @@ -0,0 +1,837 @@ + + + + + + + + + + + + + + + + + + FSharpGenericParameterMemberConstraint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpGenericParameterMemberConstraint Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ Represents further information about a member constraint on a generic type parameter +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.MemberArgumentTypes + + +

+ +
+
+ Full Usage: + this.MemberArgumentTypes +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the argument types of the method required by the constraint +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+ +

+ + + this.MemberIsStatic + + +

+ +
+
+ Full Usage: + this.MemberIsStatic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the the method required by the constraint must be static +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.MemberName + + +

+ +
+
+ Full Usage: + this.MemberName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the method required by the constraint +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.MemberReturnType + + +

+ +
+
+ Full Usage: + this.MemberReturnType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the return type of the method required by the constraint +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.MemberSources + + +

+ +
+
+ Full Usage: + this.MemberSources +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the types that may be used to satisfy the constraint +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html b/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html new file mode 100644 index 0000000000..f4f30f3d2f --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpimplementationfilecontents.html @@ -0,0 +1,837 @@ + + + + + + + + + + + + + + + + + + FSharpImplementationFileContents (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpImplementationFileContents Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the definitional contents of a single file or fragment in an assembly, as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Declarations + + +

+ +
+
+ Full Usage: + this.Declarations +
+
+ + Returns: + FSharpImplementationFileDeclaration list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declarations that make up this implementation file +

+
+ +
+
+ + Returns: + + FSharpImplementationFileDeclaration list +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the system path of the implementation file +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.HasExplicitEntryPoint + + +

+ +
+
+ Full Usage: + this.HasExplicitEntryPoint +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the implementation file has an explicit entry point +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsScript + + +

+ +
+
+ Full Usage: + this.IsScript +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the implementation file is a script +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The qualified name acts to fully-qualify module specifications and implementations +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html b/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html new file mode 100644 index 0000000000..e691619f25 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpimplementationfiledeclaration.html @@ -0,0 +1,781 @@ + + + + + + + + + + + + + + + + + + FSharpImplementationFileDeclaration (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpImplementationFileDeclaration Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents a declaration in an implementation file, as seen by the F# language +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Entity(entity, declarations) + + +

+ +
+
+ Full Usage: + Entity(entity, declarations) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Represents the declaration of a type +

+
+ +
+
+ + entity + + : + FSharpEntity +
+
+
+ + declarations + + : + FSharpImplementationFileDeclaration list +
+
+
+
+
+
+ +

+ + + InitAction action + + +

+ +
+
+ Full Usage: + InitAction action +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Represents the declaration of a static initialization action +

+
+ +
+
+ + action + + : + FSharpExpr +
+
+
+
+
+
+ +

+ + + MemberOrFunctionOrValue(value, curriedArgs, body) + + +

+ +
+
+ Full Usage: + MemberOrFunctionOrValue(value, curriedArgs, body) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Represents the declaration of a member, function or value, including the parameters and body of the member +

+
+ +
+
+ + value + + : + FSharpMemberOrFunctionOrValue +
+
+
+ + curriedArgs + + : + FSharpMemberOrFunctionOrValue list list +
+
+
+ + body + + : + FSharpExpr +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpinlineannotation.html b/reference/fsharp-compiler-symbols-fsharpinlineannotation.html new file mode 100644 index 0000000000..c9e0d4c2ab --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpinlineannotation.html @@ -0,0 +1,694 @@ + + + + + + + + + + + + + + + + + + FSharpInlineAnnotation (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpInlineAnnotation Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpInlineAnnotation> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AggressiveInline + + +

+ +
+
+ Full Usage: + AggressiveInline +
+
+
+
+
+ 		+
+ + + +

+ Indicates the value is aggressively inlined by the .NET runtime +

+
+
+
+ +

+ + + AlwaysInline + + +

+ +
+
+ Full Usage: + AlwaysInline +
+
+
+
+
+ 		+
+ + + +

+ Indicates the value is always inlined in statically compiled code +

+
+
+
+ +

+ + + NeverInline + + +

+ +
+
+ Full Usage: + NeverInline +
+
+
+
+
+ 		+
+ + + +

+ Indicates the value is never inlined +

+
+
+
+ +

+ + + OptionalInline + + +

+ +
+
+ Full Usage: + OptionalInline +
+
+
+
+
+ 		+
+ + + +

+ Indicates the value is optionally inlined +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html b/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html new file mode 100644 index 0000000000..5020d6c846 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpmemberorfunctionorvalue.html @@ -0,0 +1,4303 @@ + + + + + + + + + + + + + + + + + + FSharpMemberOrFunctionOrValue (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpMemberOrFunctionOrValue Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of F# symbol that represents an F# method, property, event, function or value, including extension members. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ApparentEnclosingEntity + + +

+ +
+
+ Full Usage: + this.ApparentEnclosingEntity +
+
+ + Returns: + FSharpEntity + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the logical enclosing entity, which for an extension member is type being extended +

+
+ +
+
+ + Returns: + + FSharpEntity +
+
+
+
+
+
+ +

+ + + this.CompiledName + + +

+ +
+
+ Full Usage: + this.CompiledName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the member name in compiled code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.CurriedParameterGroups + + +

+ +
+
+ Full Usage: + this.CurriedParameterGroups +
+
+ + Returns: + IList<IList<FSharpParameter>> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ List of list of parameters, where each nested item represents a defined parameter +

+
+ +

+ + Typically, there is only one nested list. + However, code such as 'f (a, b) (c, d)' contains two groups, each with two parameters. + In that example, there is a list made up of two lists, each with a parameter. + +

+
+
+ + Returns: + + IList<IList<FSharpParameter>> +
+
+
+
+
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaration location of the member, function or value +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.DeclaringEntity + + +

+ +
+
+ Full Usage: + this.DeclaringEntity +
+
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the enclosing entity for the definition +

+
+ +
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+
+ +

+ + + this.DisplayName + + +

+ +
+
+ Full Usage: + this.DisplayName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name as presented in F# error messages and documentation +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.EventAddMethod + + +

+ +
+
+ Full Usage: + this.EventAddMethod +
+
+ + Returns: + FSharpMemberOrFunctionOrValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get an associated add method of an event +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue +
+
+
+
+
+
+ +

+ + + this.EventDelegateType + + +

+ +
+
+ Full Usage: + this.EventDelegateType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get an associated delegate type of an event +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.EventForFSharpProperty + + +

+ +
+
+ Full Usage: + this.EventForFSharpProperty +
+
+ + Returns: + FSharpMemberOrFunctionOrValue option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the event symbol implied by the use of a property, + for the case where the property is actually an F#-declared CLIEvent. + + Uses of F#-declared events are considered to be properties as far as the language specification + and this API are concerned. +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue option +
+
+
+
+
+
+ +

+ + + this.EventIsStandard + + +

+ +
+
+ Full Usage: + this.EventIsStandard +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate if an event can be considered to be a property for the F# type system of type IEvent or IDelegateEvent. + In this case ReturnParameter will have a type corresponding to the property type. For + non-standard events, ReturnParameter will have a type corresponding to the delegate type. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.EventRemoveMethod + + +

+ +
+
+ Full Usage: + this.EventRemoveMethod +
+
+ + Returns: + FSharpMemberOrFunctionOrValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get an associated remove method of an event +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue +
+
+
+
+
+
+ +

+ + + this.FormatLayout + + +

+ +
+
+ Full Usage: + this.FormatLayout +
+
+ Parameters: + +
+ + Returns: + TaggedText[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the type using the rules of the given display context +

+
+ +
+
+ + displayContext + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + TaggedText[] +
+
+
+
+
+
+ +

+ + + this.FullType + + +

+ +
+
+ Full Usage: + this.FullType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the full type of the member, function or value when used as a first class value +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.FullTypeSafe + + +

+ +
+
+ Full Usage: + this.FullTypeSafe +
+
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Safe version of `FullType`. +

+
+ +
+
+ + Returns: + + FSharpType option +
+
+
+
+
+
+ +

+ + + this.GenericParameters + + +

+ +
+
+ Full Usage: + this.GenericParameters +
+
+ + Returns: + IList<FSharpGenericParameter> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the typars of the member, function or value +

+
+ +
+
+ + Returns: + + IList<FSharpGenericParameter> +
+
+
+
+
+
+ +

+ + + this.GetOverloads + + +

+ +
+
+ Full Usage: + this.GetOverloads +
+
+ Parameters: +
    + + + matchParameterNumber + + : + bool + +
    +
+
+ + Returns: + IList<FSharpMemberOrFunctionOrValue> option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the overloads for the current method. +

+
+ +
+
+ + matchParameterNumber + + : + bool +
+
+
+
+
+ + Returns: + + IList<FSharpMemberOrFunctionOrValue> option +
+
+
+
+
+
+ +

+ + + this.GetReturnTypeLayout + + +

+ +
+
+ Full Usage: + this.GetReturnTypeLayout +
+
+ Parameters: + +
+ + Returns: + TaggedText[] option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the type using the rules of the given display context +

+
+ +
+
+ + displayContext + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + TaggedText[] option +
+
+
+
+
+
+ +

+ + + this.GetValSignatureText + + +

+ +
+
+ Full Usage: + this.GetValSignatureText +
+
+ Parameters: + +
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the signature text to include this Symbol into an existing signature file. +

+
+ +
+
+ + displayContext + + : + FSharpDisplayContext +
+
+
+ + m + + : + range +
+
+
+
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.GetWitnessPassingInfo + + +

+ +
+
+ Full Usage: + this.GetWitnessPassingInfo +
+
+ + Returns: + (string * IList<FSharpParameter>) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Check if this method has an entrpoint that accepts witness arguments and if so return + the name of that entrypoint and information about the additional witness arguments +

+
+ +
+
+ + Returns: + + (string * IList<FSharpParameter>) option +
+
+
+
+
+
+ +

+ + + this.GetterMethod + + +

+ +
+
+ Full Usage: + this.GetterMethod +
+
+ + Returns: + FSharpMemberOrFunctionOrValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get an associated getter method of the property +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue +
+
+
+
+
+
+ +

+ + + this.HasGetterMethod + + +

+ +
+
+ Full Usage: + this.HasGetterMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a property and there exists an associated getter method +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.HasSetterMethod + + +

+ +
+
+ Full Usage: + this.HasSetterMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a property and there exists an associated setter method +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.HasSignatureFile + + +

+ +
+
+ Full Usage: + this.HasSignatureFile +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the value has a signature file counterpart +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ImplementedAbstractSignatures + + +

+ +
+
+ Full Usage: + this.ImplementedAbstractSignatures +
+
+ + Returns: + IList<FSharpAbstractSignature> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the list of the abstract slot signatures implemented by the member +

+
+ +
+
+ + Returns: + + IList<FSharpAbstractSignature> +
+
+
+
+
+
+ +

+ + + this.InlineAnnotation + + +

+ +
+
+ Full Usage: + this.InlineAnnotation +
+
+ + Returns: + FSharpInlineAnnotation + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a result indicating if this is a must-inline value +

+
+ +
+
+ + Returns: + + FSharpInlineAnnotation +
+
+
+
+
+
+ +

+ + + this.IsActivePattern + + +

+ +
+
+ Full Usage: + this.IsActivePattern +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this value or member is an F# active pattern +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsBaseValue + + +

+ +
+
+ Full Usage: + this.IsBaseValue +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is "base" in "base.M(...)" +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsCompilerGenerated + + +

+ +
+
+ Full Usage: + this.IsCompilerGenerated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a compiler generated value +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsConstructor + + +

+ +
+
+ Full Usage: + this.IsConstructor +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a constructor. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsConstructorThisValue + + +

+ +
+
+ Full Usage: + this.IsConstructorThisValue +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is the "x" in "type C() as x = ..." +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsDispatchSlot + + +

+ +
+
+ Full Usage: + this.IsDispatchSlot +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an abstract member? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEvent + + +

+ +
+
+ Full Usage: + this.IsEvent +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an event member +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEventAddMethod + + +

+ +
+
+ Full Usage: + this.IsEventAddMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an add method for an event +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEventRemoveMethod + + +

+ +
+
+ Full Usage: + this.IsEventRemoveMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a remove method for an event +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsExplicitInterfaceImplementation + + +

+ +
+
+ Full Usage: + this.IsExplicitInterfaceImplementation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an explicit implementation of an interface member +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsExtensionMember + + +

+ +
+
+ Full Usage: + this.IsExtensionMember +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an extension member? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFunction + + +

+ +
+
+ Full Usage: + this.IsFunction +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicated if this is a function +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsImplicitConstructor + + +

+ +
+
+ Full Usage: + this.IsImplicitConstructor +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an implicit constructor? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsInstanceMember + + +

+ +
+
+ Full Usage: + this.IsInstanceMember +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an instance member, when seen from F#? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsInstanceMemberInCompiledCode + + +

+ +
+
+ Full Usage: + this.IsInstanceMemberInCompiledCode +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an instance member in compiled code. + + Explanatory note: some members such as IsNone and IsSome on types with UseNullAsTrueValue appear + as instance members in F# code but are compiled as static members. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMember + + +

+ +
+
+ Full Usage: + this.IsMember +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a member, including extension members? +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMemberThisValue + + +

+ +
+
+ Full Usage: + this.IsMemberThisValue +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is the "x" in "member x.M = ..." +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMethod + + +

+ +
+
+ Full Usage: + this.IsMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a method member +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsModuleValueOrMember + + +

+ +
+
+ Full Usage: + this.IsModuleValueOrMember +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a module or member value +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMutable + + +

+ +
+
+ Full Usage: + this.IsMutable +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a mutable value +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsOverrideOrExplicitInterfaceImplementation + + +

+ +
+
+ Full Usage: + this.IsOverrideOrExplicitInterfaceImplementation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an 'override', 'default' or an explicit implementation of an interface member +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsProperty + + +

+ +
+
+ Full Usage: + this.IsProperty +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a property member +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPropertyGetterMethod + + +

+ +
+
+ Full Usage: + this.IsPropertyGetterMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a getter method for a property, or a use of a property in getter mode +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsPropertySetterMethod + + +

+ +
+
+ Full Usage: + this.IsPropertySetterMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a setter method for a property, or a use of a property in setter mode +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsRefCell + + +

+ +
+
+ Full Usage: + this.IsRefCell +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a ref cell +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsReferencedValue + + +

+ +
+
+ Full Usage: + this.IsReferencedValue +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a value that has been referenced +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsTypeFunction + + +

+ +
+
+ Full Usage: + this.IsTypeFunction +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is an F# type function +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnionCaseTester + + +

+ +
+
+ Full Usage: + this.IsUnionCaseTester +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the property or getter method is part of a IsABC union case tester implied by a union case definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnresolved + + +

+ +
+
+ Full Usage: + this.IsUnresolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the member, function or value is in an unresolved assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsValCompiledAsMethod + + +

+ +
+
+ Full Usage: + this.IsValCompiledAsMethod +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicated if this is a value compiled to a method +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsValue + + +

+ +
+
+ Full Usage: + this.IsValue +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicated if this is a value +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.LiteralValue + + +

+ +
+
+ Full Usage: + this.LiteralValue +
+
+ + Returns: + obj option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a [] value, and if so what value? (may be null) +

+
+ +
+
+ + Returns: + + obj option +
+
+
+
+
+
+ +

+ + + this.LogicalName + + +

+ +
+
+ Full Usage: + this.LogicalName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the logical name of the member +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ReturnParameter + + +

+ +
+
+ Full Usage: + this.ReturnParameter +
+
+ + Returns: + FSharpParameter + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpParameter +
+
+
+
+
+ +

+ + + this.SetterMethod + + +

+ +
+
+ Full Usage: + this.SetterMethod +
+
+ + Returns: + FSharpMemberOrFunctionOrValue + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get an associated setter method of the property +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue +
+
+
+
+
+
+ +

+ + + this.TryGetFullCompiledOperatorNameIdents + + +

+ +
+
+ Full Usage: + this.TryGetFullCompiledOperatorNameIdents +
+
+ + Returns: + string[] option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Full operator compiled name. +

+
+ +
+
+ + Returns: + + string[] option +
+
+
+
+
+
+ +

+ + + this.TryGetFullDisplayName + + +

+ +
+
+ Full Usage: + this.TryGetFullDisplayName +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Full name with last part replaced with display name. +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation for the entity +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+ +

+ + + this.XmlDocSig + + +

+ +
+
+ Full Usage: + this.XmlDocSig +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ XML documentation signature for the value, used for .xml file lookup for compiled code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html b/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html new file mode 100644 index 0000000000..05889c7d3a --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpobjectexproverride.html @@ -0,0 +1,780 @@ + + + + + + + + + + + + + + + + + + FSharpObjectExprOverride (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpObjectExprOverride Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a checked method in an object expression, as seen by the F# language. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Body + + +

+ +
+
+ Full Usage: + this.Body +
+
+ + Returns: + FSharpExpr + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The expression that forms the body of the method +

+
+ +
+
+ + Returns: + + FSharpExpr +
+
+
+
+
+
+ +

+ + + this.CurriedParameterGroups + + +

+ +
+
+ Full Usage: + this.CurriedParameterGroups +
+
+ + Returns: + FSharpMemberOrFunctionOrValue list list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The parameters of the method +

+
+ +
+
+ + Returns: + + FSharpMemberOrFunctionOrValue list list +
+
+
+
+
+
+ +

+ + + this.GenericParameters + + +

+ +
+
+ Full Usage: + this.GenericParameters +
+
+ + Returns: + FSharpGenericParameter list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The generic parameters of the method +

+
+ +
+
+ + Returns: + + FSharpGenericParameter list +
+
+
+
+
+
+ +

+ + + this.Signature + + +

+ +
+
+ Full Usage: + this.Signature +
+
+ + Returns: + FSharpAbstractSignature + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The signature of the implemented abstract slot +

+
+ +
+
+ + Returns: + + FSharpAbstractSignature +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpopendeclaration.html b/reference/fsharp-compiler-symbols-fsharpopendeclaration.html new file mode 100644 index 0000000000..f2535d2cdb --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpopendeclaration.html @@ -0,0 +1,951 @@ + + + + + + + + + + + + + + + + + + FSharpOpenDeclaration (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpOpenDeclaration Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents open declaration in F# code. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AppliedScope + + +

+ +
+
+ Full Usage: + this.AppliedScope +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Scope in which open declaration is visible. +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.IsOwnNamespace + + +

+ +
+
+ Full Usage: + this.IsOwnNamespace +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ If it's `namespace Xxx.Yyy` declaration. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.LongId + + +

+ +
+
+ Full Usage: + this.LongId +
+
+ + Returns: + Ident list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The syntactic target of the declaration +

+
+ +
+
+ + Returns: + + Ident list +
+
+
+
+
+
+ +

+ + + this.Modules + + +

+ +
+
+ Full Usage: + this.Modules +
+
+ + Returns: + FSharpEntity list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Modules or namespaces which is opened with this declaration. +

+
+ +
+
+ + Returns: + + FSharpEntity list +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Range of the open declaration. +

+
+ +
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.Target + + +

+ +
+
+ Full Usage: + this.Target +
+
+ + Returns: + SynOpenDeclTarget + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The syntactic target of the declaration +

+
+ +
+
+ + Returns: + + SynOpenDeclTarget +
+
+
+
+
+
+ +

+ + + this.Types + + +

+ +
+
+ Full Usage: + this.Types +
+
+ + Returns: + FSharpType list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Types whose static members and nested types is opened with this declaration. +

+
+ +
+
+ + Returns: + + FSharpType list +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpparameter.html b/reference/fsharp-compiler-symbols-fsharpparameter.html new file mode 100644 index 0000000000..3a8e979d66 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpparameter.html @@ -0,0 +1,951 @@ + + + + + + + + + + + + + + + + + + FSharpParameter (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpParameter Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a parameter +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The declaration location of the parameter +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.IsInArg + + +

+ +
+
+ Full Usage: + this.IsInArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is an in argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsOptionalArg + + +

+ +
+
+ Full Usage: + this.IsOptionalArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is an optional argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsOutArg + + +

+ +
+
+ Full Usage: + this.IsOutArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is an out argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsParamArrayArg + + +

+ +
+
+ Full Usage: + this.IsParamArrayArg +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicate this is a param array argument +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The optional name of the parameter +

+
+ +
+
+ + Returns: + + string option +
+
+
+
+
+
+ +

+ + + this.Type + + +

+ +
+
+ Full Usage: + this.Type +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The declared or inferred type of the parameter +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpstaticparameter.html b/reference/fsharp-compiler-symbols-fsharpstaticparameter.html new file mode 100644 index 0000000000..fa1b498bd2 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpstaticparameter.html @@ -0,0 +1,894 @@ + + + + + + + + + + + + + + + + + + FSharpStaticParameter (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpStaticParameter Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a static parameter to an F# type provider +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaration location of the static parameter +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.DefaultValue + + +

+ +
+
+ Full Usage: + this.DefaultValue +
+
+ + Returns: + obj + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the default value for the static parameter +

+
+ +
+
+ + Returns: + + obj +
+
+
+
+
+
+ +

+ + + this.IsOptional + + +

+ +
+
+ Full Usage: + this.IsOptional +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the static parameter is optional +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Kind + + +

+ +
+
+ Full Usage: + this.Kind +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the kind of the static parameter +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the static parameter +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the range of the construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpsymbol.html b/reference/fsharp-compiler-symbols-fsharpsymbol.html new file mode 100644 index 0000000000..47fc97ebe5 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpsymbol.html @@ -0,0 +1,1452 @@ + + + + + + + + + + + + + + + + + + FSharpSymbol (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpSymbol Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a symbol in checked F# source code or a compiled .NET component. + + The subtype of the symbol may reveal further information and can be one of FSharpEntity, FSharpUnionCase + FSharpField, FSharpGenericParameter, FSharpStaticParameter, FSharpMemberOrFunctionOrValue, FSharpParameter, + or FSharpActivePatternCase. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Accessibility + + +

+ +
+
+ Full Usage: + this.Accessibility +
+
+ + Returns: + FSharpAccessibility + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declared accessibility of the symbol, if any +

+
+ +
+
+ + Returns: + + FSharpAccessibility +
+
+
+
+
+
+ +

+ + + this.Assembly + + +

+ +
+
+ Full Usage: + this.Assembly +
+
+ + Returns: + FSharpAssembly + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the assembly declaring this symbol +

+
+ +
+
+ + Returns: + + FSharpAssembly +
+
+
+
+
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + IList<FSharpAttribute> + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the attributes for the symbol, if any +

+
+ +
+
+ + Returns: + + IList<FSharpAttribute> +
+
+
+
+
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaration location for the symbol +

+
+ +
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.DisplayName + + +

+ +
+
+ Full Usage: + this.DisplayName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the display name for the symbol. Double backticks are added if the name is not a valid identifier. + + For FSharpParameter symbols without a name for the paramater, this returns "````" +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.DisplayNameCore + + +

+ +
+
+ Full Usage: + this.DisplayNameCore +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the display name for the symbol where double backticks are not added for non-identifiers +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.FullName + + +

+ +
+
+ Full Usage: + this.FullName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a textual representation of the full name of the symbol. The text returned for some symbols + may not be a valid identifier path in F# code, but rather a human-readable representation of the symbol. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetEffectivelySameAsHash + + +

+ +
+
+ Full Usage: + this.GetEffectivelySameAsHash +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A hash compatible with the IsEffectivelySameAs relation +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.HasAttribute + + +

+ +
+
+ Full Usage: + this.HasAttribute +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this symbol has an attribute matching the full name of the given type parameter +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.ImplementationLocation + + +

+ +
+
+ Full Usage: + this.ImplementationLocation +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the implementation location for the symbol if it was declared in a signature that has an implementation +

+
+ +
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.IsAccessible + + +

+ +
+
+ Full Usage: + this.IsAccessible +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Computes if the symbol is accessible for the given accessibility rights +

+
+ +
+
+ + arg0 + + : + FSharpAccessibilityRights +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsEffectivelySameAs + + +

+ +
+
+ Full Usage: + this.IsEffectivelySameAs +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Return true if two symbols are effectively the same when referred to in F# source code text. + This sees through signatures (a symbol in a signature will be considered effectively the same as + the matching symbol in an implementation). In addition, other equivalences are applied + when the same F# source text implies the same declaration name - for example, constructors + are considered to be effectively the same symbol as the corresponding type definition. + + This is the relation used by GetUsesOfSymbol and GetUsesOfSymbolInFile. +

+
+ +
+
+ + other + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsExplicitlySuppressed + + +

+ +
+
+ Full Usage: + this.IsExplicitlySuppressed +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.SignatureLocation + + +

+ +
+
+ Full Usage: + this.SignatureLocation +
+
+ + Returns: + range option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the signature location for the symbol if it was declared in an implementation +

+
+ +
+
+ + Returns: + + range option +
+
+
+
+
+
+ +

+ + + this.TryGetAttribute + + +

+ +
+
+ Full Usage: + this.TryGetAttribute +
+
+ + Returns: + FSharpAttribute option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Try to get an attribute matching the full name of the given type parameter +

+
+ +
+
+ + Returns: + + FSharpAttribute option +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html b/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html new file mode 100644 index 0000000000..f970657432 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpsymbolpatterns.html @@ -0,0 +1,2749 @@ + + + + + + + + + + + + + + + + + + FSharpSymbolPatterns (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpSymbolPatterns Module +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Patterns over FSharpSymbol and derivatives. +

+
+
+
+
+
+

+ Active patterns +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Active pattern + + Description +
+
+ +

+ + + (|AbbreviatedType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|AbbreviatedType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + FSharpType option +
+
+
+
+
+ +

+ + + (|AbstractClass|_|) arg1 + + +

+ +
+
+ Full Usage: + (|AbstractClass|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|ActivePatternCase|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ActivePatternCase|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpActivePatternCase option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + FSharpActivePatternCase option +
+
+
+
+
+ +

+ + + (|Array|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Array|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Attribute|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Attribute|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|ByRef|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ByRef|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Class|_|) (original, abbreviated, arg3) + + +

+ +
+
+ Full Usage: + (|Class|_|) (original, abbreviated, arg3) +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + original + + : + FSharpEntity +
+
+
+ + abbreviated + + : + FSharpEntity +
+
+
+ + arg2 + + : + 'a +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Constructor|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Constructor|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpMemberOrFunctionOrValue +
+
+
+
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+ +

+ + + (|Delegate|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Delegate|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Enum|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Enum|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Event|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Event|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpMemberOrFunctionOrValue +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|ExtensionMember|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ExtensionMember|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpMemberOrFunctionOrValue +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|FSharpEntity|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FSharpEntity|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpEntity * FSharpEntity * FSharpType option) option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Returns (originalEntity, abbreviatedEntity, abbreviatedType) +

+
+ +
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + (FSharpEntity * FSharpEntity * FSharpType option) option +
+
+
+
+
+
+ +

+ + + (|FSharpException|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FSharpException|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|FSharpModule|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FSharpModule|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|FSharpType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FSharpType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Field|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Field|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + (FSharpField * FSharpType) option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + (FSharpField * FSharpType) option +
+
+
+
+
+ +

+ + + (|FunctionType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|FunctionType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpType +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Function|_|) excluded arg2 + + +

+ +
+
+ Full Usage: + (|Function|_|) excluded arg2 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + excluded + + : + bool +
+
+
+ + arg1 + + : + FSharpMemberOrFunctionOrValue +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Interface|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Interface|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|MemberFunctionOrValue|_|) arg1 + + +

+ +
+
+ Full Usage: + (|MemberFunctionOrValue|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpMemberOrFunctionOrValue option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + FSharpMemberOrFunctionOrValue option +
+
+
+
+
+ +

+ + + (|MutableVar|_|) arg1 + + +

+ +
+
+ Full Usage: + (|MutableVar|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Namespace|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Namespace|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Parameter|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Parameter|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Pattern|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Pattern|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|ProvidedAndErasedType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ProvidedAndErasedType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|ProvidedType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ProvidedType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|RecordField|_|) arg1 + + +

+ +
+
+ Full Usage: + (|RecordField|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpField option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + FSharpField option +
+
+
+
+
+ +

+ + + (|Record|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Record|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|RefCell|_|) arg1 + + +

+ +
+
+ Full Usage: + (|RefCell|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpType +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|Tuple|_|) arg1 + + +

+ +
+
+ Full Usage: + (|Tuple|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpType +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|TypeWithDefinition|_|) arg1 + + +

+ +
+
+ Full Usage: + (|TypeWithDefinition|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpEntity option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpType +
+
+
+
+
+ + Returns: + + FSharpEntity option +
+
+
+
+
+ +

+ + + (|UnionCase|_|) arg1 + + +

+ +
+
+ Full Usage: + (|UnionCase|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + FSharpUnionCase option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpSymbol +
+
+
+
+
+ + Returns: + + FSharpUnionCase option +
+
+
+
+
+ +

+ + + (|UnionType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|UnionType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+ +

+ + + (|ValueType|_|) arg1 + + +

+ +
+
+ Full Usage: + (|ValueType|_|) arg1 +
+
+ Parameters: + +
+ + Returns: + unit option + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpEntity +
+
+
+
+
+ + Returns: + + unit option +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharptype.html b/reference/fsharp-compiler-symbols-fsharptype.html new file mode 100644 index 0000000000..5e716fc56f --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharptype.html @@ -0,0 +1,2546 @@ + + + + + + + + + + + + + + + + + + FSharpType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpType Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.AbbreviatedType + + +

+ +
+
+ Full Usage: + this.AbbreviatedType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the type for which this is an abbreviation +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.AllInterfaces + + +

+ +
+
+ Full Usage: + this.AllInterfaces +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get all the interface implementations, by walking the type hierarchy, taking into account the instantiation of this type + if it is an instantiation of a generic type. +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+ +

+ + + this.AnonRecordTypeDetails + + +

+ +
+
+ Full Usage: + this.AnonRecordTypeDetails +
+
+ + Returns: + FSharpAnonRecordTypeDetails + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the details of the anonymous record type. +

+
+ +
+
+ + Returns: + + FSharpAnonRecordTypeDetails +
+
+
+
+
+
+ +

+ + + this.BaseType + + +

+ +
+
+ Full Usage: + this.BaseType +
+
+ + Returns: + FSharpType option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the base type, if any, taking into account the instantiation of this type + if it is an instantiation of a generic type. +

+
+ +
+
+ + Returns: + + FSharpType option +
+
+
+
+
+
+ +

+ + + this.BasicQualifiedName + + +

+ +
+
+ Full Usage: + this.BasicQualifiedName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The fully qualified name of the type or module without strong assembly name. +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ErasedType + + +

+ +
+
+ Full Usage: + this.ErasedType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Canonical form of the type with abbreviations, measures, and F# tuples and functions erased. +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.Format + + +

+ +
+
+ Full Usage: + this.Format +
+
+ Parameters: + +
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the type using the rules of the given display context, skipping type constraints +

+
+ +
+
+ + context + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.FormatLayout + + +

+ +
+
+ Full Usage: + this.FormatLayout +
+
+ Parameters: + +
+ + Returns: + TaggedText[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the type using the rules of the given display context +

+
+ +
+
+ + context + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + TaggedText[] +
+
+
+
+
+
+ +

+ + + this.FormatLayoutWithConstraints + + +

+ +
+
+ Full Usage: + this.FormatLayoutWithConstraints +
+
+ Parameters: + +
+ + Returns: + TaggedText[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the type - with constraints - using the rules of the given display context +

+
+ +
+
+ + context + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + TaggedText[] +
+
+
+
+
+
+ +

+ + + this.FormatWithConstraints + + +

+ +
+
+ Full Usage: + this.FormatWithConstraints +
+
+ Parameters: + +
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Format the type using the rules of the given display context +

+
+ +
+
+ + context + + : + FSharpDisplayContext +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GenericArguments + + +

+ +
+
+ Full Usage: + this.GenericArguments +
+
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the generic arguments for a tuple type, a function type or a type constructed using a named entity +

+
+ +
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+ +

+ + + this.GenericParameter + + +

+ +
+
+ Full Usage: + this.GenericParameter +
+
+ + Returns: + FSharpGenericParameter + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the generic parameter data for a generic parameter type +

+
+ +
+
+ + Returns: + + FSharpGenericParameter +
+
+
+
+
+
+ +

+ + + this.HasTypeDefinition + + +

+ +
+
+ Full Usage: + this.HasTypeDefinition +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is constructed using a named entity, including array and byref types +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Instantiate + + +

+ +
+
+ Full Usage: + this.Instantiate +
+
+ Parameters: + +
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Instantiate generic type parameters in a type +

+
+ +
+
+ + arg0 + + : + (FSharpGenericParameter * FSharpType) list +
+
+
+
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.IsAbbreviation + + +

+ +
+
+ Full Usage: + this.IsAbbreviation +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates this is an abbreviation for another type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsAnonRecordType + + +

+ +
+
+ Full Usage: + this.IsAnonRecordType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is an anonymous record type. The GenericArguments property returns the type instantiation of the anonymous record type +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsFunctionType + + +

+ +
+
+ Full Usage: + this.IsFunctionType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is a function type. The GenericArguments property returns the domain and range of the function type. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsGenericParameter + + +

+ +
+
+ Full Usage: + this.IsGenericParameter +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is a variable type, whether declared, generalized or an inference type parameter +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsMeasureType + + +

+ +
+
+ Full Usage: + this.IsMeasureType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is a measure type. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsStructTupleType + + +

+ +
+
+ Full Usage: + this.IsStructTupleType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is a struct tuple type. The GenericArguments property returns the elements of the tuple type. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsTupleType + + +

+ +
+
+ Full Usage: + this.IsTupleType +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the type is a tuple type (reference or struct). The GenericArguments property returns the elements of the tuple type. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnresolved + + +

+ +
+
+ Full Usage: + this.IsUnresolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates this is a named type in an unresolved assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.StripAbbreviations + + +

+ +
+
+ Full Usage: + this.StripAbbreviations +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Strip any outer abbreviations from the type +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.TypeDefinition + + +

+ +
+
+ Full Usage: + this.TypeDefinition +
+
+ + Returns: + FSharpEntity + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the type definition for a type +

+
+ +
+
+ + Returns: + + FSharpEntity +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpType.Prettify(parameters, returnParameter) + + +

+ +
+
+ Full Usage: + FSharpType.Prettify(parameters, returnParameter) +
+
+ Parameters: + +
+ + Returns: + IList<IList<FSharpParameter>> * FSharpParameter + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Adjust the types in a group of curried parameters and return type by removing any occurrences of type inference variables, replacing them + systematically with lower-case type inference variables such as 'a. +

+
+ +
+
+ + parameters + + : + IList<IList<FSharpParameter>> +
+
+
+ + returnParameter + + : + FSharpParameter +
+
+
+
+
+ + Returns: + + IList<IList<FSharpParameter>> * FSharpParameter +
+
+
+
+
+
+ +

+ + + FSharpType.Prettify(parameters) + + +

+ +
+
+ Full Usage: + FSharpType.Prettify(parameters) +
+
+ Parameters: + +
+ + Returns: + IList<IList<FSharpParameter>> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Adjust the types in a group of curried parameters by removing any occurrences of type inference variables, replacing them + systematically with lower-case type inference variables such as 'a. +

+
+ +
+
+ + parameters + + : + IList<IList<FSharpParameter>> +
+
+
+
+
+ + Returns: + + IList<IList<FSharpParameter>> +
+
+
+
+
+
+ +

+ + + FSharpType.Prettify(parameters) + + +

+ +
+
+ Full Usage: + FSharpType.Prettify(parameters) +
+
+ Parameters: + +
+ + Returns: + IList<FSharpParameter> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Adjust the types in a group of parameters by removing any occurrences of type inference variables, replacing them + systematically with lower-case type inference variables such as 'a. +

+
+ +
+
+ + parameters + + : + IList<FSharpParameter> +
+
+
+
+
+ + Returns: + + IList<FSharpParameter> +
+
+
+
+
+
+ +

+ + + FSharpType.Prettify(parameter) + + +

+ +
+
+ Full Usage: + FSharpType.Prettify(parameter) +
+
+ Parameters: + +
+ + Returns: + FSharpParameter + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Adjust the type in a single parameter by removing any occurrences of type inference variables, replacing them + systematically with lower-case type inference variables such as 'a. +

+
+ +
+
+ + parameter + + : + FSharpParameter +
+
+
+
+
+ + Returns: + + FSharpParameter +
+
+
+
+
+
+ +

+ + + FSharpType.Prettify(types) + + +

+ +
+
+ Full Usage: + FSharpType.Prettify(types) +
+
+ Parameters: + +
+ + Returns: + IList<FSharpType> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Adjust a group of types by removing any occurrences of type inference variables, replacing them + systematically with lower-case type inference variables such as 'a. +

+
+ +
+
+ + types + + : + IList<FSharpType> +
+
+
+
+
+ + Returns: + + IList<FSharpType> +
+
+
+
+
+
+ +

+ + + FSharpType.Prettify(ty) + + +

+ +
+
+ Full Usage: + FSharpType.Prettify(ty) +
+
+ Parameters: + +
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Adjust the type by removing any occurrences of type inference variables, replacing them + systematically with lower-case type inference variables such as 'a. +

+
+ +
+
+ + ty + + : + FSharpType +
+
+
+
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpunioncase.html b/reference/fsharp-compiler-symbols-fsharpunioncase.html new file mode 100644 index 0000000000..6e9d9c47a4 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpunioncase.html @@ -0,0 +1,1122 @@ + + + + + + + + + + + + + + + + + + FSharpUnionCase (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpUnionCase Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + FSharpSymbol +
+
+
+
+

+ A subtype of FSharpSymbol that represents a union case as seen by the F# language +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CompiledName + + +

+ +
+
+ Full Usage: + this.CompiledName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the case in generated IL code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.DeclarationLocation + + +

+ +
+
+ Full Usage: + this.DeclarationLocation +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the range of the name of the case +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.DeclaringEntity + + +

+ +
+
+ Full Usage: + this.DeclaringEntity +
+
+ + Returns: + FSharpEntity + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the declaring entity of the case +

+
+ +
+
+ + Returns: + + FSharpEntity +
+
+
+
+
+
+ +

+ + + this.Fields + + +

+ +
+
+ Full Usage: + this.Fields +
+
+ + Returns: + IList<FSharpField> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the data carried by the case. +

+
+ +
+
+ + Returns: + + IList<FSharpField> +
+
+
+
+
+
+ +

+ + + this.HasFields + + +

+ +
+
+ Full Usage: + this.HasFields +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the union case has field definitions +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.IsUnresolved + + +

+ +
+
+ Full Usage: + this.IsUnresolved +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the union case is for a type in an unresolved assembly +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Name + + +

+ +
+
+ Full Usage: + this.Name +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the name of the union case +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.ReturnType + + +

+ +
+
+ Full Usage: + this.ReturnType +
+
+ + Returns: + FSharpType + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it +

+
+ +
+
+ + Returns: + + FSharpType +
+
+
+
+
+
+ +

+ + + this.XmlDoc + + +

+ +
+
+ Full Usage: + this.XmlDoc +
+
+ + Returns: + FSharpXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation for the entity +

+
+ +
+
+ + Returns: + + FSharpXmlDoc +
+
+
+
+
+
+ +

+ + + this.XmlDocSig + + +

+ +
+
+ Full Usage: + this.XmlDocSig +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the XML documentation signature for .xml file lookup for the union case, used for .xml file lookup for compiled code +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols-fsharpxmldoc.html b/reference/fsharp-compiler-symbols-fsharpxmldoc.html new file mode 100644 index 0000000000..87d08a7890 --- /dev/null +++ b/reference/fsharp-compiler-symbols-fsharpxmldoc.html @@ -0,0 +1,723 @@ + + + + + + + + + + + + + + + + + + FSharpXmlDoc (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpXmlDoc Type +

+
+
+ Namespace: + + FSharp.Compiler.Symbols + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Describe a comment as either a block of text or a file+signature reference into an intellidoc file. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + FromXmlFile(dllName, xmlSig) + + +

+ +
+
+ Full Usage: + FromXmlFile(dllName, xmlSig) +
+
+ Parameters: +
    + + + dllName + + : + string + +
    + + + xmlSig + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Indicates that the XML for the documentation can be found in a .xml documentation file for the given DLL, using the given signature key +

+
+ +
+
+ + dllName + + : + string +
+
+
+ + xmlSig + + : + string +
+
+
+
+
+
+ +

+ + + FromXmlText XmlDoc + + +

+ +
+
+ Full Usage: + FromXmlText XmlDoc +
+
+ Parameters: +
    + + + Item + + : + XmlDoc + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ The text for documentation for in-memory references. +

+
+ +
+
+ + Item + + : + XmlDoc +
+
+
+
+
+
+ +

+ + + None + + +

+ +
+
+ Full Usage: + None +
+
+
+
+
+ 		+
+ + + +

+ No documentation is available +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-symbols.html b/reference/fsharp-compiler-symbols.html new file mode 100644 index 0000000000..830115ebdc --- /dev/null +++ b/reference/fsharp-compiler-symbols.html @@ -0,0 +1,1475 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Symbols | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Symbols Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + FSharpAbstractParameter + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a parameter in an abstract method of a class or interface +

+
+
+

+ + + FSharpAbstractSignature + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the signature of an abstract slot of a class or interface +

+
+
+

+ + + FSharpAccessibility + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicates the accessibility of a symbol, as seen by the F# language +

+
+
+

+ + + FSharpAccessibilityRights + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the rights of a compilation to access symbols +

+
+
+

+ + + FSharpActivePatternCase + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a single case within an active pattern +

+
+
+

+ + + FSharpActivePatternGroup + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents all cases within an active pattern +

+
+
+

+ + + FSharpAnonRecordTypeDetails + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a record or union case field as seen by the F# language +

+
+
+

+ + + FSharpAssembly + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an assembly as seen by the F# language +

+
+
+

+ + + FSharpAssemblyContents + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the definitional contents of an assembly, as seen by the F# language +

+
+
+

+ + + FSharpAssemblySignature + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an inferred signature of part of an assembly as seen by the F# language +

+
+
+

+ + + FSharpAttribute + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a custom attribute attached to F# source code or a compiler .NET component +

+
+
+

+ + + FSharpDelegateSignature + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a delegate signature in an F# symbol +

+
+
+

+ + + FSharpDisplayContext + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the information needed to format types and other information in a style + suitable for use in F# source text at a particular source location. + + Acquired via GetDisplayEnvAtLocationAlternate and similar methods. May be passed + to the Format method on FSharpType and other methods. +

+
+
+

+ + + FSharpEntity + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a type definition or module as seen by the F# language +

+
+
+

+ + + FSharpExpr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a checked and reduced expression, as seen by the F# language. The active patterns + in 'FSharp.Compiler.SourceCodeServices' can be used to analyze information about the expression. + + Pattern matching is reduced to decision trees and conditional tests. Some other + constructs may be represented in reduced form. +

+
+
+

+ + + FSharpExprPatterns + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A collection of active patterns to analyze expressions +

+
+
+

+ + + FSharpField + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a record or union case field as seen by the F# language +

+
+
+

+ + + FSharpGenericParameter + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a generic parameter for an FSharpSymbol +

+
+
+

+ + + FSharpGenericParameterConstraint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a constraint on a generic type parameter +

+
+
+

+ + + FSharpGenericParameterDefaultsToConstraint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents further information about a 'defaults to' constraint on a generic type parameter +

+
+
+

+ + + FSharpGenericParameterDelegateConstraint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents further information about a delegate constraint on a generic type parameter +

+
+
+

+ + + FSharpGenericParameterMemberConstraint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents further information about a member constraint on a generic type parameter +

+
+
+

+ + + FSharpImplementationFileContents + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the definitional contents of a single file or fragment in an assembly, as seen by the F# language +

+
+
+

+ + + FSharpImplementationFileDeclaration + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a declaration in an implementation file, as seen by the F# language +

+
+
+

+ + + FSharpInlineAnnotation + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpMemberOrFunctionOrValue + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of F# symbol that represents an F# method, property, event, function or value, including extension members. +

+
+
+

+ + + FSharpObjectExprOverride + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a checked method in an object expression, as seen by the F# language. +

+
+
+

+ + + FSharpOpenDeclaration + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents open declaration in F# code. +

+
+
+

+ + + FSharpParameter + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a parameter +

+
+
+

+ + + FSharpStaticParameter + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a static parameter to an F# type provider +

+
+
+

+ + + FSharpSymbol + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a symbol in checked F# source code or a compiled .NET component. + + The subtype of the symbol may reveal further information and can be one of FSharpEntity, FSharpUnionCase + FSharpField, FSharpGenericParameter, FSharpStaticParameter, FSharpMemberOrFunctionOrValue, FSharpParameter, + or FSharpActivePatternCase. +

+
+
+

+ + + FSharpSymbolPatterns + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Patterns over FSharpSymbol and derivatives. +

+
+
+

+ + + FSharpType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpUnionCase + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ A subtype of FSharpSymbol that represents a union case as seen by the F# language +

+
+
+

+ + + FSharpXmlDoc + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Describe a comment as either a block of text or a file+signature reference into an intellidoc file. +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatbinding.html b/reference/fsharp-compiler-syntax-debugpointatbinding.html new file mode 100644 index 0000000000..9460362b59 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatbinding.html @@ -0,0 +1,815 @@ + + + + + + + + + + + + + + + + + + DebugPointAtBinding (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtBinding Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for a 'let' binding, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + NoneAtDo + + +

+ +
+
+ Full Usage: + NoneAtDo +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NoneAtInvisible + + +

+ +
+
+ Full Usage: + NoneAtInvisible +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NoneAtLet + + +

+ +
+
+ Full Usage: + NoneAtLet +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NoneAtSticky + + +

+ +
+
+ Full Usage: + NoneAtSticky +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Combine + + +

+ +
+
+ Full Usage: + this.Combine +
+
+ Parameters: + +
+ + Returns: + DebugPointAtBinding + +
+
+
+
+ 		+
+
+ + y + + : + DebugPointAtBinding +
+
+
+
+
+ + Returns: + + DebugPointAtBinding +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatfinally.html b/reference/fsharp-compiler-syntax-debugpointatfinally.html new file mode 100644 index 0000000000..458fe75261 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatfinally.html @@ -0,0 +1,637 @@ + + + + + + + + + + + + + + + + + + DebugPointAtFinally (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtFinally Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for the 'finally' in a 'try .. finally', + that is whether the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatfor.html b/reference/fsharp-compiler-syntax-debugpointatfor.html new file mode 100644 index 0000000000..599e01c8ea --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatfor.html @@ -0,0 +1,637 @@ + + + + + + + + + + + + + + + + + + DebugPointAtFor (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtFor Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for the 'for' in a 'for...' loop, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatinorto.html b/reference/fsharp-compiler-syntax-debugpointatinorto.html new file mode 100644 index 0000000000..2865c1c611 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatinorto.html @@ -0,0 +1,637 @@ + + + + + + + + + + + + + + + + + + DebugPointAtInOrTo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtInOrTo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for the 'in' or 'to' of a 'for...' loop, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatleafexpr.html b/reference/fsharp-compiler-syntax-debugpointatleafexpr.html new file mode 100644 index 0000000000..3bbd406f03 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatleafexpr.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + DebugPointAtLeafExpr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtLeafExpr Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents a debug point at a leaf expression (e.g. an application or constant). +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + Item + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatsequential.html b/reference/fsharp-compiler-syntax-debugpointatsequential.html new file mode 100644 index 0000000000..09e7394fa8 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatsequential.html @@ -0,0 +1,696 @@ + + + + + + + + + + + + + + + + + + DebugPointAtSequential (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtSequential Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<DebugPointAtSequential> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Represents whether a debug point should be suppressed for either the + first or second part of a sequential execution, that is whether the + construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SuppressBoth + + +

+ +
+
+ Full Usage: + SuppressBoth +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SuppressExpr + + +

+ +
+
+ Full Usage: + SuppressExpr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SuppressNeither + + +

+ +
+
+ Full Usage: + SuppressNeither +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SuppressStmt + + +

+ +
+
+ Full Usage: + SuppressStmt +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointattarget.html b/reference/fsharp-compiler-syntax-debugpointattarget.html new file mode 100644 index 0000000000..c5d4fa0bd5 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointattarget.html @@ -0,0 +1,630 @@ + + + + + + + + + + + + + + + + + + DebugPointAtTarget (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtTarget Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<DebugPointAtTarget> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Represents whether a debug point should be present for the target + of a decision tree, that is whether the construct corresponds to a debug + point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes + + +

+ +
+
+ Full Usage: + Yes +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointattry.html b/reference/fsharp-compiler-syntax-debugpointattry.html new file mode 100644 index 0000000000..94c2841c49 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointattry.html @@ -0,0 +1,637 @@ + + + + + + + + + + + + + + + + + + DebugPointAtTry (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtTry Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for a 'try', that is whether + the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatwhile.html b/reference/fsharp-compiler-syntax-debugpointatwhile.html new file mode 100644 index 0000000000..dabc227d98 --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatwhile.html @@ -0,0 +1,637 @@ + + + + + + + + + + + + + + + + + + DebugPointAtWhile (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtWhile Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for the 'while' in a 'while...' loop, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-debugpointatwith.html b/reference/fsharp-compiler-syntax-debugpointatwith.html new file mode 100644 index 0000000000..9af8d80c3e --- /dev/null +++ b/reference/fsharp-compiler-syntax-debugpointatwith.html @@ -0,0 +1,637 @@ + + + + + + + + + + + + + + + + + + DebugPointAtWith (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DebugPointAtWith Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents whether a debug point should be present for the 'with' in a 'try .. with', + that is whether the construct corresponds to a debug point in the original source. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + No + + +

+ +
+
+ Full Usage: + No +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yes range + + +

+ +
+
+ Full Usage: + Yes range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-expratomicflag.html b/reference/fsharp-compiler-syntax-expratomicflag.html new file mode 100644 index 0000000000..5b34e81a3d --- /dev/null +++ b/reference/fsharp-compiler-syntax-expratomicflag.html @@ -0,0 +1,657 @@ + + + + + + + + + + + + + + + + + + ExprAtomicFlag (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ExprAtomicFlag Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ Indicates if an expression is an atomic expression. + + An atomic expression has no whitespace unless enclosed in parentheses, e.g. + 1, "3", ident, ident.[expr] and (expr). If an atomic expression has type T, + then the largest expression ending at the same range as the atomic expression + also has type T. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Atomic + + +

+ +
+
+ Full Usage: + Atomic +
+
+ + Field type: + ExprAtomicFlag + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + ExprAtomicFlag +
+
+
+
+
+ +

+ + + NonAtomic + + +

+ +
+
+ Full Usage: + NonAtomic +
+
+ + Field type: + ExprAtomicFlag + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + ExprAtomicFlag +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-ident.html b/reference/fsharp-compiler-syntax-ident.html new file mode 100644 index 0000000000..8fd1805a58 --- /dev/null +++ b/reference/fsharp-compiler-syntax-ident.html @@ -0,0 +1,728 @@ + + + + + + + + + + + + + + + + + + Ident (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Ident Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ Kind: Struct +
+
+
+
+

+ Represents an identifier in F# code +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + Ident(text, range) + + +

+ +
+
+ Full Usage: + Ident(text, range) +
+
+ Parameters: +
    + + + text + + : + string + +
    + + + range + + : + range + +
    +
+
+ + Returns: + Ident + +
+
+
+
+ 		+
+
+ + text + + : + string +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + Ident +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.idRange + + +

+ +
+
+ Full Usage: + this.idRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.idText + + +

+ +
+
+ Full Usage: + this.idText +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedhashdirective.html b/reference/fsharp-compiler-syntax-parsedhashdirective.html new file mode 100644 index 0000000000..2827e33955 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedhashdirective.html @@ -0,0 +1,631 @@ + + + + + + + + + + + + + + + + + + ParsedHashDirective (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedHashDirective Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a parsed hash directive +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ParsedHashDirective(ident, args, range) + + +

+ +
+
+ Full Usage: + ParsedHashDirective(ident, args, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + ident + + : + string +
+
+
+ + args + + : + ParsedHashDirectiveArgument list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html b/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html new file mode 100644 index 0000000000..471c37e604 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedhashdirectiveargument.html @@ -0,0 +1,785 @@ + + + + + + + + + + + + + + + + + + ParsedHashDirectiveArgument (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedHashDirectiveArgument Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a parsed hash directive argument +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SourceIdentifier(constant, value, range) + + +

+ +
+
+ Full Usage: + SourceIdentifier(constant, value, range) +
+
+ Parameters: +
    + + + constant + + : + string + +
    + + + value + + : + string + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + constant + + : + string +
+
+
+ + value + + : + string +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + String(value, stringKind, range) + + +

+ +
+
+ Full Usage: + String(value, stringKind, range) +
+
+ Parameters: +
    + + + value + + : + string + +
    + + + stringKind + + : + SynStringKind + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + value + + : + string +
+
+
+ + stringKind + + : + SynStringKind +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedimplfile.html b/reference/fsharp-compiler-syntax-parsedimplfile.html new file mode 100644 index 0000000000..9cf79d2943 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedimplfile.html @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + ParsedImplFile (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedImplFile Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a parsed implementation file made up of fragments +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ParsedImplFile(hashDirectives, fragments) + + +

+ +
+
+ Full Usage: + ParsedImplFile(hashDirectives, fragments) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + hashDirectives + + : + ParsedHashDirective list +
+
+
+ + fragments + + : + ParsedImplFileFragment list +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedimplfilefragment.html b/reference/fsharp-compiler-syntax-parsedimplfilefragment.html new file mode 100644 index 0000000000..331d944adb --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedimplfilefragment.html @@ -0,0 +1,857 @@ + + + + + + + + + + + + + + + + + + ParsedImplFileFragment (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedImplFileFragment Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for the contents of a parsed implementation file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AnonModule(decls, range) + + +

+ +
+
+ Full Usage: + AnonModule(decls, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An implementation file which is an anonymous module definition, e.g. a script +

+
+ +
+
+ + decls + + : + SynModuleDecl list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + NamedModule namedModule + + +

+ +
+
+ Full Usage: + NamedModule namedModule +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An implementation file is a named module definition, 'module N' +

+
+ +
+
+ + namedModule + + : + SynModuleOrNamespace +
+
+
+
+
+
+ +

+ + + NamespaceFragment(longId, isRecursive, kind, decls, xmlDoc, attributes, range, trivia) + + +

+ +
+
+ Full Usage: + NamespaceFragment(longId, isRecursive, kind, decls, xmlDoc, attributes, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An implementation file fragment which declares a namespace fragment +

+
+ +
+
+ + longId + + : + LongIdent +
+
+
+ + isRecursive + + : + bool +
+
+
+ + kind + + : + SynModuleOrNamespaceKind +
+
+
+ + decls + + : + SynModuleDecl list +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynModuleOrNamespaceTrivia +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedimplfileinput.html b/reference/fsharp-compiler-syntax-parsedimplfileinput.html new file mode 100644 index 0000000000..4a2834d6c4 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedimplfileinput.html @@ -0,0 +1,1096 @@ + + + + + + + + + + + + + + + + + + ParsedImplFileInput (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedImplFileInput Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the full syntax tree, file name and other parsing information for an implementation file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ParsedImplFileInput(fileName, isScript, qualifiedNameOfFile, scopedPragmas, hashDirectives, contents, flags, trivia, identifiers) + + +

+ +
+
+ Full Usage: + ParsedImplFileInput(fileName, isScript, qualifiedNameOfFile, scopedPragmas, hashDirectives, contents, flags, trivia, identifiers) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+ + isScript + + : + bool +
+
+
+ + qualifiedNameOfFile + + : + QualifiedNameOfFile +
+
+
+ + scopedPragmas + + : + ScopedPragma list +
+
+
+ + hashDirectives + + : + ParsedHashDirective list +
+
+
+ + contents + + : + SynModuleOrNamespace list +
+
+
+ + flags + + : + bool * bool +
+
+
+ + trivia + + : + ParsedImplFileInputTrivia +
+
+
+ + identifiers + + : + Set<string> +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Contents + + +

+ +
+
+ Full Usage: + this.Contents +
+
+ + Returns: + SynModuleOrNamespace list + +
+
+
+
+ 		+
+
+ + Returns: + + SynModuleOrNamespace list +
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.HashDirectives + + +

+ +
+
+ Full Usage: + this.HashDirectives +
+
+ + Returns: + ParsedHashDirective list + +
+
+
+
+ 		+
+
+ + Returns: + + ParsedHashDirective list +
+
+
+
+
+ +

+ + + this.IsExe + + +

+ +
+
+ Full Usage: + this.IsExe +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsLastCompiland + + +

+ +
+
+ Full Usage: + this.IsLastCompiland +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsScript + + +

+ +
+
+ Full Usage: + this.IsScript +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + QualifiedNameOfFile + +
+
+
+
+ 		+
+
+ + Returns: + + QualifiedNameOfFile +
+
+
+
+
+ +

+ + + this.ScopedPragmas + + +

+ +
+
+ Full Usage: + this.ScopedPragmas +
+
+ + Returns: + ScopedPragma list + +
+
+
+
+ 		+
+
+ + Returns: + + ScopedPragma list +
+
+
+
+
+ +

+ + + this.Trivia + + +

+ +
+
+ Full Usage: + this.Trivia +
+
+ + Returns: + ParsedImplFileInputTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + ParsedImplFileInputTrivia +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedinput.html b/reference/fsharp-compiler-syntax-parsedinput.html new file mode 100644 index 0000000000..f177902e64 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedinput.html @@ -0,0 +1,973 @@ + + + + + + + + + + + + + + + + + + ParsedInput (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedInput Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for a parsed implementation or signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ImplFile ParsedImplFileInput + + +

+ +
+
+ Full Usage: + ImplFile ParsedImplFileInput +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A parsed implementation file +

+
+ +
+
+ + Item + + : + ParsedImplFileInput +
+
+
+
+
+
+ +

+ + + SigFile ParsedSigFileInput + + +

+ +
+
+ Full Usage: + SigFile ParsedSigFileInput +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A parsed signature file +

+
+ +
+
+ + Item + + : + ParsedSigFileInput +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the file name for the parsed input +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.Identifiers + + +

+ +
+
+ Full Usage: + this.Identifiers +
+
+ + Returns: + Set<string> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets a set of all identifiers used in this parsed input. Only populated if captureIdentifiersWhenParsing option was used. +

+
+ +
+
+ + Returns: + + Set<string> +
+
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + QualifiedNameOfFile + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the qualified name used to help match signature and implementation files +

+
+ +
+
+ + Returns: + + QualifiedNameOfFile +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.ScopedPragmas + + +

+ +
+
+ Full Usage: + this.ScopedPragmas +
+
+ + Returns: + ScopedPragma list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the #nowarn and other scoped pragmas +

+
+ +
+
+ + Returns: + + ScopedPragma list +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedscriptinteraction.html b/reference/fsharp-compiler-syntax-parsedscriptinteraction.html new file mode 100644 index 0000000000..c9fb52e2a9 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedscriptinteraction.html @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + ParsedScriptInteraction (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedScriptInteraction Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a parsed syntax tree for an F# Interactive interaction +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Definitions(defns, range) + + +

+ +
+
+ Full Usage: + Definitions(defns, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + defns + + : + SynModuleDecl list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedsigfile.html b/reference/fsharp-compiler-syntax-parsedsigfile.html new file mode 100644 index 0000000000..3da3b9944f --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedsigfile.html @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + ParsedSigFile (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedSigFile Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a parsed signature file made up of fragments +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ParsedSigFile(hashDirectives, fragments) + + +

+ +
+
+ Full Usage: + ParsedSigFile(hashDirectives, fragments) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + hashDirectives + + : + ParsedHashDirective list +
+
+
+ + fragments + + : + ParsedSigFileFragment list +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedsigfilefragment.html b/reference/fsharp-compiler-syntax-parsedsigfilefragment.html new file mode 100644 index 0000000000..4ace08f346 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedsigfilefragment.html @@ -0,0 +1,857 @@ + + + + + + + + + + + + + + + + + + ParsedSigFileFragment (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedSigFileFragment Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for the contents of a parsed signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AnonModule(decls, range) + + +

+ +
+
+ Full Usage: + AnonModule(decls, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A signature file which is an anonymous module, e.g. the signature file for the final file in an application +

+
+ +
+
+ + decls + + : + SynModuleSigDecl list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + NamedModule namedModule + + +

+ +
+
+ Full Usage: + NamedModule namedModule +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A signature file which is a module, 'module N' +

+
+ +
+
+ + namedModule + + : + SynModuleOrNamespaceSig +
+
+
+
+
+
+ +

+ + + NamespaceFragment(longId, isRecursive, kind, decls, xmlDoc, attributes, range, trivia) + + +

+ +
+
+ Full Usage: + NamespaceFragment(longId, isRecursive, kind, decls, xmlDoc, attributes, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A signature file namespace fragment +

+
+ +
+
+ + longId + + : + LongIdent +
+
+
+ + isRecursive + + : + bool +
+
+
+ + kind + + : + SynModuleOrNamespaceKind +
+
+
+ + decls + + : + SynModuleSigDecl list +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynModuleOrNamespaceSigTrivia +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parsedsigfileinput.html b/reference/fsharp-compiler-syntax-parsedsigfileinput.html new file mode 100644 index 0000000000..db0b277395 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parsedsigfileinput.html @@ -0,0 +1,947 @@ + + + + + + + + + + + + + + + + + + ParsedSigFileInput (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedSigFileInput Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the full syntax tree, file name and other parsing information for a signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ParsedSigFileInput(fileName, qualifiedNameOfFile, scopedPragmas, hashDirectives, contents, trivia, identifiers) + + +

+ +
+
+ Full Usage: + ParsedSigFileInput(fileName, qualifiedNameOfFile, scopedPragmas, hashDirectives, contents, trivia, identifiers) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + fileName + + : + string +
+
+
+ + qualifiedNameOfFile + + : + QualifiedNameOfFile +
+
+
+ + scopedPragmas + + : + ScopedPragma list +
+
+
+ + hashDirectives + + : + ParsedHashDirective list +
+
+
+ + contents + + : + SynModuleOrNamespaceSig list +
+
+
+ + trivia + + : + ParsedSigFileInputTrivia +
+
+
+ + identifiers + + : + Set<string> +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Contents + + +

+ +
+
+ Full Usage: + this.Contents +
+
+ + Returns: + SynModuleOrNamespaceSig list + +
+
+
+
+ 		+
+
+ + Returns: + + SynModuleOrNamespaceSig list +
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + this.HashDirectives + + +

+ +
+
+ Full Usage: + this.HashDirectives +
+
+ + Returns: + ParsedHashDirective list + +
+
+
+
+ 		+
+
+ + Returns: + + ParsedHashDirective list +
+
+
+
+
+ +

+ + + this.QualifiedName + + +

+ +
+
+ Full Usage: + this.QualifiedName +
+
+ + Returns: + QualifiedNameOfFile + +
+
+
+
+ 		+
+
+ + Returns: + + QualifiedNameOfFile +
+
+
+
+
+ +

+ + + this.ScopedPragmas + + +

+ +
+
+ Full Usage: + this.ScopedPragmas +
+
+ + Returns: + ScopedPragma list + +
+
+
+
+ 		+
+
+ + Returns: + + ScopedPragma list +
+
+
+
+
+ +

+ + + this.Trivia + + +

+ +
+
+ Full Usage: + this.Trivia +
+
+ + Returns: + ParsedSigFileInputTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + ParsedSigFileInputTrivia +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-parserdetail.html b/reference/fsharp-compiler-syntax-parserdetail.html new file mode 100644 index 0000000000..ededc30007 --- /dev/null +++ b/reference/fsharp-compiler-syntax-parserdetail.html @@ -0,0 +1,628 @@ + + + + + + + + + + + + + + + + + + ParserDetail (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParserDetail Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<ParserDetail> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Indicates if the construct arises from error recovery +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ErrorRecovery + + +

+ +
+
+ Full Usage: + ErrorRecovery +
+
+
+
+
+ 		+
+ + + +

+ The construct arises from error recovery +

+
+
+
+ +

+ + + Ok + + +

+ +
+
+ Full Usage: + Ok +
+
+
+
+
+ 		+
+ + + +

+ The construct arises normally +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-prettynaming.html b/reference/fsharp-compiler-syntax-prettynaming.html new file mode 100644 index 0000000000..a31a750566 --- /dev/null +++ b/reference/fsharp-compiler-syntax-prettynaming.html @@ -0,0 +1,2000 @@ + + + + + + + + + + + + + + + + + + PrettyNaming (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ PrettyNaming Module +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Some general F# utilities for mangling / unmangling / manipulating names. + Anything to do with special names of identifiers and other lexical rules +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + CompileOpName op + + +

+ +
+
+ Full Usage: + CompileOpName op +
+
+ Parameters: +
    + + + op + + : + string + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Converts the core of an operator name into a logical name. For example,
+    +  --> op_Addition
+    !%  --> op_DereferencePercent
+ Only used on actual operator names
+
+ +
+
+ + op + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + ConvertValLogicalNameToDisplayNameCore opName + + +

+ +
+
+ Full Usage: + ConvertValLogicalNameToDisplayNameCore opName +
+
+ Parameters: +
    + + + opName + + : + string + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Converts the logical name for and operator back into the core of a display name. For example:
+     Foo                   --> Foo
+     +                     --> +
+     op_Addition           --> +
+     op_DereferencePercent --> !%
+     A-B                   --> A-B
+     |A|_|                 --> |A|_|
+     base                  --> base        regardless of IsBaseVal
+ Used on names of all kinds
+
+ TODO: We should assess uses of this function.
+
+ In any cases it is used it probably indicates that text is being
+ generated which:
+    1. does not contain double-backticks for non-identifiers
+    2. does not put parentheses arounf operators or active pattern names
+
+ If the text is immediately in quotes, this is generally ok, e.g.
+
+         error FS0038: '+' is bound twice in this pattern
+         error FS0038: '|A|_|' is bound twice in this pattern
+         error FS0038: 'a a' is bound twice in this pattern
+
+ If not, the it is likely this should be replaced by ConvertValLogicalNameToDisplayName.
+
+ +
+
+ + opName + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + FSharpSignatureDataResourceName2 + + +

+ +
+
+ Full Usage: + FSharpSignatureDataResourceName2 +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + FormatAndOtherOverloadsString arg1 + + +

+ +
+
+ Full Usage: + FormatAndOtherOverloadsString arg1 +
+
+ Parameters: +
    + + + arg0 + + : + int + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+
+ + arg0 + + : + int +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+ +

+ + + FsiDynamicModulePrefix + + +

+ +
+
+ Full Usage: + FsiDynamicModulePrefix +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The prefix of the names used for the fake namespace path added to all dynamic code entries in FSI.EXE +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + GetLongNameFromString arg1 + + +

+ +
+
+ Full Usage: + GetLongNameFromString arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + string list +
+
+
+
+
+ +

+ + + IsActivePatternName name + + +

+ +
+
+ Full Usage: + IsActivePatternName name +
+
+ Parameters: +
    + + + name + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Determines if the specified name is a valid name for an active pattern.
+     |A|_|        --> true
+     |A|B|        --> true
+     |A|          --> true
+     |            --> false
+     ||           --> false
+     op_Addition  --> false
+
+ TBD: needs unit testing
+
+ +
+
+ + name + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsCompilerGeneratedName nm + + +

+ +
+
+ Full Usage: + IsCompilerGeneratedName nm +
+
+ Parameters: +
    + + + nm + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + nm + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + IsIdentifierFirstCharacter c + + +

+ +
+
+ Full Usage: + IsIdentifierFirstCharacter c +
+
+ Parameters: +
    + + + c + + : + char + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The characters that are allowed to be the first character of an identifier. +

+
+ +
+
+ + c + + : + char +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsIdentifierName name + + +

+ +
+
+ Full Usage: + IsIdentifierName name +
+
+ Parameters: +
    + + + name + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Is the name a valid F# identifier, primarily used internally in PrettyNaming.fs for determining if an
+ identifier needs backticks.
+
+ In general do not use this routine. It is only used in one quick fix, for determining if it is valid
+ to add "_" in front of an identifier.
+
+     A            --> true
+     A'           --> true
+     _A           --> true
+     A0           --> true
+     |A|B|        --> false
+     op_Addition  --> true
+     +            --> false
+     let          --> false
+     base         --> false
+
+ TBD: needs unit testing
+
+ +
+
+ + name + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsIdentifierPartCharacter c + + +

+ +
+
+ Full Usage: + IsIdentifierPartCharacter c +
+
+ Parameters: +
    + + + c + + : + char + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The characters that are allowed to be in an identifier. +

+
+ +
+
+ + c + + : + char +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsLogicalInfixOpName logicalName + + +

+ +
+
+ Full Usage: + IsLogicalInfixOpName logicalName +
+
+ Parameters: +
    + + + logicalName + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + logicalName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + IsLogicalOpName logicalName + + +

+ +
+
+ Full Usage: + IsLogicalOpName logicalName +
+
+ Parameters: +
    + + + logicalName + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Is the name a logical operator name, including unary, binary and ternary operators
+    op_UnaryPlus         - yes
+    op_Addition          - yes
+    op_Range             - yes (?)
+    op_RangeStep         - yes (?)
+    op_DynamicAssignment - yes
+    op_Quack             - no
+    +                    - no
+    ABC                  - no
+    ABC DEF              - no
+    base                 - no
+    |A|_|                - no
+
+ +
+
+ + logicalName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsLogicalPrefixOperator logicalName + + +

+ +
+
+ Full Usage: + IsLogicalPrefixOperator logicalName +
+
+ Parameters: +
    + + + logicalName + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + logicalName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + IsLogicalTernaryOperator logicalName + + +

+ +
+
+ Full Usage: + IsLogicalTernaryOperator logicalName +
+
+ Parameters: +
    + + + logicalName + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + logicalName + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + IsLongIdentifierPartCharacter c + + +

+ +
+
+ Full Usage: + IsLongIdentifierPartCharacter c +
+
+ Parameters: +
    + + + c + + : + char + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Is this character a part of a long identifier? +

+
+ +
+
+ + c + + : + char +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsOperatorDisplayName name + + +

+ +
+
+ Full Usage: + IsOperatorDisplayName name +
+
+ Parameters: +
    + + + name + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Returns `true` if given string is an operator display name, e.g.
+    ( |>> )
+    |>>
+    ..
+
+ +
+
+ + name + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + IsPunctuation s + + +

+ +
+
+ Full Usage: + IsPunctuation s +
+
+ Parameters: +
    + + + s + + : + string + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + s + + : + string +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + NormalizeIdentifierBackticks name + + +

+ +
+
+ Full Usage: + NormalizeIdentifierBackticks name +
+
+ Parameters: +
    + + + name + + : + string + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Adds double backticks if necessary to make a valid identifier, e.g.
+     op_Addition  -->  op_Addition
+     +            -->  ``+``    (this is not op_Addition)
+     |>>          -->  ``|>>``  (this is not an op_)
+     A-B          -->  ``A-B``
+     AB           -->  AB
+     |A|_|        -->  |A|_|    this is an active pattern name, needs parens not backticks
+ Removes double backticks if not necessary to make a valid identifier, e.g.
+     ``A``        --> A
+     ``A-B``      --> ``A-B``
+
+ +
+
+ + name + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + TryChopPropertyName s + + +

+ +
+
+ Full Usage: + TryChopPropertyName s +
+
+ Parameters: +
    + + + s + + : + string + +
    +
+
+ + Returns: + string option + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Try to chop "get_" or "set_" from a string +

+
+ +
+
+ + s + + : + string +
+
+
+
+
+ + Returns: + + string option +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-qualifiednameoffile.html b/reference/fsharp-compiler-syntax-qualifiednameoffile.html new file mode 100644 index 0000000000..ba8d001f46 --- /dev/null +++ b/reference/fsharp-compiler-syntax-qualifiednameoffile.html @@ -0,0 +1,788 @@ + + + + + + + + + + + + + + + + + + QualifiedNameOfFile (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ QualifiedNameOfFile Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a qualifying name for anonymous module specifications and implementations, +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + QualifiedNameOfFile Ident + + +

+ +
+
+ Full Usage: + QualifiedNameOfFile Ident +
+
+ Parameters: +
    + + + Item + + : + Ident + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + Ident +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Id + + +

+ +
+
+ Full Usage: + this.Id +
+
+ + Returns: + Ident + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The identifier for the name of the file +

+
+ +
+
+ + Returns: + + Ident +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.Text + + +

+ +
+
+ Full Usage: + this.Text +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The name of the file +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-scopedpragma.html b/reference/fsharp-compiler-syntax-scopedpragma.html new file mode 100644 index 0000000000..951168ecfd --- /dev/null +++ b/reference/fsharp-compiler-syntax-scopedpragma.html @@ -0,0 +1,631 @@ + + + + + + + + + + + + + + + + + + ScopedPragma (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ScopedPragma Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents a scoped pragma +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + WarningOff(range, warningNumber) + + +

+ +
+
+ Full Usage: + WarningOff(range, warningNumber) +
+
+ Parameters: +
    + + + range + + : + range + +
    + + + warningNumber + + : + int + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A pragma to turn a warning off +

+
+ +
+
+ + range + + : + range +
+
+
+ + warningNumber + + : + int +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-seqexpronly.html b/reference/fsharp-compiler-syntax-seqexpronly.html new file mode 100644 index 0000000000..28de6c7bda --- /dev/null +++ b/reference/fsharp-compiler-syntax-seqexpronly.html @@ -0,0 +1,621 @@ + + + + + + + + + + + + + + + + + + SeqExprOnly (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SeqExprOnly Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<SeqExprOnly> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Indicates if a for loop is 'for x in e1 -> e2', only valid in sequence expressions +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SeqExprOnly bool + + +

+ +
+
+ Full Usage: + SeqExprOnly bool +
+
+ Parameters: +
    + + + Item + + : + bool + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Indicates if a for loop is 'for x in e1 -> e2', only valid in sequence expressions +

+
+ +
+
+ + Item + + : + bool +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synaccess.html b/reference/fsharp-compiler-syntax-synaccess.html new file mode 100644 index 0000000000..e32825f938 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synaccess.html @@ -0,0 +1,790 @@ + + + + + + + + + + + + + + + + + + SynAccess (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynAccess Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents an accessibility modifier in F# syntax +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Internal range + + +

+ +
+
+ Full Usage: + Internal range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A construct marked or assumed 'internal' +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Private range + + +

+ +
+
+ Full Usage: + Private range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A construct marked or assumed 'private' +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Public range + + +

+ +
+
+ Full Usage: + Public range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A construct marked or assumed 'public' +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synarginfo.html b/reference/fsharp-compiler-syntax-synarginfo.html new file mode 100644 index 0000000000..5a64e7e6f9 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synarginfo.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + SynArgInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynArgInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the argument names and other metadata for a parameter for a member or function +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynArgInfo(attributes, optional, ident) + + +

+ +
+
+ Full Usage: + SynArgInfo(attributes, optional, ident) +
+
+ Parameters: +
    + + + attributes + + : + SynAttributes + +
    + + + optional + + : + bool + +
    + + + ident + + : + Ident option + +
    +
+
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + optional + + : + bool +
+
+
+ + ident + + : + Ident option +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Attributes + + +

+ +
+
+ Full Usage: + this.Attributes +
+
+ + Returns: + SynAttributes + +
+
+
+
+ 		+
+
+ + Returns: + + SynAttributes +
+
+
+
+
+ +

+ + + this.Ident + + +

+ +
+
+ Full Usage: + this.Ident +
+
+ + Returns: + Ident option + +
+
+
+
+ 		+
+
+ + Returns: + + Ident option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synargpats.html b/reference/fsharp-compiler-syntax-synargpats.html new file mode 100644 index 0000000000..625a273404 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synargpats.html @@ -0,0 +1,735 @@ + + + + + + + + + + + + + + + + + + SynArgPats (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynArgPats Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntax tree for arguments patterns +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + NamePatPairs(pats, range, trivia) + + +

+ +
+
+ Full Usage: + NamePatPairs(pats, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + pats + + : + (Ident * range option * SynPat) list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynArgPatsNamePatPairsTrivia +
+
+
+
+
+ +

+ + + Pats pats + + +

+ +
+
+ Full Usage: + Pats pats +
+
+ Parameters: +
    + + + pats + + : + SynPat list + +
    +
+
+
+
+
+ 		+
+
+ + pats + + : + SynPat list +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Patterns + + +

+ +
+
+ Full Usage: + this.Patterns +
+
+ + Returns: + SynPat list + +
+
+
+
+ 		+
+
+ + Returns: + + SynPat list +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synattribute.html b/reference/fsharp-compiler-syntax-synattribute.html new file mode 100644 index 0000000000..6fdb947408 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synattribute.html @@ -0,0 +1,807 @@ + + + + + + + + + + + + + + + + + + SynAttribute (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynAttribute Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an attribute +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AppliesToGetterAndSetter + + +

+ +
+
+ Full Usage: + AppliesToGetterAndSetter +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ Is this attribute being applied to a property getter or setter? +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + ArgExpr + + +

+ +
+
+ Full Usage: + ArgExpr +
+
+ + Field type: + SynExpr + +
+
+
+
+ 		+
+ +
+ + + +

+ The argument of the attribute, perhaps a tuple +

+
+ +
+
+ + Field type: + + SynExpr +
+
+
+
+
+
+ +

+ + + Range + + +

+ +
+
+ Full Usage: + Range +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the attribute +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + Target + + +

+ +
+
+ Full Usage: + Target +
+
+ + Field type: + Ident option + +
+
+
+
+ 		+
+ +
+ + + +

+ Target specifier, e.g. "assembly", "module", etc. +

+
+ +
+
+ + Field type: + + Ident option +
+
+
+
+
+
+ +

+ + + TypeName + + +

+ +
+
+ Full Usage: + TypeName +
+
+ + Field type: + SynLongIdent + +
+
+
+
+ 		+
+ +
+ + + +

+ The name of the type for the attribute +

+
+ +
+
+ + Field type: + + SynLongIdent +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synattributelist.html b/reference/fsharp-compiler-syntax-synattributelist.html new file mode 100644 index 0000000000..4a883fe640 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synattributelist.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + SynAttributeList (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynAttributeList Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ List of attributes enclosed in [< ... >]. +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Attributes + + +

+ +
+
+ Full Usage: + Attributes +
+
+ + Field type: + SynAttribute list + +
+
+
+
+ 		+
+ +
+ + + +

+ The list of attributes +

+
+ +
+
+ + Field type: + + SynAttribute list +
+
+
+
+
+
+ +

+ + + Range + + +

+ +
+
+ Full Usage: + Range +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the list of attributes +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synbinding.html b/reference/fsharp-compiler-syntax-synbinding.html new file mode 100644 index 0000000000..d14c1bc716 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synbinding.html @@ -0,0 +1,926 @@ + + + + + + + + + + + + + + + + + + SynBinding (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynBinding Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a binding for a 'let' or 'member' declaration +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynBinding(accessibility, kind, isInline, isMutable, attributes, xmlDoc, valData, headPat, returnInfo, expr, range, debugPoint, trivia) + + +

+ +
+
+ Full Usage: + SynBinding(accessibility, kind, isInline, isMutable, attributes, xmlDoc, valData, headPat, returnInfo, expr, range, debugPoint, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + kind + + : + SynBindingKind +
+
+
+ + isInline + + : + bool +
+
+
+ + isMutable + + : + bool +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + valData + + : + SynValData +
+
+
+ + headPat + + : + SynPat +
+
+
+ + returnInfo + + : + SynBindingReturnInfo option +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + debugPoint + + : + DebugPointAtBinding +
+
+
+ + trivia + + : + SynBindingTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.RangeOfBindingWithRhs + + +

+ +
+
+ Full Usage: + this.RangeOfBindingWithRhs +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.RangeOfBindingWithoutRhs + + +

+ +
+
+ Full Usage: + this.RangeOfBindingWithoutRhs +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.RangeOfHeadPattern + + +

+ +
+
+ Full Usage: + this.RangeOfHeadPattern +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synbindingkind.html b/reference/fsharp-compiler-syntax-synbindingkind.html new file mode 100644 index 0000000000..6abe3e96a6 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synbindingkind.html @@ -0,0 +1,661 @@ + + + + + + + + + + + + + + + + + + SynBindingKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynBindingKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<SynBindingKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ The kind associated with a binding - "let", "do" or a standalone expression +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Do + + +

+ +
+
+ Full Usage: + Do +
+
+
+
+
+ 		+
+ + + +

+ A 'do' binding in a module. Must have type 'unit' +

+
+
+
+ +

+ + + Normal + + +

+ +
+
+ Full Usage: + Normal +
+
+
+
+
+ 		+
+ + + +

+ A normal 'let' binding in a module +

+
+
+
+ +

+ + + StandaloneExpression + + +

+ +
+
+ Full Usage: + StandaloneExpression +
+
+
+
+
+ 		+
+ + + +

+ A standalone expression in a module +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synbindingreturninfo.html b/reference/fsharp-compiler-syntax-synbindingreturninfo.html new file mode 100644 index 0000000000..89f488ec8c --- /dev/null +++ b/reference/fsharp-compiler-syntax-synbindingreturninfo.html @@ -0,0 +1,647 @@ + + + + + + + + + + + + + + + + + + SynBindingReturnInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynBindingReturnInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the return information in a binding for a 'let' or 'member' declaration +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynBindingReturnInfo(typeName, range, attributes, trivia) + + +

+ +
+
+ Full Usage: + SynBindingReturnInfo(typeName, range, attributes, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + typeName + + : + SynType +
+
+
+ + range + + : + range +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + trivia + + : + SynBindingReturnInfoTrivia +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synbytestringkind.html b/reference/fsharp-compiler-syntax-synbytestringkind.html new file mode 100644 index 0000000000..c309cdff8d --- /dev/null +++ b/reference/fsharp-compiler-syntax-synbytestringkind.html @@ -0,0 +1,631 @@ + + + + + + + + + + + + + + + + + + SynByteStringKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynByteStringKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<SynByteStringKind> + , + IComparable + , + IStructuralComparable +
+
+ Kind: Struct +
+
+
+
+

+ Indicate if the byte string had a special format +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Regular + + +

+ +
+
+ Full Usage: + Regular +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Verbatim + + +

+ +
+
+ Full Usage: + Verbatim +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syncomponentinfo.html b/reference/fsharp-compiler-syntax-syncomponentinfo.html new file mode 100644 index 0000000000..b18210695b --- /dev/null +++ b/reference/fsharp-compiler-syntax-syncomponentinfo.html @@ -0,0 +1,791 @@ + + + + + + + + + + + + + + + + + + SynComponentInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynComponentInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree associated with the name of a type definition or module + in signature or implementation. + + This includes the name, attributes, type parameters, constraints, documentation and accessibility + for a type definition or module. For modules, entries such as the type parameters are + always empty. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynComponentInfo(attributes, typeParams, constraints, longId, xmlDoc, preferPostfix, accessibility, range) + + +

+ +
+
+ Full Usage: + SynComponentInfo(attributes, typeParams, constraints, longId, xmlDoc, preferPostfix, accessibility, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + typeParams + + : + SynTyparDecls option +
+
+
+ + constraints + + : + SynTypeConstraint list +
+
+
+ + longId + + : + LongIdent +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + preferPostfix + + : + bool +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synconst.html b/reference/fsharp-compiler-syntax-synconst.html new file mode 100644 index 0000000000..bbf2cf5dd5 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synconst.html @@ -0,0 +1,2088 @@ + + + + + + + + + + + + + + + + + + SynConst (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynConst Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ The unchecked abstract syntax tree of constants in F# types and expressions. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Bool bool + + +

+ +
+
+ Full Usage: + Bool bool +
+
+ Parameters: +
    + + + Item + + : + bool + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: true, false +

+
+ +
+
+ + Item + + : + bool +
+
+
+
+
+
+ +

+ + + Byte byte + + +

+ +
+
+ Full Usage: + Byte byte +
+
+ Parameters: +
    + + + Item + + : + byte + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13uy, 0x40uy, 0oFFuy, 0b0111101uy +

+
+ +
+
+ + Item + + : + byte +
+
+
+
+
+
+ +

+ + + Bytes(bytes, synByteStringKind, range) + + +

+ +
+
+ Full Usage: + Bytes(bytes, synByteStringKind, range) +
+
+ Parameters: +
    + + + bytes + + : + byte[] + +
    + + + synByteStringKind + + : + SynByteStringKind + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: verbatim or regular byte string, e.g. "abc"B. + + Also used internally in the typechecker once an array of unit16 constants + is detected, to allow more efficient processing of large arrays of uint16 constants. +

+
+ +
+
+ + bytes + + : + byte[] +
+
+
+ + synByteStringKind + + : + SynByteStringKind +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Char char + + +

+ +
+
+ Full Usage: + Char char +
+
+ Parameters: +
    + + + Item + + : + char + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'a' +

+
+ +
+
+ + Item + + : + char +
+
+
+
+
+
+ +

+ + + Decimal Decimal + + +

+ +
+
+ Full Usage: + Decimal Decimal +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 23.4M +

+
+ +
+
+ + Item + + : + Decimal +
+
+
+
+
+
+ +

+ + + Double double + + +

+ +
+
+ Full Usage: + Double double +
+
+ Parameters: +
    + + + Item + + : + double + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 1.30, 1.40e10 etc. +

+
+ +
+
+ + Item + + : + double +
+
+
+
+
+
+ +

+ + + Int16 int16 + + +

+ +
+
+ Full Usage: + Int16 int16 +
+
+ Parameters: +
    + + + Item + + : + int16 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13s, 0x4000s, 0o0777s, 0b0111101s +

+
+ +
+
+ + Item + + : + int16 +
+
+
+
+
+
+ +

+ + + Int32 int32 + + +

+ +
+
+ Full Usage: + Int32 int32 +
+
+ Parameters: +
    + + + Item + + : + int32 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13, 0x4000, 0o0777 +

+
+ +
+
+ + Item + + : + int32 +
+
+
+
+
+
+ +

+ + + Int64 int64 + + +

+ +
+
+ Full Usage: + Int64 int64 +
+
+ Parameters: +
    + + + Item + + : + int64 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13L +

+
+ +
+
+ + Item + + : + int64 +
+
+
+
+
+
+ +

+ + + IntPtr int64 + + +

+ +
+
+ Full Usage: + IntPtr int64 +
+
+ Parameters: +
    + + + Item + + : + int64 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13n +

+
+ +
+
+ + Item + + : + int64 +
+
+
+
+
+
+ +

+ + + Measure(constant, constantRange, synMeasure, trivia) + + +

+ +
+
+ Full Usage: + Measure(constant, constantRange, synMeasure, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Old comment: "we never iterate, so the const here is not another SynConst.Measure" +

+
+ +
+
+ + constant + + : + SynConst +
+
+
+ + constantRange + + : + range +
+
+
+ + synMeasure + + : + SynMeasure +
+
+
+ + trivia + + : + SynMeasureConstantTrivia +
+
+
+
+
+
+ +

+ + + SByte sbyte + + +

+ +
+
+ Full Usage: + SByte sbyte +
+
+ Parameters: +
    + + + Item + + : + sbyte + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13y, 0xFFy, 0o077y, 0b0111101y +

+
+ +
+
+ + Item + + : + sbyte +
+
+
+
+
+
+ +

+ + + Single single + + +

+ +
+
+ Full Usage: + Single single +
+
+ Parameters: +
    + + + Item + + : + single + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 1.30f, 1.40e10f etc. +

+
+ +
+
+ + Item + + : + single +
+
+
+
+
+
+ +

+ + + SourceIdentifier(constant, value, range) + + +

+ +
+
+ Full Usage: + SourceIdentifier(constant, value, range) +
+
+ Parameters: +
    + + + constant + + : + string + +
    + + + value + + : + string + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Source Line, File, and Path Identifiers + Containing both the original value as the evaluated value. +

+
+ +
+
+ + constant + + : + string +
+
+
+ + value + + : + string +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + String(text, synStringKind, range) + + +

+ +
+
+ Full Usage: + String(text, synStringKind, range) +
+
+ Parameters: +
    + + + text + + : + string + +
    + + + synStringKind + + : + SynStringKind + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: verbatim or regular string, e.g. "abc" +

+
+ +
+
+ + text + + : + string +
+
+
+ + synStringKind + + : + SynStringKind +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + UInt16 uint16 + + +

+ +
+
+ Full Usage: + UInt16 uint16 +
+
+ Parameters: +
    + + + Item + + : + uint16 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13us, 0x4000us, 0o0777us, 0b0111101us +

+
+ +
+
+ + Item + + : + uint16 +
+
+
+
+
+
+ +

+ + + UInt16s uint16[] + + +

+ +
+
+ Full Usage: + UInt16s uint16[] +
+
+ Parameters: +
    + + + Item + + : + uint16[] + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Used internally in the typechecker once an array of unit16 constants + is detected, to allow more efficient processing of large arrays of uint16 constants. +

+
+ +
+
+ + Item + + : + uint16[] +
+
+
+
+
+
+ +

+ + + UInt32 uint32 + + +

+ +
+
+ Full Usage: + UInt32 uint32 +
+
+ Parameters: +
    + + + Item + + : + uint32 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13u, 0x4000u, 0o0777u +

+
+ +
+
+ + Item + + : + uint32 +
+
+
+
+
+
+ +

+ + + UInt64 uint64 + + +

+ +
+
+ Full Usage: + UInt64 uint64 +
+
+ Parameters: +
    + + + Item + + : + uint64 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13UL +

+
+ +
+
+ + Item + + : + uint64 +
+
+
+
+
+
+ +

+ + + UIntPtr uint64 + + +

+ +
+
+ Full Usage: + UIntPtr uint64 +
+
+ Parameters: +
    + + + Item + + : + uint64 + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 13un +

+
+ +
+
+ + Item + + : + uint64 +
+
+
+
+
+
+ +

+ + + Unit + + +

+ +
+
+ Full Usage: + Unit +
+
+
+
+
+ 		+
+ + + +

+ F# syntax: () +

+
+
+
+ +

+ + + UserNum(value, suffix) + + +

+ +
+
+ Full Usage: + UserNum(value, suffix) +
+
+ Parameters: +
    + + + value + + : + string + +
    + + + suffix + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ UserNum(value, suffix) + + F# syntax: 1Q, 1Z, 1R, 1N, 1G +

+
+ +
+
+ + value + + : + string +
+
+
+ + suffix + + : + string +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ Parameters: +
    + + + dflt + + : + range + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + dflt + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synenumcase.html b/reference/fsharp-compiler-syntax-synenumcase.html new file mode 100644 index 0000000000..d8e8141976 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synenumcase.html @@ -0,0 +1,754 @@ + + + + + + + + + + + + + + + + + + SynEnumCase (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynEnumCase Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for one case in an enum definition. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynEnumCase(attributes, ident, valueExpr, xmlDoc, range, trivia) + + +

+ +
+
+ Full Usage: + SynEnumCase(attributes, ident, valueExpr, xmlDoc, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + ident + + : + SynIdent +
+
+
+ + valueExpr + + : + SynExpr +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynEnumCaseTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synexceptiondefn.html b/reference/fsharp-compiler-syntax-synexceptiondefn.html new file mode 100644 index 0000000000..205cba5ae8 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synexceptiondefn.html @@ -0,0 +1,723 @@ + + + + + + + + + + + + + + + + + + SynExceptionDefn (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExceptionDefn Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the right hand side of an exception declaration 'exception E = ... ' plus + any member definitions for the exception +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynExceptionDefn(exnRepr, withKeyword, members, range) + + +

+ +
+
+ Full Usage: + SynExceptionDefn(exnRepr, withKeyword, members, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + exnRepr + + : + SynExceptionDefnRepr +
+
+
+ + withKeyword + + : + range option +
+
+
+ + members + + : + SynMemberDefns +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synexceptiondefnrepr.html b/reference/fsharp-compiler-syntax-synexceptiondefnrepr.html new file mode 100644 index 0000000000..a1c3cb7fa6 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synexceptiondefnrepr.html @@ -0,0 +1,754 @@ + + + + + + + + + + + + + + + + + + SynExceptionDefnRepr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExceptionDefnRepr Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the right hand side of an exception declaration 'exception E = ... ' +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynExceptionDefnRepr(attributes, caseName, longId, xmlDoc, accessibility, range) + + +

+ +
+
+ Full Usage: + SynExceptionDefnRepr(attributes, caseName, longId, xmlDoc, accessibility, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + caseName + + : + SynUnionCase +
+
+
+ + longId + + : + LongIdent option +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synexceptionsig.html b/reference/fsharp-compiler-syntax-synexceptionsig.html new file mode 100644 index 0000000000..3c45aa7068 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synexceptionsig.html @@ -0,0 +1,647 @@ + + + + + + + + + + + + + + + + + + SynExceptionSig (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExceptionSig Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the right hand side of an exception definition in a signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynExceptionSig(exnRepr, withKeyword, members, range) + + +

+ +
+
+ Full Usage: + SynExceptionSig(exnRepr, withKeyword, members, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + exnRepr + + : + SynExceptionDefnRepr +
+
+
+ + withKeyword + + : + range option +
+
+
+ + members + + : + SynMemberSig list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synexpr.html b/reference/fsharp-compiler-syntax-synexpr.html new file mode 100644 index 0000000000..a349e26f85 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synexpr.html @@ -0,0 +1,8314 @@ + + + + + + + + + + + + + + + + + + SynExpr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExpr Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntax tree for F# expressions +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AddressOf(isByref, expr, opRange, range) + + +

+ +
+
+ Full Usage: + AddressOf(isByref, expr, opRange, range) +
+
+ Parameters: +
    + + + isByref + + : + bool + +
    + + + expr + + : + SynExpr + +
    + + + opRange + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: &expr, &&expr +

+
+ +
+
+ + isByref + + : + bool +
+
+
+ + expr + + : + SynExpr +
+
+
+ + opRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + AnonRecd(isStruct, copyInfo, recordFields, range, trivia) + + +

+ +
+
+ Full Usage: + AnonRecd(isStruct, copyInfo, recordFields, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: {| id1=e1; ...; idN=eN |} + F# syntax: struct {| id1=e1; ...; idN=eN |} +

+
+ +
+
+ + isStruct + + : + bool +
+
+
+ + copyInfo + + : + (SynExpr * BlockSeparator) option +
+
+
+ + recordFields + + : + (SynLongIdent * range option * SynExpr) list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprAnonRecdTrivia +
+
+
+
+
+
+ +

+ + + App(flag, isInfix, funcExpr, argExpr, range) + + +

+ +
+
+ Full Usage: + App(flag, isInfix, funcExpr, argExpr, range) +
+
+ Parameters: +
    + + + flag + + : + ExprAtomicFlag + +
    + + + isInfix + + : + bool + +
    + + + funcExpr + + : + SynExpr + +
    + + + argExpr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: f x + + flag: indicates if the application is syntactically atomic, e.g. f.[1] is atomic, but 'f x' is not + isInfix is true for the first app of an infix operator, e.g. 1+2 + becomes App(App(+, 1), 2), where the inner node is marked isInfix +

+
+ +
+
+ + flag + + : + ExprAtomicFlag +
+
+
+ + isInfix + + : + bool +
+
+
+ + funcExpr + + : + SynExpr +
+
+
+ + argExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ArbitraryAfterError(debugStr, range) + + +

+ +
+
+ Full Usage: + ArbitraryAfterError(debugStr, range) +
+
+ Parameters: +
    + + + debugStr + + : + string + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Inserted for error recovery +

+
+ +
+
+ + debugStr + + : + string +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ArrayOrList(isArray, exprs, range) + + +

+ +
+
+ Full Usage: + ArrayOrList(isArray, exprs, range) +
+
+ Parameters: +
    + + + isArray + + : + bool + +
    + + + exprs + + : + SynExpr list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: [ e1; ...; en ], [| e1; ...; en |] +

+
+ +
+
+ + isArray + + : + bool +
+
+
+ + exprs + + : + SynExpr list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ArrayOrListComputed(isArray, expr, range) + + +

+ +
+
+ Full Usage: + ArrayOrListComputed(isArray, expr, range) +
+
+ Parameters: +
    + + + isArray + + : + bool + +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: [ expr ], [| expr |] +

+
+ +
+
+ + isArray + + : + bool +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Assert(expr, range) + + +

+ +
+
+ Full Usage: + Assert(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: assert expr +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ComputationExpr(hasSeqBuilder, expr, range) + + +

+ +
+
+ Full Usage: + ComputationExpr(hasSeqBuilder, expr, range) +
+
+ Parameters: +
    + + + hasSeqBuilder + + : + bool + +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: { expr } +

+
+ +
+
+ + hasSeqBuilder + + : + bool +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Const(constant, range) + + +

+ +
+
+ Full Usage: + Const(constant, range) +
+
+ Parameters: +
    + + + constant + + : + SynConst + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 1, 1.3, () etc. +

+
+ +
+
+ + constant + + : + SynConst +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DebugPoint(debugPoint, isControlFlow, innerExpr) + + +

+ +
+
+ Full Usage: + DebugPoint(debugPoint, isControlFlow, innerExpr) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Debug points arising from computation expressions +

+
+ +
+
+ + debugPoint + + : + DebugPointAtLeafExpr +
+
+
+ + isControlFlow + + : + bool +
+
+
+ + innerExpr + + : + SynExpr +
+
+
+
+
+
+ +

+ + + DiscardAfterMissingQualificationAfterDot(expr, dotRange, range) + + +

+ +
+
+ Full Usage: + DiscardAfterMissingQualificationAfterDot(expr, dotRange, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + dotRange + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Inserted for error recovery when there is "expr." and missing tokens or error recovery after the dot +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + dotRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Do(expr, range) + + +

+ +
+
+ Full Usage: + Do(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: do expr +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DoBang(expr, range) + + +

+ +
+
+ Full Usage: + DoBang(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: do! expr + Computation expressions only +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DotGet(expr, rangeOfDot, longDotId, range) + + +

+ +
+
+ Full Usage: + DotGet(expr, rangeOfDot, longDotId, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr.ident.ident +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + rangeOfDot + + : + range +
+
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DotIndexedGet(objectExpr, indexArgs, dotRange, range) + + +

+ +
+
+ Full Usage: + DotIndexedGet(objectExpr, indexArgs, dotRange, range) +
+
+ Parameters: +
    + + + objectExpr + + : + SynExpr + +
    + + + indexArgs + + : + SynExpr + +
    + + + dotRange + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr.[expr, ..., expr] +

+
+ +
+
+ + objectExpr + + : + SynExpr +
+
+
+ + indexArgs + + : + SynExpr +
+
+
+ + dotRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DotIndexedSet(objectExpr, indexArgs, valueExpr, leftOfSetRange, dotRange, range) + + +

+ +
+
+ Full Usage: + DotIndexedSet(objectExpr, indexArgs, valueExpr, leftOfSetRange, dotRange, range) +
+
+ Parameters: +
    + + + objectExpr + + : + SynExpr + +
    + + + indexArgs + + : + SynExpr + +
    + + + valueExpr + + : + SynExpr + +
    + + + leftOfSetRange + + : + range + +
    + + + dotRange + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr.[expr, ..., expr] <- expr +

+
+ +
+
+ + objectExpr + + : + SynExpr +
+
+
+ + indexArgs + + : + SynExpr +
+
+
+ + valueExpr + + : + SynExpr +
+
+
+ + leftOfSetRange + + : + range +
+
+
+ + dotRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DotLambda(expr, range, trivia) + + +

+ +
+
+ Full Usage: + DotLambda(expr, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: _.ident.ident +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprDotLambdaTrivia +
+
+
+
+
+
+ +

+ + + DotNamedIndexedPropertySet(targetExpr, longDotId, argExpr, rhsExpr, range) + + +

+ +
+
+ Full Usage: + DotNamedIndexedPropertySet(targetExpr, longDotId, argExpr, rhsExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr.Items (e1) <- e2, rarely used named-property-setter notation, e.g. (stringExpr).Chars(3) <- 'a' +

+
+ +
+
+ + targetExpr + + : + SynExpr +
+
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + argExpr + + : + SynExpr +
+
+
+ + rhsExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + DotSet(targetExpr, longDotId, rhsExpr, range) + + +

+ +
+
+ Full Usage: + DotSet(targetExpr, longDotId, rhsExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr.ident...ident <- expr +

+
+ +
+
+ + targetExpr + + : + SynExpr +
+
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + rhsExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Downcast(expr, targetType, range) + + +

+ +
+
+ Full Usage: + Downcast(expr, targetType, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + targetType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr :?> type +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + targetType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Dynamic(funcExpr, qmark, argExpr, range) + + +

+ +
+
+ Full Usage: + Dynamic(funcExpr, qmark, argExpr, range) +
+
+ Parameters: +
    + + + funcExpr + + : + SynExpr + +
    + + + qmark + + : + range + +
    + + + argExpr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: f?x +

+
+ +
+
+ + funcExpr + + : + SynExpr +
+
+
+ + qmark + + : + range +
+
+
+ + argExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Fixed(expr, range) + + +

+ +
+
+ Full Usage: + Fixed(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ 'use x = fixed expr' +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + For(forDebugPoint, toDebugPoint, ident, equalsRange, identBody, direction, toBody, doBody, range) + + +

+ +
+
+ Full Usage: + For(forDebugPoint, toDebugPoint, ident, equalsRange, identBody, direction, toBody, doBody, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'for i = ... to ... do ...' +

+
+ +
+
+ + forDebugPoint + + : + DebugPointAtFor +
+
+
+ + toDebugPoint + + : + DebugPointAtInOrTo +
+
+
+ + ident + + : + Ident +
+
+
+ + equalsRange + + : + range option +
+
+
+ + identBody + + : + SynExpr +
+
+
+ + direction + + : + bool +
+
+
+ + toBody + + : + SynExpr +
+
+
+ + doBody + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ForEach(forDebugPoint, inDebugPoint, seqExprOnly, isFromSource, pat, enumExpr, bodyExpr, range) + + +

+ +
+
+ Full Usage: + ForEach(forDebugPoint, inDebugPoint, seqExprOnly, isFromSource, pat, enumExpr, bodyExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'for ... in ... do ...' +

+
+ +
+
+ + forDebugPoint + + : + DebugPointAtFor +
+
+
+ + inDebugPoint + + : + DebugPointAtInOrTo +
+
+
+ + seqExprOnly + + : + SeqExprOnly +
+
+
+ + isFromSource + + : + bool +
+
+
+ + pat + + : + SynPat +
+
+
+ + enumExpr + + : + SynExpr +
+
+
+ + bodyExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + FromParseError(expr, range) + + +

+ +
+
+ Full Usage: + FromParseError(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Inserted for error recovery +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Ident ident + + +

+ +
+
+ Full Usage: + Ident ident +
+
+ Parameters: +
    + + + ident + + : + Ident + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ident + Optimized representation for SynExpr.LongIdent (false, [id], id.idRange) +

+
+ +
+
+ + ident + + : + Ident +
+
+
+
+
+
+ +

+ + + IfThenElse(ifExpr, thenExpr, elseExpr, spIfToThen, isFromErrorRecovery, range, trivia) + + +

+ +
+
+ Full Usage: + IfThenElse(ifExpr, thenExpr, elseExpr, spIfToThen, isFromErrorRecovery, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: if expr then expr + F# syntax: if expr then expr else expr +

+
+ +
+
+ + ifExpr + + : + SynExpr +
+
+
+ + thenExpr + + : + SynExpr +
+
+
+ + elseExpr + + : + SynExpr option +
+
+
+ + spIfToThen + + : + DebugPointAtBinding +
+
+
+ + isFromErrorRecovery + + : + bool +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprIfThenElseTrivia +
+
+
+
+
+
+ +

+ + + ImplicitZero range + + +

+ +
+
+ Full Usage: + ImplicitZero range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Used in parser error recovery and internally during type checking for translating computation expressions. +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + IndexFromEnd(expr, range) + + +

+ +
+
+ Full Usage: + IndexFromEnd(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ^expr, used for from-end-of-collection indexing and ^T.Operation +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + IndexRange(expr1, opm, expr2, range1, range2, range) + + +

+ +
+
+ Full Usage: + IndexRange(expr1, opm, expr2, range1, range2, range) +
+
+ Parameters: +
    + + + expr1 + + : + SynExpr option + +
    + + + opm + + : + range + +
    + + + expr2 + + : + SynExpr option + +
    + + + range1 + + : + range + +
    + + + range2 + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr.. + F# syntax: ..expr + F# syntax: expr..expr + F# syntax: * + A two-element range indexer argument a..b, a.., ..b. Also used to represent + a range in a list, array or sequence expression. +

+
+ +
+
+ + expr1 + + : + SynExpr option +
+
+
+ + opm + + : + range +
+
+
+ + expr2 + + : + SynExpr option +
+
+
+ + range1 + + : + range +
+
+
+ + range2 + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + InferredDowncast(expr, range) + + +

+ +
+
+ Full Usage: + InferredDowncast(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: downcast expr +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + InferredUpcast(expr, range) + + +

+ +
+
+ Full Usage: + InferredUpcast(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: upcast expr +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + InterpolatedString(contents, synStringKind, range) + + +

+ +
+
+ Full Usage: + InterpolatedString(contents, synStringKind, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: interpolated string, e.g. "abc{x}" or "abc{x,3}" or "abc{x:N4}" + Note the string ranges include the quotes, verbatim markers, dollar sign and braces +

+
+ +
+
+ + contents + + : + SynInterpolatedStringPart list +
+
+
+ + synStringKind + + : + SynStringKind +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + JoinIn(lhsExpr, lhsRange, rhsExpr, range) + + +

+ +
+
+ Full Usage: + JoinIn(lhsExpr, lhsRange, rhsExpr, range) +
+
+ Parameters: +
    + + + lhsExpr + + : + SynExpr + +
    + + + lhsRange + + : + range + +
    + + + rhsExpr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ... in ... + Computation expressions only, based on JOIN_IN token from lex filter +

+
+ +
+
+ + lhsExpr + + : + SynExpr +
+
+
+ + lhsRange + + : + range +
+
+
+ + rhsExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Lambda(fromMethod, inLambdaSeq, args, body, parsedData, range, trivia) + + +

+ +
+
+ Full Usage: + Lambda(fromMethod, inLambdaSeq, args, body, parsedData, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ First bool indicates if lambda originates from a method. Patterns here are always "simple" + Second bool indicates if this is a "later" part of an iterated sequence of lambdas + parsedData keeps original parsed patterns and expression, + prior to transforming to "simple" patterns and iterated lambdas + + F# syntax: fun pat -> expr +

+
+ +
+
+ + fromMethod + + : + bool +
+
+
+ + inLambdaSeq + + : + bool +
+
+
+ + args + + : + SynSimplePats +
+
+
+ + body + + : + SynExpr +
+
+
+ + parsedData + + : + (SynPat list * SynExpr) option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprLambdaTrivia +
+
+
+
+
+
+ +

+ + + Lazy(expr, range) + + +

+ +
+
+ Full Usage: + Lazy(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: lazy expr +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LetOrUse(isRecursive, isUse, bindings, body, range, trivia) + + +

+ +
+
+ Full Usage: + LetOrUse(isRecursive, isUse, bindings, body, range, trivia) +
+
+ Parameters: +
    + + + isRecursive + + : + bool + +
    + + + isUse + + : + bool + +
    + + + bindings + + : + SynBinding list + +
    + + + body + + : + SynExpr + +
    + + + range + + : + range + +
    + + + trivia + + : + SynExprLetOrUseTrivia + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: let pat = expr in expr + F# syntax: let f pat1 .. patN = expr in expr + F# syntax: let rec f pat1 .. patN = expr in expr + F# syntax: use pat = expr in expr +

+
+ +
+
+ + isRecursive + + : + bool +
+
+
+ + isUse + + : + bool +
+
+
+ + bindings + + : + SynBinding list +
+
+
+ + body + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprLetOrUseTrivia +
+
+
+
+
+
+ +

+ + + LetOrUseBang(bindDebugPoint, isUse, isFromSource, pat, rhs, andBangs, body, range, trivia) + + +

+ +
+
+ Full Usage: + LetOrUseBang(bindDebugPoint, isUse, isFromSource, pat, rhs, andBangs, body, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: let! pat = expr in expr + F# syntax: use! pat = expr in expr + F# syntax: let! pat = expr and! ... and! ... and! pat = expr in expr + Computation expressions only +

+
+ +
+
+ + bindDebugPoint + + : + DebugPointAtBinding +
+
+
+ + isUse + + : + bool +
+
+
+ + isFromSource + + : + bool +
+
+
+ + pat + + : + SynPat +
+
+
+ + rhs + + : + SynExpr +
+
+
+ + andBangs + + : + SynExprAndBang list +
+
+
+ + body + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprLetOrUseBangTrivia +
+
+
+
+
+
+ +

+ + + LibraryOnlyILAssembly(ilCode, typeArgs, args, retTy, range) + + +

+ +
+
+ Full Usage: + LibraryOnlyILAssembly(ilCode, typeArgs, args, retTy, range) +
+
+ Parameters: +
    + + + ilCode + + : + obj + +
    + + + typeArgs + + : + SynType list + +
    + + + args + + : + SynExpr list + +
    + + + retTy + + : + SynType list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Only used in FSharp.Core +

+
+ +
+
+ + ilCode + + : + obj +
+
+
+ + typeArgs + + : + SynType list +
+
+
+ + args + + : + SynExpr list +
+
+
+ + retTy + + : + SynType list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LibraryOnlyStaticOptimization(constraints, expr, optimizedExpr, range) + + +

+ +
+
+ Full Usage: + LibraryOnlyStaticOptimization(constraints, expr, optimizedExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Only used in FSharp.Core +

+
+ +
+
+ + constraints + + : + SynStaticOptimizationConstraint list +
+
+
+ + expr + + : + SynExpr +
+
+
+ + optimizedExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LibraryOnlyUnionCaseFieldGet(expr, longId, fieldNum, range) + + +

+ +
+
+ Full Usage: + LibraryOnlyUnionCaseFieldGet(expr, longId, fieldNum, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + longId + + : + LongIdent + +
    + + + fieldNum + + : + int + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Only used in FSharp.Core +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + longId + + : + LongIdent +
+
+
+ + fieldNum + + : + int +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LibraryOnlyUnionCaseFieldSet(expr, longId, fieldNum, rhsExpr, range) + + +

+ +
+
+ Full Usage: + LibraryOnlyUnionCaseFieldSet(expr, longId, fieldNum, rhsExpr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + longId + + : + LongIdent + +
    + + + fieldNum + + : + int + +
    + + + rhsExpr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Only used in FSharp.Core +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + longId + + : + LongIdent +
+
+
+ + fieldNum + + : + int +
+
+
+ + rhsExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LongIdent(isOptional, longDotId, altNameRefCell, range) + + +

+ +
+
+ Full Usage: + LongIdent(isOptional, longDotId, altNameRefCell, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ident.ident...ident + + isOptional: true if preceded by a '?' for an optional named parameter + altNameRefCell: Normally 'None' except for some compiler-generated + variables in desugaring pattern matching. See SynSimplePat.Id +

+
+ +
+
+ + isOptional + + : + bool +
+
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + altNameRefCell + + : + SynSimplePatAlternativeIdInfo ref option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LongIdentSet(longDotId, expr, range) + + +

+ +
+
+ Full Usage: + LongIdentSet(longDotId, expr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ident.ident...ident <- expr +

+
+ +
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Match(matchDebugPoint, expr, clauses, range, trivia) + + +

+ +
+
+ Full Usage: + Match(matchDebugPoint, expr, clauses, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: match expr with pat1 -> expr | ... | patN -> exprN +

+
+ +
+
+ + matchDebugPoint + + : + DebugPointAtBinding +
+
+
+ + expr + + : + SynExpr +
+
+
+ + clauses + + : + SynMatchClause list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprMatchTrivia +
+
+
+
+
+
+ +

+ + + MatchBang(matchDebugPoint, expr, clauses, range, trivia) + + +

+ +
+
+ Full Usage: + MatchBang(matchDebugPoint, expr, clauses, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: match! expr with pat1 -> expr | ... | patN -> exprN +

+
+ +
+
+ + matchDebugPoint + + : + DebugPointAtBinding +
+
+
+ + expr + + : + SynExpr +
+
+
+ + clauses + + : + SynMatchClause list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprMatchBangTrivia +
+
+
+
+
+
+ +

+ + + MatchLambda(isExnMatch, keywordRange, matchClauses, matchDebugPoint, range) + + +

+ +
+
+ Full Usage: + MatchLambda(isExnMatch, keywordRange, matchClauses, matchDebugPoint, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: function pat1 -> expr | ... | patN -> exprN +

+
+ +
+
+ + isExnMatch + + : + bool +
+
+
+ + keywordRange + + : + range +
+
+
+ + matchClauses + + : + SynMatchClause list +
+
+
+ + matchDebugPoint + + : + DebugPointAtBinding +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + NamedIndexedPropertySet(longDotId, expr1, expr2, range) + + +

+ +
+
+ Full Usage: + NamedIndexedPropertySet(longDotId, expr1, expr2, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: Type.Items(e1) <- e2, rarely used named-property-setter notation, e.g. Foo.Bar.Chars(3) <- 'a' +

+
+ +
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + expr1 + + : + SynExpr +
+
+
+ + expr2 + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + New(isProtected, targetType, expr, range) + + +

+ +
+
+ Full Usage: + New(isProtected, targetType, expr, range) +
+
+ Parameters: +
    + + + isProtected + + : + bool + +
    + + + targetType + + : + SynType + +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: new C(...) + The flag is true if known to be 'family' ('protected') scope +

+
+ +
+
+ + isProtected + + : + bool +
+
+
+ + targetType + + : + SynType +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Null range + + +

+ +
+
+ Full Usage: + Null range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: null +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ObjExpr(objType, argOptions, withKeyword, bindings, members, extraImpls, newExprRange, range) + + +

+ +
+
+ Full Usage: + ObjExpr(objType, argOptions, withKeyword, bindings, members, extraImpls, newExprRange, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: { new ... with ... } +

+
+ +
+
+ + objType + + : + SynType +
+
+
+ + argOptions + + : + (SynExpr * Ident option) option +
+
+
+ + withKeyword + + : + range option +
+
+
+ + bindings + + : + SynBinding list +
+
+
+ + members + + : + SynMemberDefns +
+
+
+ + extraImpls + + : + SynInterfaceImpl list +
+
+
+ + newExprRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Paren(expr, leftParenRange, rightParenRange, range) + + +

+ +
+
+ Full Usage: + Paren(expr, leftParenRange, rightParenRange, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + leftParenRange + + : + range + +
    + + + rightParenRange + + : + range option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: (expr) + + Parenthesized expressions. Kept in AST to distinguish A.M((x, y)) + from A.M(x, y), among other things. +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + leftParenRange + + : + range +
+
+
+ + rightParenRange + + : + range option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Quote(operator, isRaw, quotedExpr, isFromQueryExpression, range) + + +

+ +
+
+ Full Usage: + Quote(operator, isRaw, quotedExpr, isFromQueryExpression, range) +
+
+ Parameters: +
    + + + operator + + : + SynExpr + +
    + + + isRaw + + : + bool + +
    + + + quotedExpr + + : + SynExpr + +
    + + + isFromQueryExpression + + : + bool + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: <@ expr @>, <@@ expr @@> + + Quote(operator, isRaw, quotedSynExpr, isFromQueryExpression, m) +

+
+ +
+
+ + operator + + : + SynExpr +
+
+
+ + isRaw + + : + bool +
+
+
+ + quotedExpr + + : + SynExpr +
+
+
+ + isFromQueryExpression + + : + bool +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Record(baseInfo, copyInfo, recordFields, range) + + +

+ +
+
+ Full Usage: + Record(baseInfo, copyInfo, recordFields, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: { f1=e1; ...; fn=en } + inherit includes location of separator (for tooling) + copyOpt contains range of the following WITH part (for tooling) + every field includes range of separator after the field (for tooling) +

+
+ +
+
+ + baseInfo + + : + (SynType * SynExpr * range * BlockSeparator option * range) option +
+
+
+ + copyInfo + + : + (SynExpr * BlockSeparator) option +
+
+
+ + recordFields + + : + SynExprRecordField list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Sequential(debugPoint, isTrueSeq, expr1, expr2, range) + + +

+ +
+
+ Full Usage: + Sequential(debugPoint, isTrueSeq, expr1, expr2, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + + 
 F# syntax: expr; expr
+
+  isTrueSeq: false indicates "let v = a in b; v"
+
+ +
+
+ + debugPoint + + : + DebugPointAtSequential +
+
+
+ + isTrueSeq + + : + bool +
+
+
+ + expr1 + + : + SynExpr +
+
+
+ + expr2 + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + SequentialOrImplicitYield(debugPoint, expr1, expr2, ifNotStmt, range) + + +

+ +
+
+ Full Usage: + SequentialOrImplicitYield(debugPoint, expr1, expr2, ifNotStmt, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Used internally during type checking for translating computation expressions. +

+
+ +
+
+ + debugPoint + + : + DebugPointAtSequential +
+
+
+ + expr1 + + : + SynExpr +
+
+
+ + expr2 + + : + SynExpr +
+
+
+ + ifNotStmt + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Set(targetExpr, rhsExpr, range) + + +

+ +
+
+ Full Usage: + Set(targetExpr, rhsExpr, range) +
+
+ Parameters: +
    + + + targetExpr + + : + SynExpr + +
    + + + rhsExpr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr <- expr +

+
+ +
+
+ + targetExpr + + : + SynExpr +
+
+
+ + rhsExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + TraitCall(supportTys, traitSig, argExpr, range) + + +

+ +
+
+ Full Usage: + TraitCall(supportTys, traitSig, argExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ((type1 or ... or typeN): (member-dig) expr) +

+
+ +
+
+ + supportTys + + : + SynType +
+
+
+ + traitSig + + : + SynMemberSig +
+
+
+ + argExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + TryFinally(tryExpr, finallyExpr, range, tryDebugPoint, finallyDebugPoint, trivia) + + +

+ +
+
+ Full Usage: + TryFinally(tryExpr, finallyExpr, range, tryDebugPoint, finallyDebugPoint, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: try expr finally expr +

+
+ +
+
+ + tryExpr + + : + SynExpr +
+
+
+ + finallyExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + tryDebugPoint + + : + DebugPointAtTry +
+
+
+ + finallyDebugPoint + + : + DebugPointAtFinally +
+
+
+ + trivia + + : + SynExprTryFinallyTrivia +
+
+
+
+
+
+ +

+ + + TryWith(tryExpr, withCases, range, tryDebugPoint, withDebugPoint, trivia) + + +

+ +
+
+ Full Usage: + TryWith(tryExpr, withCases, range, tryDebugPoint, withDebugPoint, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: try expr with pat -> expr +

+
+ +
+
+ + tryExpr + + : + SynExpr +
+
+
+ + withCases + + : + SynMatchClause list +
+
+
+ + range + + : + range +
+
+
+ + tryDebugPoint + + : + DebugPointAtTry +
+
+
+ + withDebugPoint + + : + DebugPointAtWith +
+
+
+ + trivia + + : + SynExprTryWithTrivia +
+
+
+
+
+
+ +

+ + + Tuple(isStruct, exprs, commaRanges, range) + + +

+ +
+
+ Full Usage: + Tuple(isStruct, exprs, commaRanges, range) +
+
+ Parameters: +
    + + + isStruct + + : + bool + +
    + + + exprs + + : + SynExpr list + +
    + + + commaRanges + + : + range list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: e1, ..., eN +

+
+ +
+
+ + isStruct + + : + bool +
+
+
+ + exprs + + : + SynExpr list +
+
+
+ + commaRanges + + : + range list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Typar(typar, range) + + +

+ +
+
+ Full Usage: + Typar(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'T (for 'T.ident). +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + TypeApp(expr, lessRange, typeArgs, commaRanges, greaterRange, typeArgsRange, range) + + +

+ +
+
+ Full Usage: + TypeApp(expr, lessRange, typeArgs, commaRanges, greaterRange, typeArgsRange, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + lessRange + + : + range + +
    + + + typeArgs + + : + SynType list + +
    + + + commaRanges + + : + range list + +
    + + + greaterRange + + : + range option + +
    + + + typeArgsRange + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + lessRange + + : + range +
+
+
+ + typeArgs + + : + SynType list +
+
+
+ + commaRanges + + : + range list +
+
+
+ + greaterRange + + : + range option +
+
+
+ + typeArgsRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + TypeTest(expr, targetType, range) + + +

+ +
+
+ Full Usage: + TypeTest(expr, targetType, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + targetType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr :? type +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + targetType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Typed(expr, targetType, range) + + +

+ +
+
+ Full Usage: + Typed(expr, targetType, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + targetType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr: type +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + targetType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Upcast(expr, targetType, range) + + +

+ +
+
+ Full Usage: + Upcast(expr, targetType, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + targetType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: expr :> type +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + targetType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + While(whileDebugPoint, whileExpr, doExpr, range) + + +

+ +
+
+ Full Usage: + While(whileDebugPoint, whileExpr, doExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'while ... do ...' +

+
+ +
+
+ + whileDebugPoint + + : + DebugPointAtWhile +
+
+
+ + whileExpr + + : + SynExpr +
+
+
+ + doExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhileBang(whileDebugPoint, whileExpr, doExpr, range) + + +

+ +
+
+ Full Usage: + WhileBang(whileDebugPoint, whileExpr, doExpr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'while! ... do ...' +

+
+ +
+
+ + whileDebugPoint + + : + DebugPointAtWhile +
+
+
+ + whileExpr + + : + SynExpr +
+
+
+ + doExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + YieldOrReturn(flags, expr, range) + + +

+ +
+
+ Full Usage: + YieldOrReturn(flags, expr, range) +
+
+ Parameters: +
    + + + flags + + : + bool * bool + +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: yield expr + F# syntax: return expr + Computation expressions only +

+
+ +
+
+ + flags + + : + bool * bool +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + YieldOrReturnFrom(flags, expr, range) + + +

+ +
+
+ Full Usage: + YieldOrReturnFrom(flags, expr, range) +
+
+ Parameters: +
    + + + flags + + : + bool * bool + +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: yield! expr + F# syntax: return! expr + Computation expressions only +

+
+ +
+
+ + flags + + : + bool * bool +
+
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsArbExprAndThusAlreadyReportedError + + +

+ +
+
+ Full Usage: + this.IsArbExprAndThusAlreadyReportedError +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this expression arises from error recovery +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.RangeOfFirstPortion + + +

+ +
+
+ Full Usage: + this.RangeOfFirstPortion +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Attempt to get the range of the first token or initial portion only - this + is ad-hoc, just a cheap way to improve a certain 'query custom operation' error range +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.RangeWithoutAnyExtraDot + + +

+ +
+
+ Full Usage: + this.RangeWithoutAnyExtraDot +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synexprandbang.html b/reference/fsharp-compiler-syntax-synexprandbang.html new file mode 100644 index 0000000000..0e287e175f --- /dev/null +++ b/reference/fsharp-compiler-syntax-synexprandbang.html @@ -0,0 +1,695 @@ + + + + + + + + + + + + + + + + + + SynExprAndBang (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprAndBang Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynExprAndBang(debugPoint, isUse, isFromSource, pat, body, range, trivia) + + +

+ +
+
+ Full Usage: + SynExprAndBang(debugPoint, isUse, isFromSource, pat, body, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + debugPoint + + : + DebugPointAtBinding +
+
+
+ + isUse + + : + bool +
+
+
+ + isFromSource + + : + bool +
+
+
+ + pat + + : + SynPat +
+
+
+ + body + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynExprAndBangTrivia +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synexprrecordfield.html b/reference/fsharp-compiler-syntax-synexprrecordfield.html new file mode 100644 index 0000000000..03decfa60c --- /dev/null +++ b/reference/fsharp-compiler-syntax-synexprrecordfield.html @@ -0,0 +1,647 @@ + + + + + + + + + + + + + + + + + + SynExprRecordField (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprRecordField Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynExprRecordField(fieldName, equalsRange, expr, blockSeparator) + + +

+ +
+
+ Full Usage: + SynExprRecordField(fieldName, equalsRange, expr, blockSeparator) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + fieldName + + : + RecordFieldName +
+
+
+ + equalsRange + + : + range option +
+
+
+ + expr + + : + SynExpr option +
+
+
+ + blockSeparator + + : + BlockSeparator option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synfield.html b/reference/fsharp-compiler-syntax-synfield.html new file mode 100644 index 0000000000..bdad8f2320 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synfield.html @@ -0,0 +1,802 @@ + + + + + + + + + + + + + + + + + + SynField (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynField Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for a field declaration in a record or class +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynField(attributes, isStatic, idOpt, fieldType, isMutable, xmlDoc, accessibility, range, trivia) + + +

+ +
+
+ Full Usage: + SynField(attributes, isStatic, idOpt, fieldType, isMutable, xmlDoc, accessibility, range, trivia) +
+
+ Parameters: +
    + + + attributes + + : + SynAttributes + +
    + + + isStatic + + : + bool + +
    + + + idOpt + + : + Ident option + +
    + + + fieldType + + : + SynType + +
    + + + isMutable + + : + bool + +
    + + + xmlDoc + + : + PreXmlDoc + +
    + + + accessibility + + : + SynAccess option + +
    + + + range + + : + range + +
    + + + trivia + + : + SynFieldTrivia + +
    +
+
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + isStatic + + : + bool +
+
+
+ + idOpt + + : + Ident option +
+
+
+ + fieldType + + : + SynType +
+
+
+ + isMutable + + : + bool +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynFieldTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synident.html b/reference/fsharp-compiler-syntax-synident.html new file mode 100644 index 0000000000..5c56a220b3 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synident.html @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + SynIdent (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynIdent Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an identifier with potentially additional trivia information. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynIdent(ident, trivia) + + +

+ +
+
+ Full Usage: + SynIdent(ident, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + ident + + : + Ident +
+
+
+ + trivia + + : + IdentTrivia option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syninterfaceimpl.html b/reference/fsharp-compiler-syntax-syninterfaceimpl.html new file mode 100644 index 0000000000..d2dfd1e941 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syninterfaceimpl.html @@ -0,0 +1,663 @@ + + + + + + + + + + + + + + + + + + SynInterfaceImpl (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynInterfaceImpl Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a set of bindings that implement an interface +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynInterfaceImpl(interfaceTy, withKeyword, bindings, members, range) + + +

+ +
+
+ Full Usage: + SynInterfaceImpl(interfaceTy, withKeyword, bindings, members, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + interfaceTy + + : + SynType +
+
+
+ + withKeyword + + : + range option +
+
+
+ + bindings + + : + SynBinding list +
+
+
+ + members + + : + SynMemberDefns +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syninterpolatedstringpart.html b/reference/fsharp-compiler-syntax-syninterpolatedstringpart.html new file mode 100644 index 0000000000..b5e0e7b34f --- /dev/null +++ b/reference/fsharp-compiler-syntax-syninterpolatedstringpart.html @@ -0,0 +1,678 @@ + + + + + + + + + + + + + + + + + + SynInterpolatedStringPart (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynInterpolatedStringPart Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + FillExpr(fillExpr, qualifiers) + + +

+ +
+
+ Full Usage: + FillExpr(fillExpr, qualifiers) +
+
+ Parameters: +
    + + + fillExpr + + : + SynExpr + +
    + + + qualifiers + + : + Ident option + +
    +
+
+
+
+
+ 		+
+
+ + fillExpr + + : + SynExpr +
+
+
+ + qualifiers + + : + Ident option +
+
+
+
+
+ +

+ + + String(value, range) + + +

+ +
+
+ Full Usage: + String(value, range) +
+
+ Parameters: +
    + + + value + + : + string + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + value + + : + string +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synlongident.html b/reference/fsharp-compiler-syntax-synlongident.html new file mode 100644 index 0000000000..0c97df8228 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synlongident.html @@ -0,0 +1,1054 @@ + + + + + + + + + + + + + + + + + + SynLongIdent (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynLongIdent Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a long identifier with possible '.' at end. + + Typically dotRanges.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. "Foo.Bar." + The dots mostly matter for parsing, and are typically ignored by the typechecker, but + if dotRanges.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed + more freedom about typechecking these expressions. + LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit) +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynLongIdent(id, dotRanges, trivia) + + +

+ +
+
+ Full Usage: + SynLongIdent(id, dotRanges, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + id + + : + LongIdent +
+
+
+ + dotRanges + + : + range list +
+
+
+ + trivia + + : + IdentTrivia option list +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Dots + + +

+ +
+
+ Full Usage: + this.Dots +
+
+ + Returns: + range list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the dot ranges +

+
+ +
+
+ + Returns: + + range list +
+
+
+
+
+
+ +

+ + + this.IdentsWithTrivia + + +

+ +
+
+ Full Usage: + this.IdentsWithTrivia +
+
+ + Returns: + SynIdent list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the idents with potential trivia attached +

+
+ +
+
+ + Returns: + + SynIdent list +
+
+
+
+
+
+ +

+ + + this.LongIdent + + +

+ +
+
+ Full Usage: + this.LongIdent +
+
+ + Returns: + LongIdent + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the long ident for this construct +

+
+ +
+
+ + Returns: + + LongIdent +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.RangeWithoutAnyExtraDot + + +

+ +
+
+ Full Usage: + this.RangeWithoutAnyExtraDot +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range for part of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.ThereIsAnExtraDotAtTheEnd + + +

+ +
+
+ Full Usage: + this.ThereIsAnExtraDotAtTheEnd +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the construct ends in '.' due to error recovery +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Trivia + + +

+ +
+
+ Full Usage: + this.Trivia +
+
+ + Returns: + IdentTrivia list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the trivia of the idents +

+
+ +
+
+ + Returns: + + IdentTrivia list +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synlongidenthelpers.html b/reference/fsharp-compiler-syntax-synlongidenthelpers.html new file mode 100644 index 0000000000..8f964d2c08 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synlongidenthelpers.html @@ -0,0 +1,521 @@ + + + + + + + + + + + + + + + + + + SynLongIdentHelpers (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynLongIdentHelpers Module +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmatchclause.html b/reference/fsharp-compiler-syntax-synmatchclause.html new file mode 100644 index 0000000000..5f4c0779cc --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmatchclause.html @@ -0,0 +1,811 @@ + + + + + + + + + + + + + + + + + + SynMatchClause (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMatchClause Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a clause in a 'match' expression +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynMatchClause(pat, whenExpr, resultExpr, range, debugPoint, trivia) + + +

+ +
+
+ Full Usage: + SynMatchClause(pat, whenExpr, resultExpr, range, debugPoint, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + pat + + : + SynPat +
+
+
+ + whenExpr + + : + SynExpr option +
+
+
+ + resultExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + debugPoint + + : + DebugPointAtTarget +
+
+
+ + trivia + + : + SynMatchClauseTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.RangeOfGuardAndRhs + + +

+ +
+
+ Full Usage: + this.RangeOfGuardAndRhs +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of part of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmeasure.html b/reference/fsharp-compiler-syntax-synmeasure.html new file mode 100644 index 0000000000..8671e57985 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmeasure.html @@ -0,0 +1,1291 @@ + + + + + + + + + + + + + + + + + + SynMeasure (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMeasure Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an unchecked syntax tree of F# unit of measure annotations. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Anon range + + +

+ +
+
+ Full Usage: + Anon range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An anonymous (inferred) unit of measure +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Divide(measure1, mSlash, measure2, range) + + +

+ +
+
+ Full Usage: + Divide(measure1, mSlash, measure2, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A division of two units of measure, e.g. 'kg / m' +

+
+ +
+
+ + measure1 + + : + SynMeasure option +
+
+
+ + mSlash + + : + range +
+
+
+ + measure2 + + : + SynMeasure +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Named(longId, range) + + +

+ +
+
+ Full Usage: + Named(longId, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A named unit of measure +

+
+ +
+
+ + longId + + : + LongIdent +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + One range + + +

+ +
+
+ Full Usage: + One range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ The '1' unit of measure +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Paren(measure, range) + + +

+ +
+
+ Full Usage: + Paren(measure, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A parenthesized measure +

+
+ +
+
+ + measure + + : + SynMeasure +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Power(measure, caretRange, power, range) + + +

+ +
+
+ Full Usage: + Power(measure, caretRange, power, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A power of a unit of measure, e.g. 'kg ^ 2' +

+
+ +
+
+ + measure + + : + SynMeasure +
+
+
+ + caretRange + + : + range +
+
+
+ + power + + : + SynRationalConst +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Product(measure1, mAsterisk, measure2, range) + + +

+ +
+
+ Full Usage: + Product(measure1, mAsterisk, measure2, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A product of two units of measure, e.g. 'kg * m' +

+
+ +
+
+ + measure1 + + : + SynMeasure +
+
+
+ + mAsterisk + + : + range +
+
+
+ + measure2 + + : + SynMeasure +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Seq(measures, range) + + +

+ +
+
+ Full Usage: + Seq(measures, range) +
+
+ Parameters: +
    + + + measures + + : + SynMeasure list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A sequence of several units of measure, e.g. 'kg m m' +

+
+ +
+
+ + measures + + : + SynMeasure list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Var(typar, range) + + +

+ +
+
+ Full Usage: + Var(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A variable unit of measure +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmemberdefn.html b/reference/fsharp-compiler-syntax-synmemberdefn.html new file mode 100644 index 0000000000..a0ed59c010 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmemberdefn.html @@ -0,0 +1,1959 @@ + + + + + + + + + + + + + + + + + + SynMemberDefn (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberDefn Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a definition element within a type definition, e.g. 'member ... ' +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AbstractSlot(slotSig, flags, range, trivia) + + +

+ +
+
+ Full Usage: + AbstractSlot(slotSig, flags, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An abstract slot definition within a class or interface +

+
+ +
+
+ + slotSig + + : + SynValSig +
+
+
+ + flags + + : + SynMemberFlags +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynMemberDefnAbstractSlotTrivia +
+
+
+
+
+
+ +

+ + + AutoProperty(attributes, isStatic, ident, typeOpt, propKind, memberFlags, memberFlagsForSet, xmlDoc, accessibility, synExpr, range, trivia) + + +

+ +
+
+ Full Usage: + AutoProperty(attributes, isStatic, ident, typeOpt, propKind, memberFlags, memberFlagsForSet, xmlDoc, accessibility, synExpr, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An auto-property definition, F# syntax: 'member val X = expr' +

+
+ +
+
+ + attributes + + : + SynAttributes +
+
+
+ + isStatic + + : + bool +
+
+
+ + ident + + : + Ident +
+
+
+ + typeOpt + + : + SynType option +
+
+
+ + propKind + + : + SynMemberKind +
+
+
+ + memberFlags + + : + SynMemberFlags +
+
+
+ + memberFlagsForSet + + : + SynMemberFlags +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + synExpr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynMemberDefnAutoPropertyTrivia +
+
+
+
+
+
+ +

+ + + GetSetMember(memberDefnForGet, memberDefnForSet, range, trivia) + + +

+ +
+
+ Full Usage: + GetSetMember(memberDefnForGet, memberDefnForSet, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A 'member' definition with get/set accessors within a type +

+
+ +
+
+ + memberDefnForGet + + : + SynBinding option +
+
+
+ + memberDefnForSet + + : + SynBinding option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynMemberGetSetTrivia +
+
+
+
+
+
+ +

+ + + ImplicitCtor(accessibility, attributes, ctorArgs, selfIdentifier, xmlDoc, range, trivia) + + +

+ +
+
+ Full Usage: + ImplicitCtor(accessibility, attributes, ctorArgs, selfIdentifier, xmlDoc, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An implicit constructor definition +

+
+ +
+
+ + accessibility + + : + SynAccess option +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + ctorArgs + + : + SynPat +
+
+
+ + selfIdentifier + + : + Ident option +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynMemberDefnImplicitCtorTrivia +
+
+
+
+
+
+ +

+ + + ImplicitInherit(inheritType, inheritArgs, inheritAlias, range) + + +

+ +
+
+ Full Usage: + ImplicitInherit(inheritType, inheritArgs, inheritAlias, range) +
+
+ Parameters: +
    + + + inheritType + + : + SynType + +
    + + + inheritArgs + + : + SynExpr + +
    + + + inheritAlias + + : + Ident option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An implicit inherit definition, 'inherit (args...) as base' +

+
+ +
+
+ + inheritType + + : + SynType +
+
+
+ + inheritArgs + + : + SynExpr +
+
+
+ + inheritAlias + + : + Ident option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Inherit(baseType, asIdent, range) + + +

+ +
+
+ Full Usage: + Inherit(baseType, asIdent, range) +
+
+ Parameters: +
    + + + baseType + + : + SynType + +
    + + + asIdent + + : + Ident option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An 'inherit' definition within a class +

+
+ +
+
+ + baseType + + : + SynType +
+
+
+ + asIdent + + : + Ident option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Interface(interfaceType, withKeyword, members, range) + + +

+ +
+
+ Full Usage: + Interface(interfaceType, withKeyword, members, range) +
+
+ Parameters: +
    + + + interfaceType + + : + SynType + +
    + + + withKeyword + + : + range option + +
    + + + members + + : + SynMemberDefns option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An interface implementation definition within a class +

+
+ +
+
+ + interfaceType + + : + SynType +
+
+
+ + withKeyword + + : + range option +
+
+
+ + members + + : + SynMemberDefns option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LetBindings(bindings, isStatic, isRecursive, range) + + +

+ +
+
+ Full Usage: + LetBindings(bindings, isStatic, isRecursive, range) +
+
+ Parameters: +
    + + + bindings + + : + SynBinding list + +
    + + + isStatic + + : + bool + +
    + + + isRecursive + + : + bool + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A 'let' definition within a class +

+
+ +
+
+ + bindings + + : + SynBinding list +
+
+
+ + isStatic + + : + bool +
+
+
+ + isRecursive + + : + bool +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Member(memberDefn, range) + + +

+ +
+
+ Full Usage: + Member(memberDefn, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A 'member' definition within a type +

+
+ +
+
+ + memberDefn + + : + SynBinding +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + NestedType(typeDefn, accessibility, range) + + +

+ +
+
+ Full Usage: + NestedType(typeDefn, accessibility, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A nested type definition, a feature that is not implemented +

+
+ +
+
+ + typeDefn + + : + SynTypeDefn +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Open(target, range) + + +

+ +
+
+ Full Usage: + Open(target, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An 'open' definition within a type +

+
+ +
+
+ + target + + : + SynOpenDeclTarget +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ValField(fieldInfo, range) + + +

+ +
+
+ Full Usage: + ValField(fieldInfo, range) +
+
+ Parameters: +
    + + + fieldInfo + + : + SynField + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A 'val' definition within a class +

+
+ +
+
+ + fieldInfo + + : + SynField +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmemberflags.html b/reference/fsharp-compiler-syntax-synmemberflags.html new file mode 100644 index 0000000000..ae2167c4c9 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmemberflags.html @@ -0,0 +1,858 @@ + + + + + + + + + + + + + + + + + + SynMemberFlags (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberFlags Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the flags for a 'member' declaration +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + GetterOrSetterIsCompilerGenerated + + +

+ +
+
+ Full Usage: + GetterOrSetterIsCompilerGenerated +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ The member was generated by the compiler +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + IsDispatchSlot + + +

+ +
+
+ Full Usage: + IsDispatchSlot +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ The member is a dispatch slot +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + IsFinal + + +

+ +
+
+ Full Usage: + IsFinal +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ The member is 'final' +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + IsInstance + + +

+ +
+
+ Full Usage: + IsInstance +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ The member is an instance member (non-static) +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + IsOverrideOrExplicitImpl + + +

+ +
+
+ Full Usage: + IsOverrideOrExplicitImpl +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ The member is an 'override' or explicit interface implementation +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + MemberKind + + +

+ +
+
+ Full Usage: + MemberKind +
+
+ + Field type: + SynMemberKind + +
+
+
+
+ 		+
+ +
+ + + +

+ The kind of the member +

+
+ +
+
+ + Field type: + + SynMemberKind +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmemberkind.html b/reference/fsharp-compiler-syntax-synmemberkind.html new file mode 100644 index 0000000000..c00c51d328 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmemberkind.html @@ -0,0 +1,755 @@ + + + + + + + + + + + + + + + + + + SynMemberKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Note the member kind is actually computed partially by a syntax tree transformation in tc.fs +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ClassConstructor + + +

+ +
+
+ Full Usage: + ClassConstructor +
+
+
+
+
+ 		+
+ + + +

+ The member is a class initializer +

+
+
+
+ +

+ + + Constructor + + +

+ +
+
+ Full Usage: + Constructor +
+
+
+
+
+ 		+
+ + + +

+ The member is a object model constructor +

+
+
+
+ +

+ + + Member + + +

+ +
+
+ Full Usage: + Member +
+
+
+
+
+ 		+
+ + + +

+ The member kind is not yet determined +

+
+
+
+ +

+ + + PropertyGet + + +

+ +
+
+ Full Usage: + PropertyGet +
+
+
+
+
+ 		+
+ + + +

+ The member kind is property getter +

+
+
+
+ +

+ + + PropertyGetSet + + +

+ +
+
+ Full Usage: + PropertyGetSet +
+
+
+
+
+ 		+
+ + + +

+ An artificial member kind used prior to the point where a + get/set property is split into two distinct members. +

+
+
+
+ +

+ + + PropertySet + + +

+ +
+
+ Full Usage: + PropertySet +
+
+
+
+
+ 		+
+ + + +

+ The member kind is property setter +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmembersig.html b/reference/fsharp-compiler-syntax-synmembersig.html new file mode 100644 index 0000000000..8e33beb1af --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmembersig.html @@ -0,0 +1,1035 @@ + + + + + + + + + + + + + + + + + + SynMemberSig (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberSig Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for a member signature (used in signature files, abstract member declarations + and member constraints) +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Inherit(inheritedType, range) + + +

+ +
+
+ Full Usage: + Inherit(inheritedType, range) +
+
+ Parameters: +
    + + + inheritedType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An 'inherit' definition in a type in a signature file +

+
+ +
+
+ + inheritedType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Interface(interfaceType, range) + + +

+ +
+
+ Full Usage: + Interface(interfaceType, range) +
+
+ Parameters: +
    + + + interfaceType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An interface definition in a type in a signature file +

+
+ +
+
+ + interfaceType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Member(memberSig, flags, range, trivia) + + +

+ +
+
+ Full Usage: + Member(memberSig, flags, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A member definition in a type in a signature file +

+
+ +
+
+ + memberSig + + : + SynValSig +
+
+
+ + flags + + : + SynMemberFlags +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynMemberSigMemberTrivia +
+
+
+
+
+
+ +

+ + + NestedType(nestedType, range) + + +

+ +
+
+ Full Usage: + NestedType(nestedType, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A nested type definition in a signature file (an unimplemented feature) +

+
+ +
+
+ + nestedType + + : + SynTypeDefnSig +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ValField(field, range) + + +

+ +
+
+ Full Usage: + ValField(field, range) +
+
+ Parameters: +
    + + + field + + : + SynField + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A 'val' definition in a type in a signature file +

+
+ +
+
+ + field + + : + SynField +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmoduledecl.html b/reference/fsharp-compiler-syntax-synmoduledecl.html new file mode 100644 index 0000000000..9771e05658 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmoduledecl.html @@ -0,0 +1,1457 @@ + + + + + + + + + + + + + + + + + + SynModuleDecl (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleDecl Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a definition within a module +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Attributes(attributes, range) + + +

+ +
+
+ Full Usage: + Attributes(attributes, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An attribute definition within a module, for assembly and .NET module attributes +

+
+ +
+
+ + attributes + + : + SynAttributes +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Exception(exnDefn, range) + + +

+ +
+
+ Full Usage: + Exception(exnDefn, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An 'exception' definition within a module +

+
+ +
+
+ + exnDefn + + : + SynExceptionDefn +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Expr(expr, range) + + +

+ +
+
+ Full Usage: + Expr(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An 'expr' within a module. +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + HashDirective(hashDirective, range) + + +

+ +
+
+ Full Usage: + HashDirective(hashDirective, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A hash directive within a module +

+
+ +
+
+ + hashDirective + + : + ParsedHashDirective +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Let(isRecursive, bindings, range) + + +

+ +
+
+ Full Usage: + Let(isRecursive, bindings, range) +
+
+ Parameters: +
    + + + isRecursive + + : + bool + +
    + + + bindings + + : + SynBinding list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A 'let' definition within a module +

+
+ +
+
+ + isRecursive + + : + bool +
+
+
+ + bindings + + : + SynBinding list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ModuleAbbrev(ident, longId, range) + + +

+ +
+
+ Full Usage: + ModuleAbbrev(ident, longId, range) +
+
+ Parameters: +
    + + + ident + + : + Ident + +
    + + + longId + + : + LongIdent + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A module abbreviation definition 'module X = A.B.C' +

+
+ +
+
+ + ident + + : + Ident +
+
+
+ + longId + + : + LongIdent +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + NamespaceFragment fragment + + +

+ +
+
+ Full Usage: + NamespaceFragment fragment +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A namespace fragment within a module +

+
+ +
+
+ + fragment + + : + SynModuleOrNamespace +
+
+
+
+
+
+ +

+ + + NestedModule(moduleInfo, isRecursive, decls, isContinuing, range, trivia) + + +

+ +
+
+ Full Usage: + NestedModule(moduleInfo, isRecursive, decls, isContinuing, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A nested module definition 'module X = ...' +

+
+ +
+
+ + moduleInfo + + : + SynComponentInfo +
+
+
+ + isRecursive + + : + bool +
+
+
+ + decls + + : + SynModuleDecl list +
+
+
+ + isContinuing + + : + bool +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynModuleDeclNestedModuleTrivia +
+
+
+
+
+
+ +

+ + + Open(target, range) + + +

+ +
+
+ Full Usage: + Open(target, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An 'open' definition within a module +

+
+ +
+
+ + target + + : + SynOpenDeclTarget +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Types(typeDefns, range) + + +

+ +
+
+ Full Usage: + Types(typeDefns, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ One or more 'type' definitions within a module +

+
+ +
+
+ + typeDefns + + : + SynTypeDefn list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmoduleornamespace.html b/reference/fsharp-compiler-syntax-synmoduleornamespace.html new file mode 100644 index 0000000000..7f99d9a954 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmoduleornamespace.html @@ -0,0 +1,802 @@ + + + + + + + + + + + + + + + + + + SynModuleOrNamespace (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleOrNamespace Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the definition of a module or namespace +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynModuleOrNamespace(longId, isRecursive, kind, decls, xmlDoc, attribs, accessibility, range, trivia) + + +

+ +
+
+ Full Usage: + SynModuleOrNamespace(longId, isRecursive, kind, decls, xmlDoc, attribs, accessibility, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + longId + + : + LongIdent +
+
+
+ + isRecursive + + : + bool +
+
+
+ + kind + + : + SynModuleOrNamespaceKind +
+
+
+ + decls + + : + SynModuleDecl list +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + attribs + + : + SynAttributes +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynModuleOrNamespaceTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html b/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html new file mode 100644 index 0000000000..226c30337b --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmoduleornamespacekind.html @@ -0,0 +1,772 @@ + + + + + + + + + + + + + + + + + + SynModuleOrNamespaceKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleOrNamespaceKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<SynModuleOrNamespaceKind> + , + IComparable + , + IStructuralComparable +
+
+ Kind: Struct +
+
+
+
+

+ Represents the kind of a module or namespace definition +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + AnonModule + + +

+ +
+
+ Full Usage: + AnonModule +
+
+
+
+
+ 		+
+ + + +

+ A module is anonymously named, e.g. a script +

+
+
+
+ +

+ + + DeclaredNamespace + + +

+ +
+
+ Full Usage: + DeclaredNamespace +
+
+
+
+
+ 		+
+ + + +

+ A namespace is explicitly declared +

+
+
+
+ +

+ + + GlobalNamespace + + +

+ +
+
+ Full Usage: + GlobalNamespace +
+
+
+
+
+ 		+
+ + + +

+ A namespace is declared 'global' +

+
+
+
+ +

+ + + NamedModule + + +

+ +
+
+ Full Usage: + NamedModule +
+
+
+
+
+ 		+
+ + + +

+ A module is explicitly named 'module N' +

+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsModule + + +

+ +
+
+ Full Usage: + this.IsModule +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if this is a module definition +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmoduleornamespacesig.html b/reference/fsharp-compiler-syntax-synmoduleornamespacesig.html new file mode 100644 index 0000000000..2feaff96f9 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmoduleornamespacesig.html @@ -0,0 +1,802 @@ + + + + + + + + + + + + + + + + + + SynModuleOrNamespaceSig (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleOrNamespaceSig Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the definition of a module or namespace in a signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynModuleOrNamespaceSig(longId, isRecursive, kind, decls, xmlDoc, attribs, accessibility, range, trivia) + + +

+ +
+
+ Full Usage: + SynModuleOrNamespaceSig(longId, isRecursive, kind, decls, xmlDoc, attribs, accessibility, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + longId + + : + LongIdent +
+
+
+ + isRecursive + + : + bool +
+
+
+ + kind + + : + SynModuleOrNamespaceKind +
+
+
+ + decls + + : + SynModuleSigDecl list +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + attribs + + : + SynAttributes +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynModuleOrNamespaceSigTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synmodulesigdecl.html b/reference/fsharp-compiler-syntax-synmodulesigdecl.html new file mode 100644 index 0000000000..381fcb3633 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synmodulesigdecl.html @@ -0,0 +1,1276 @@ + + + + + + + + + + + + + + + + + + SynModuleSigDecl (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleSigDecl Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a definition within a module or namespace in a signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Exception(exnSig, range) + + +

+ +
+
+ Full Usage: + Exception(exnSig, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An exception definition within a module or namespace in a signature file +

+
+ +
+
+ + exnSig + + : + SynExceptionSig +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + HashDirective(hashDirective, range) + + +

+ +
+
+ Full Usage: + HashDirective(hashDirective, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A hash directive within a module or namespace in a signature file +

+
+ +
+
+ + hashDirective + + : + ParsedHashDirective +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ModuleAbbrev(ident, longId, range) + + +

+ +
+
+ Full Usage: + ModuleAbbrev(ident, longId, range) +
+
+ Parameters: +
    + + + ident + + : + Ident + +
    + + + longId + + : + LongIdent + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A module abbreviation definition within a module or namespace in a signature file +

+
+ +
+
+ + ident + + : + Ident +
+
+
+ + longId + + : + LongIdent +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + NamespaceFragment SynModuleOrNamespaceSig + + +

+ +
+
+ Full Usage: + NamespaceFragment SynModuleOrNamespaceSig +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A namespace fragment within a namespace in a signature file +

+
+ +
+
+ + Item + + : + SynModuleOrNamespaceSig +
+
+
+
+
+
+ +

+ + + NestedModule(moduleInfo, isRecursive, moduleDecls, range, trivia) + + +

+ +
+
+ Full Usage: + NestedModule(moduleInfo, isRecursive, moduleDecls, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A nested module definition within a module or namespace in a signature file +

+
+ +
+
+ + moduleInfo + + : + SynComponentInfo +
+
+
+ + isRecursive + + : + bool +
+
+
+ + moduleDecls + + : + SynModuleSigDecl list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynModuleSigDeclNestedModuleTrivia +
+
+
+
+
+
+ +

+ + + Open(target, range) + + +

+ +
+
+ Full Usage: + Open(target, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An 'open' definition within a module or namespace in a signature file +

+
+ +
+
+ + target + + : + SynOpenDeclTarget +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Types(types, range) + + +

+ +
+
+ Full Usage: + Types(types, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A set of one or more type definitions within a module or namespace in a signature file +

+
+ +
+
+ + types + + : + SynTypeDefnSig list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Val(valSig, range) + + +

+ +
+
+ Full Usage: + Val(valSig, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A 'val' definition within a module or namespace in a signature file, corresponding + to a 'let' definition in the implementation +

+
+ +
+
+ + valSig + + : + SynValSig +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synopendecltarget.html b/reference/fsharp-compiler-syntax-synopendecltarget.html new file mode 100644 index 0000000000..6015e691a6 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synopendecltarget.html @@ -0,0 +1,777 @@ + + + + + + + + + + + + + + + + + + SynOpenDeclTarget (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynOpenDeclTarget Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the target of the open declaration +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ModuleOrNamespace(longId, range) + + +

+ +
+
+ Full Usage: + ModuleOrNamespace(longId, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A 'open' declaration +

+
+ +
+
+ + longId + + : + SynLongIdent +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Type(typeName, range) + + +

+ +
+
+ Full Usage: + Type(typeName, range) +
+
+ Parameters: +
    + + + typeName + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A 'open type' declaration +

+
+ +
+
+ + typeName + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synpat.html b/reference/fsharp-compiler-syntax-synpat.html new file mode 100644 index 0000000000..9ebbe94243 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synpat.html @@ -0,0 +1,2399 @@ + + + + + + + + + + + + + + + + + + SynPat (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynPat Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntax tree for an F# pattern +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Ands(pats, range) + + +

+ +
+
+ Full Usage: + Ands(pats, range) +
+
+ Parameters: +
    + + + pats + + : + SynPat list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A conjunctive pattern 'pat1 & pat2' +

+
+ +
+
+ + pats + + : + SynPat list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ArrayOrList(isArray, elementPats, range) + + +

+ +
+
+ Full Usage: + ArrayOrList(isArray, elementPats, range) +
+
+ Parameters: +
    + + + isArray + + : + bool + +
    + + + elementPats + + : + SynPat list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An array or a list as a pattern +

+
+ +
+
+ + isArray + + : + bool +
+
+
+ + elementPats + + : + SynPat list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + As(lhsPat, rhsPat, range) + + +

+ +
+
+ Full Usage: + As(lhsPat, rhsPat, range) +
+
+ Parameters: +
    + + + lhsPat + + : + SynPat + +
    + + + rhsPat + + : + SynPat + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A conjunctive pattern 'pat1 as pat2' +

+
+ +
+
+ + lhsPat + + : + SynPat +
+
+
+ + rhsPat + + : + SynPat +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Attrib(pat, attributes, range) + + +

+ +
+
+ Full Usage: + Attrib(pat, attributes, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An attributed pattern, used in argument or declaration position +

+
+ +
+
+ + pat + + : + SynPat +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Const(constant, range) + + +

+ +
+
+ Full Usage: + Const(constant, range) +
+
+ Parameters: +
    + + + constant + + : + SynConst + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A constant in a pattern +

+
+ +
+
+ + constant + + : + SynConst +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + FromParseError(pat, range) + + +

+ +
+
+ Full Usage: + FromParseError(pat, range) +
+
+ Parameters: +
    + + + pat + + : + SynPat + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A pattern arising from a parse error +

+
+ +
+
+ + pat + + : + SynPat +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + InstanceMember(thisId, memberId, toolingId, accessibility, range) + + +

+ +
+
+ Full Usage: + InstanceMember(thisId, memberId, toolingId, accessibility, range) +
+
+ Parameters: +
    + + + thisId + + : + Ident + +
    + + + memberId + + : + Ident + +
    + + + toolingId + + : + Ident option + +
    + + + accessibility + + : + SynAccess option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Used internally in the type checker +

+
+ +
+
+ + thisId + + : + Ident +
+
+
+ + memberId + + : + Ident +
+
+
+ + toolingId + + : + Ident option +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + IsInst(pat, range) + + +

+ +
+
+ Full Usage: + IsInst(pat, range) +
+
+ Parameters: +
    + + + pat + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A type test pattern ':? type ' +

+
+ +
+
+ + pat + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + ListCons(lhsPat, rhsPat, range, trivia) + + +

+ +
+
+ Full Usage: + ListCons(lhsPat, rhsPat, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A conjunctive pattern 'pat1 :: pat2' +

+
+ +
+
+ + lhsPat + + : + SynPat +
+
+
+ + rhsPat + + : + SynPat +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynPatListConsTrivia +
+
+
+
+
+
+ +

+ + + LongIdent(longDotId, extraId, typarDecls, argPats, accessibility, range) + + +

+ +
+
+ Full Usage: + LongIdent(longDotId, extraId, typarDecls, argPats, accessibility, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A long identifier pattern possibly with argument patterns +

+
+ +
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + extraId + + : + Ident option +
+
+
+ + typarDecls + + : + SynValTyparDecls option +
+
+
+ + argPats + + : + SynArgPats +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Named(ident, isThisVal, accessibility, range) + + +

+ +
+
+ Full Usage: + Named(ident, isThisVal, accessibility, range) +
+
+ Parameters: +
    + + + ident + + : + SynIdent + +
    + + + isThisVal + + : + bool + +
    + + + accessibility + + : + SynAccess option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A name pattern 'ident' +

+
+ +
+
+ + ident + + : + SynIdent +
+
+
+ + isThisVal + + : + bool +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Null range + + +

+ +
+
+ Full Usage: + Null range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ The 'null' pattern +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + OptionalVal(ident, range) + + +

+ +
+
+ Full Usage: + OptionalVal(ident, range) +
+
+ Parameters: +
    + + + ident + + : + Ident + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ '?id' -- for optional argument names +

+
+ +
+
+ + ident + + : + Ident +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Or(lhsPat, rhsPat, range, trivia) + + +

+ +
+
+ Full Usage: + Or(lhsPat, rhsPat, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A disjunctive pattern 'pat1 | pat2' +

+
+ +
+
+ + lhsPat + + : + SynPat +
+
+
+ + rhsPat + + : + SynPat +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynPatOrTrivia +
+
+
+
+
+
+ +

+ + + Paren(pat, range) + + +

+ +
+
+ Full Usage: + Paren(pat, range) +
+
+ Parameters: +
    + + + pat + + : + SynPat + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A parenthesized pattern +

+
+ +
+
+ + pat + + : + SynPat +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + QuoteExpr(expr, range) + + +

+ +
+
+ Full Usage: + QuoteExpr(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ <@ expr @>, used for active pattern arguments +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Record(fieldPats, range) + + +

+ +
+
+ Full Usage: + Record(fieldPats, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A record pattern +

+
+ +
+
+ + fieldPats + + : + ((LongIdent * Ident) * range option * SynPat) list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Tuple(isStruct, elementPats, commaRanges, range) + + +

+ +
+
+ Full Usage: + Tuple(isStruct, elementPats, commaRanges, range) +
+
+ Parameters: +
    + + + isStruct + + : + bool + +
    + + + elementPats + + : + SynPat list + +
    + + + commaRanges + + : + range list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A tuple pattern +

+
+ +
+
+ + isStruct + + : + bool +
+
+
+ + elementPats + + : + SynPat list +
+
+
+ + commaRanges + + : + range list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Typed(pat, targetType, range) + + +

+ +
+
+ Full Usage: + Typed(pat, targetType, range) +
+
+ Parameters: +
    + + + pat + + : + SynPat + +
    + + + targetType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A typed pattern 'pat : type' +

+
+ +
+
+ + pat + + : + SynPat +
+
+
+ + targetType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Wild range + + +

+ +
+
+ Full Usage: + Wild range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A wildcard '_' in a pattern +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synrationalconst.html b/reference/fsharp-compiler-syntax-synrationalconst.html new file mode 100644 index 0000000000..cd85e9b815 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synrationalconst.html @@ -0,0 +1,868 @@ + + + + + + + + + + + + + + + + + + SynRationalConst (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynRationalConst Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents an unchecked syntax tree of F# unit of measure exponents. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Integer(value, range) + + +

+ +
+
+ Full Usage: + Integer(value, range) +
+
+ Parameters: +
    + + + value + + : + int32 + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + value + + : + int32 +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + Negate(rationalConst, range) + + +

+ +
+
+ Full Usage: + Negate(rationalConst, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + rationalConst + + : + SynRationalConst +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + Paren(rationalConst, range) + + +

+ +
+
+ Full Usage: + Paren(rationalConst, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + rationalConst + + : + SynRationalConst +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + Rational(numerator, numeratorRange, divRange, denominator, denominatorRange, range) + + +

+ +
+
+ Full Usage: + Rational(numerator, numeratorRange, divRange, denominator, denominatorRange, range) +
+
+ Parameters: +
    + + + numerator + + : + int32 + +
    + + + numeratorRange + + : + range + +
    + + + divRange + + : + range + +
    + + + denominator + + : + int32 + +
    + + + denominatorRange + + : + range + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + numerator + + : + int32 +
+
+
+ + numeratorRange + + : + range +
+
+
+ + divRange + + : + range +
+
+
+ + denominator + + : + int32 +
+
+
+ + denominatorRange + + : + range +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synreturninfo.html b/reference/fsharp-compiler-syntax-synreturninfo.html new file mode 100644 index 0000000000..2deaa21c15 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synreturninfo.html @@ -0,0 +1,672 @@ + + + + + + + + + + + + + + + + + + SynReturnInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynReturnInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntactic elements associated with the "return" of a function or method. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynReturnInfo(returnType, range) + + +

+ +
+
+ Full Usage: + SynReturnInfo(returnType, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + returnType + + : + SynType * SynArgInfo +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synsimplepat.html b/reference/fsharp-compiler-syntax-synsimplepat.html new file mode 100644 index 0000000000..5b80bd8b05 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synsimplepat.html @@ -0,0 +1,939 @@ + + + + + + + + + + + + + + + + + + SynSimplePat (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynSimplePat Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntax tree for simple F# patterns +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Attrib(pat, attributes, range) + + +

+ +
+
+ Full Usage: + Attrib(pat, attributes, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An attributed simple pattern +

+
+ +
+
+ + pat + + : + SynSimplePat +
+
+
+ + attributes + + : + SynAttributes +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Id(ident, altNameRefCell, isCompilerGenerated, isThisVal, isOptional, range) + + +

+ +
+
+ Full Usage: + Id(ident, altNameRefCell, isCompilerGenerated, isThisVal, isOptional, range) +
+
+ Parameters: +
    + + + ident + + : + Ident + +
    + + + altNameRefCell + + : + SynSimplePatAlternativeIdInfo ref option + +
    + + + isCompilerGenerated + + : + bool + +
    + + + isThisVal + + : + bool + +
    + + + isOptional + + : + bool + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + + 
 Indicates a simple pattern variable.
+
+ altNameRefCell:
+   Normally 'None' except for some compiler-generated variables in desugaring pattern matching.
+   Pattern processing sets this reference for hidden variable introduced
+   by desugaring pattern matching in arguments. The info indicates an
+   alternative (compiler generated) identifier to be used because the
+   name of the identifier is already bound.
+
+ isCompilerGenerated: true if a compiler generated name
+ isThisVal: true if 'this' variable in member
+ isOptional: true if a '?' is in front of the name
+
+ +
+
+ + ident + + : + Ident +
+
+
+ + altNameRefCell + + : + SynSimplePatAlternativeIdInfo ref option +
+
+
+ + isCompilerGenerated + + : + bool +
+
+
+ + isThisVal + + : + bool +
+
+
+ + isOptional + + : + bool +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Typed(pat, targetType, range) + + +

+ +
+
+ Full Usage: + Typed(pat, targetType, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A type annotated simple pattern +

+
+ +
+
+ + pat + + : + SynSimplePat +
+
+
+ + targetType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synsimplepatalternativeidinfo.html b/reference/fsharp-compiler-syntax-synsimplepatalternativeidinfo.html new file mode 100644 index 0000000000..c392f9af30 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synsimplepatalternativeidinfo.html @@ -0,0 +1,670 @@ + + + + + + + + + + + + + + + + + + SynSimplePatAlternativeIdInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynSimplePatAlternativeIdInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the alternative identifier for a simple pattern +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Decided Ident + + +

+ +
+
+ Full Usage: + Decided Ident +
+
+ Parameters: +
    + + + Item + + : + Ident + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ We have decided to use an alternative name in the pattern and related expression +

+
+ +
+
+ + Item + + : + Ident +
+
+
+
+
+
+ +

+ + + Undecided Ident + + +

+ +
+
+ Full Usage: + Undecided Ident +
+
+ Parameters: +
    + + + Item + + : + Ident + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ We have not decided to use an alternative name in the pattern and related expression +

+
+ +
+
+ + Item + + : + Ident +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synsimplepats.html b/reference/fsharp-compiler-syntax-synsimplepats.html new file mode 100644 index 0000000000..52217b65e8 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synsimplepats.html @@ -0,0 +1,691 @@ + + + + + + + + + + + + + + + + + + SynSimplePats (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynSimplePats Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a simple set of variable bindings a, (a, b) or (a: Type, b: Type) at a lambda, + function definition or other binding point, after the elimination of pattern matching + from the construct, e.g. after changing a "function pat1 -> rule1 | ..." to a + "fun v -> match v with ..." +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SimplePats(pats, commaRanges, range) + + +

+ +
+
+ Full Usage: + SimplePats(pats, commaRanges, range) +
+
+ Parameters: +
    + + + pats + + : + SynSimplePat list + +
    + + + commaRanges + + : + range list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + pats + + : + SynSimplePat list +
+
+
+ + commaRanges + + : + range list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synstaticoptimizationconstraint.html b/reference/fsharp-compiler-syntax-synstaticoptimizationconstraint.html new file mode 100644 index 0000000000..fd4d298bda --- /dev/null +++ b/reference/fsharp-compiler-syntax-synstaticoptimizationconstraint.html @@ -0,0 +1,718 @@ + + + + + + + + + + + + + + + + + + SynStaticOptimizationConstraint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynStaticOptimizationConstraint Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntax tree for a static optimization constraint in the F# core library +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + WhenTyparIsStruct(typar, range) + + +

+ +
+
+ Full Usage: + WhenTyparIsStruct(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A static optimization conditional that activates for a struct +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhenTyparTyconEqualsTycon(typar, rhsType, range) + + +

+ +
+
+ Full Usage: + WhenTyparTyconEqualsTycon(typar, rhsType, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + rhsType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A static optimization conditional that activates for a particular type instantiation +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + rhsType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synstringkind.html b/reference/fsharp-compiler-syntax-synstringkind.html new file mode 100644 index 0000000000..1a4c62224e --- /dev/null +++ b/reference/fsharp-compiler-syntax-synstringkind.html @@ -0,0 +1,664 @@ + + + + + + + + + + + + + + + + + + SynStringKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynStringKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<SynStringKind> + , + IComparable + , + IStructuralComparable +
+
+ Kind: Struct +
+
+
+
+

+ Indicate if the string had a special format +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Regular + + +

+ +
+
+ Full Usage: + Regular +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TripleQuote + + +

+ +
+
+ Full Usage: + TripleQuote +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Verbatim + + +

+ +
+
+ Full Usage: + Verbatim +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntaxnode.html b/reference/fsharp-compiler-syntax-syntaxnode.html new file mode 100644 index 0000000000..81168f3c75 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntaxnode.html @@ -0,0 +1,1210 @@ + + + + + + + + + + + + + + + + + + SyntaxNode (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SyntaxNode Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Used to track route during traversal of syntax using SyntaxTraversal.Traverse +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynBinding SynBinding + + +

+ +
+
+ Full Usage: + SynBinding SynBinding +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynBinding +
+
+
+
+
+ +

+ + + SynExpr SynExpr + + +

+ +
+
+ Full Usage: + SynExpr SynExpr +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynExpr +
+
+
+
+
+ +

+ + + SynMatchClause SynMatchClause + + +

+ +
+
+ Full Usage: + SynMatchClause SynMatchClause +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynMatchClause +
+
+
+
+
+ +

+ + + SynMemberDefn SynMemberDefn + + +

+ +
+
+ Full Usage: + SynMemberDefn SynMemberDefn +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynMemberDefn +
+
+
+
+
+ +

+ + + SynMemberSig SynMemberSig + + +

+ +
+
+ Full Usage: + SynMemberSig SynMemberSig +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynMemberSig +
+
+
+
+
+ +

+ + + SynModule SynModuleDecl + + +

+ +
+
+ Full Usage: + SynModule SynModuleDecl +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynModuleDecl +
+
+
+
+
+ +

+ + + SynModuleOrNamespace SynModuleOrNamespace + + +

+ +
+
+ Full Usage: + SynModuleOrNamespace SynModuleOrNamespace +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynModuleOrNamespace +
+
+
+
+
+ +

+ + + SynModuleOrNamespaceSig SynModuleOrNamespaceSig + + +

+ +
+
+ Full Usage: + SynModuleOrNamespaceSig SynModuleOrNamespaceSig +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynModuleOrNamespaceSig +
+
+
+
+
+ +

+ + + SynModuleSigDecl SynModuleSigDecl + + +

+ +
+
+ Full Usage: + SynModuleSigDecl SynModuleSigDecl +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynModuleSigDecl +
+
+
+
+
+ +

+ + + SynPat SynPat + + +

+ +
+
+ Full Usage: + SynPat SynPat +
+
+ Parameters: +
    + + + Item + + : + SynPat + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + SynPat +
+
+
+
+
+ +

+ + + SynType SynType + + +

+ +
+
+ Full Usage: + SynType SynType +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynType +
+
+
+
+
+ +

+ + + SynTypeDefn SynTypeDefn + + +

+ +
+
+ Full Usage: + SynTypeDefn SynTypeDefn +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynTypeDefn +
+
+
+
+
+ +

+ + + SynTypeDefnSig SynTypeDefnSig + + +

+ +
+
+ Full Usage: + SynTypeDefnSig SynTypeDefnSig +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynTypeDefnSig +
+
+
+
+
+ +

+ + + SynValSig SynValSig + + +

+ +
+
+ Full Usage: + SynValSig SynValSig +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + SynValSig +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntaxtraversal.html b/reference/fsharp-compiler-syntax-syntaxtraversal.html new file mode 100644 index 0000000000..c143ba2307 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntaxtraversal.html @@ -0,0 +1,641 @@ + + + + + + + + + + + + + + + + + + SyntaxTraversal (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SyntaxTraversal Module +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + Traverse (pos, parseTree, visitor) + + +

+ +
+
+ Full Usage: + Traverse (pos, parseTree, visitor) +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+
+
+
+ 		+
+
+ + pos + + : + pos +
+
+
+ + parseTree + + : + ParsedInput +
+
+
+ + visitor + + : + SyntaxVisitorBase<'T> +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html b/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html new file mode 100644 index 0000000000..2a787fe7e1 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntaxvisitorbase-1.html @@ -0,0 +1,2869 @@ + + + + + + + + + + + + + + + + + + SyntaxVisitorBase<'T> (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SyntaxVisitorBase<'T> Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + SyntaxVisitorBase() + + +

+ +
+
+ Full Usage: + SyntaxVisitorBase() +
+
+ + Returns: + SyntaxVisitorBase<'T> + +
+
+
+
+ 		+
+
+ + Returns: + + SyntaxVisitorBase<'T> +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.VisitAttributeApplication + + +

+ +
+
+ Full Usage: + this.VisitAttributeApplication +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + attributes + + : + SynAttributeList +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitBinding + + +

+ +
+
+ Full Usage: + this.VisitBinding +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynBinding -> 'T option +
+
+
+ + synBinding + + : + SynBinding +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitComponentInfo + + +

+ +
+
+ Full Usage: + this.VisitComponentInfo +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + synComponentInfo + + : + SynComponentInfo +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitEnumDefn + + +

+ +
+
+ Full Usage: + this.VisitEnumDefn +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + cases + + : + SynEnumCase list +
+
+
+ + arg2 + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitExpr + + +

+ +
+
+ Full Usage: + this.VisitExpr +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + + 
 Controls the behavior when a SynExpr is reached; it can just do
+          defaultTraverse(expr)      if you have no special logic for this node, and want the default processing to pick which sub-node to dive deeper into
+ or can inject non-default behavior, which might incorporate:
+          traverseSynExpr(subExpr)   to recurse deeper on some particular sub-expression based on your own logic
+ path helps to track AST nodes that were passed during traversal
+
+ +
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + traverseSynExpr + + : + SynExpr -> 'T option +
+
+
+ + defaultTraverse + + : + SynExpr -> 'T option +
+
+
+ + synExpr + + : + SynExpr +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+
+ +

+ + + this.VisitHashDirective + + +

+ +
+
+ Full Usage: + this.VisitHashDirective +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + hashDirective + + : + ParsedHashDirective +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitImplicitInherit + + +

+ +
+
+ Full Usage: + this.VisitImplicitInherit +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynExpr -> 'T option +
+
+
+ + inheritedType + + : + SynType +
+
+
+ + synArgs + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitInheritSynMemberDefn + + +

+ +
+
+ Full Usage: + this.VisitInheritSynMemberDefn +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + componentInfo + + : + SynComponentInfo +
+
+
+ + typeDefnKind + + : + SynTypeDefnKind +
+
+
+ + synType + + : + SynType +
+
+
+ + members + + : + SynMemberDefns +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitInterfaceSynMemberDefnType + + +

+ +
+
+ Full Usage: + this.VisitInterfaceSynMemberDefnType +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + synType + + : + SynType +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitLetOrUse + + +

+ +
+
+ Full Usage: + this.VisitLetOrUse +
+
+ Parameters: +
    + + + path + + : + SyntaxVisitorPath + +
    + + + isRecursive + + : + bool + +
    + + + defaultTraverse + + : + SynBinding -> 'T option + +
    + + + bindings + + : + SynBinding list + +
    + + + range + + : + range + +
    +
+
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + isRecursive + + : + bool +
+
+
+ + defaultTraverse + + : + SynBinding -> 'T option +
+
+
+ + bindings + + : + SynBinding list +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitMatchClause + + +

+ +
+
+ Full Usage: + this.VisitMatchClause +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynMatchClause -> 'T option +
+
+
+ + matchClause + + : + SynMatchClause +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitModuleDecl + + +

+ +
+
+ Full Usage: + this.VisitModuleDecl +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynModuleDecl -> 'T option +
+
+
+ + synModuleDecl + + : + SynModuleDecl +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitModuleOrNamespace + + +

+ +
+
+ Full Usage: + this.VisitModuleOrNamespace +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + synModuleOrNamespace + + : + SynModuleOrNamespace +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitModuleOrNamespaceSig + + +

+ +
+
+ Full Usage: + this.VisitModuleOrNamespaceSig +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + synModuleOrNamespaceSig + + : + SynModuleOrNamespaceSig +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitModuleSigDecl + + +

+ +
+
+ Full Usage: + this.VisitModuleSigDecl +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynModuleSigDecl -> 'T option +
+
+
+ + synModuleSigDecl + + : + SynModuleSigDecl +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitPat + + +

+ +
+
+ Full Usage: + this.VisitPat +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynPat -> 'T option +
+
+
+ + synPat + + : + SynPat +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitRecordDefn + + +

+ +
+
+ Full Usage: + this.VisitRecordDefn +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + fields + + : + SynField list +
+
+
+ + arg2 + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitRecordField + + +

+ +
+
+ Full Usage: + this.VisitRecordField +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + copyOpt + + : + SynExpr option +
+
+
+ + recordField + + : + SynLongIdent option +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitSimplePats + + +

+ +
+
+ Full Usage: + this.VisitSimplePats +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + pat + + : + SynPat +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitType + + +

+ +
+
+ Full Usage: + this.VisitType +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynType -> 'T option +
+
+
+ + synType + + : + SynType +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitTypeAbbrev + + +

+ +
+
+ Full Usage: + this.VisitTypeAbbrev +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + synType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitUnionDefn + + +

+ +
+
+ Full Usage: + this.VisitUnionDefn +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + cases + + : + SynUnionCase list +
+
+
+ + arg2 + + : + range +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+ +

+ + + this.VisitValSig + + +

+ +
+
+ Full Usage: + this.VisitValSig +
+
+ Parameters: + +
+ + Returns: + 'T option + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + path + + : + SyntaxVisitorPath +
+
+
+ + defaultTraverse + + : + SynValSig -> 'T option +
+
+
+ + valSig + + : + SynValSig +
+
+
+
+
+ + Returns: + + 'T option +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntupletypesegment.html b/reference/fsharp-compiler-syntax-syntupletypesegment.html new file mode 100644 index 0000000000..f176881c8b --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntupletypesegment.html @@ -0,0 +1,750 @@ + + + + + + + + + + + + + + + + + + SynTupleTypeSegment (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTupleTypeSegment Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Slash range + + +

+ +
+
+ Full Usage: + Slash range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + Star range + + +

+ +
+
+ Full Usage: + Star range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + Type typeName + + +

+ +
+
+ Full Usage: + Type typeName +
+
+ Parameters: +
    + + + typeName + + : + SynType + +
    +
+
+
+
+
+ 		+
+
+ + typeName + + : + SynType +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypar.html b/reference/fsharp-compiler-syntax-syntypar.html new file mode 100644 index 0000000000..abb1a4588a --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypar.html @@ -0,0 +1,706 @@ + + + + + + + + + + + + + + + + + + SynTypar (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypar Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntactic type parameter +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynTypar(ident, staticReq, isCompGen) + + +

+ +
+
+ Full Usage: + SynTypar(ident, staticReq, isCompGen) +
+
+ Parameters: +
    + + + ident + + : + Ident + +
    + + + staticReq + + : + TyparStaticReq + +
    + + + isCompGen + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + ident + + : + Ident +
+
+
+ + staticReq + + : + TyparStaticReq +
+
+
+ + isCompGen + + : + bool +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypardecl.html b/reference/fsharp-compiler-syntax-syntypardecl.html new file mode 100644 index 0000000000..2681fcae67 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypardecl.html @@ -0,0 +1,647 @@ + + + + + + + + + + + + + + + + + + SynTyparDecl (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTyparDecl Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the explicit declaration of a type parameter +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynTyparDecl(attributes, typar, intersectionConstraints, trivia) + + +

+ +
+
+ Full Usage: + SynTyparDecl(attributes, typar, intersectionConstraints, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + typar + + : + SynTypar +
+
+
+ + intersectionConstraints + + : + SynType list +
+
+
+ + trivia + + : + SynTyparDeclTrivia +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypardecls.html b/reference/fsharp-compiler-syntax-syntypardecls.html new file mode 100644 index 0000000000..14d7a13947 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypardecls.html @@ -0,0 +1,893 @@ + + + + + + + + + + + + + + + + + + SynTyparDecls (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTyparDecls Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ List of type parameter declarations with optional type constraints, + enclosed in `< ... >` (postfix) or `( ... )` (prefix), or a single prefix parameter. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + PostfixList(decls, constraints, range) + + +

+ +
+
+ Full Usage: + PostfixList(decls, constraints, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + decls + + : + SynTyparDecl list +
+
+
+ + constraints + + : + SynTypeConstraint list +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + PrefixList(decls, range) + + +

+ +
+
+ Full Usage: + PrefixList(decls, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + decls + + : + SynTyparDecl list +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + SinglePrefix(decl, range) + + +

+ +
+
+ Full Usage: + SinglePrefix(decl, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + decl + + : + SynTyparDecl +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Constraints + + +

+ +
+
+ Full Usage: + this.Constraints +
+
+ + Returns: + SynTypeConstraint list + +
+
+
+
+ 		+
+
+ + Returns: + + SynTypeConstraint list +
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.TyparDecls + + +

+ +
+
+ Full Usage: + this.TyparDecls +
+
+ + Returns: + SynTyparDecl list + +
+
+
+
+ 		+
+
+ + Returns: + + SynTyparDecl list +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntype.html b/reference/fsharp-compiler-syntax-syntype.html new file mode 100644 index 0000000000..d93be13738 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntype.html @@ -0,0 +1,2471 @@ + + + + + + + + + + + + + + + + + + SynType (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynType Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a syntax tree for F# types +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Anon range + + +

+ +
+
+ Full Usage: + Anon range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: _ +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + AnonRecd(isStruct, fields, range) + + +

+ +
+
+ Full Usage: + AnonRecd(isStruct, fields, range) +
+
+ Parameters: +
    + + + isStruct + + : + bool + +
    + + + fields + + : + (Ident * SynType) list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: {| id: type; ...; id: type |} + F# syntax: struct {| id: type; ...; id: type |} +

+
+ +
+
+ + isStruct + + : + bool +
+
+
+ + fields + + : + (Ident * SynType) list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + App(typeName, lessRange, typeArgs, commaRanges, greaterRange, isPostfix, range) + + +

+ +
+
+ Full Usage: + App(typeName, lessRange, typeArgs, commaRanges, greaterRange, isPostfix, range) +
+
+ Parameters: +
    + + + typeName + + : + SynType + +
    + + + lessRange + + : + range option + +
    + + + typeArgs + + : + SynType list + +
    + + + commaRanges + + : + range list + +
    + + + greaterRange + + : + range option + +
    + + + isPostfix + + : + bool + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + + 
 F# syntax: type or type type or (type, ..., type) type
+   isPostfix: indicates a postfix type application e.g. "int list" or "(int, string) dict"
+
+ +
+
+ + typeName + + : + SynType +
+
+
+ + lessRange + + : + range option +
+
+
+ + typeArgs + + : + SynType list +
+
+
+ + commaRanges + + : + range list +
+
+
+ + greaterRange + + : + range option +
+
+
+ + isPostfix + + : + bool +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Array(rank, elementType, range) + + +

+ +
+
+ Full Usage: + Array(rank, elementType, range) +
+
+ Parameters: +
    + + + rank + + : + int + +
    + + + elementType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: type[] +

+
+ +
+
+ + rank + + : + int +
+
+
+ + elementType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + FromParseError range + + +

+ +
+
+ Full Usage: + FromParseError range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A type arising from a parse error +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Fun(argType, returnType, range, trivia) + + +

+ +
+
+ Full Usage: + Fun(argType, returnType, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: type -> type +

+
+ +
+
+ + argType + + : + SynType +
+
+
+ + returnType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynTypeFunTrivia +
+
+
+
+
+
+ +

+ + + HashConstraint(innerType, range) + + +

+ +
+
+ Full Usage: + HashConstraint(innerType, range) +
+
+ Parameters: +
    + + + innerType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: #type +

+
+ +
+
+ + innerType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Intersection(typar, types, range, trivia) + + +

+ +
+
+ Full Usage: + Intersection(typar, types, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: x: #I1 & #I2 + F# syntax: x: 't & #I1 & #I2 + Shorthand for x: 't when 't :> I1 and 't :> I2 +

+
+ +
+
+ + typar + + : + SynTypar option +
+
+
+ + types + + : + SynType list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynTyparDeclTrivia +
+
+
+
+
+
+ +

+ + + LongIdent longDotId + + +

+ +
+
+ Full Usage: + LongIdent longDotId +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: A.B.C +

+
+ +
+
+ + longDotId + + : + SynLongIdent +
+
+
+
+
+
+ +

+ + + LongIdentApp(typeName, longDotId, lessRange, typeArgs, commaRanges, greaterRange, range) + + +

+ +
+
+ Full Usage: + LongIdentApp(typeName, longDotId, lessRange, typeArgs, commaRanges, greaterRange, range) +
+
+ Parameters: +
    + + + typeName + + : + SynType + +
    + + + longDotId + + : + SynLongIdent + +
    + + + lessRange + + : + range option + +
    + + + typeArgs + + : + SynType list + +
    + + + commaRanges + + : + range list + +
    + + + greaterRange + + : + range option + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: type.A.B.C +

+
+ +
+
+ + typeName + + : + SynType +
+
+
+ + longDotId + + : + SynLongIdent +
+
+
+ + lessRange + + : + range option +
+
+
+ + typeArgs + + : + SynType list +
+
+
+ + commaRanges + + : + range list +
+
+
+ + greaterRange + + : + range option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + MeasurePower(baseMeasure, exponent, range) + + +

+ +
+
+ Full Usage: + MeasurePower(baseMeasure, exponent, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: for units of measure e.g. m^3, kg^1/2 +

+
+ +
+
+ + baseMeasure + + : + SynType +
+
+
+ + exponent + + : + SynRationalConst +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Or(lhsType, rhsType, range, trivia) + + +

+ +
+
+ Full Usage: + Or(lhsType, rhsType, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ^a or ^b, used in trait calls +

+
+ +
+
+ + lhsType + + : + SynType +
+
+
+ + rhsType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynTypeOrTrivia +
+
+
+
+
+
+ +

+ + + Paren(innerType, range) + + +

+ +
+
+ Full Usage: + Paren(innerType, range) +
+
+ Parameters: +
    + + + innerType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + innerType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + SignatureParameter(attributes, optional, id, usedType, range) + + +

+ +
+
+ Full Usage: + SignatureParameter(attributes, optional, id, usedType, range) +
+
+ Parameters: +
    + + + attributes + + : + SynAttributes + +
    + + + optional + + : + bool + +
    + + + id + + : + Ident option + +
    + + + usedType + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: a: b, used in signatures and type annotations +

+
+ +
+
+ + attributes + + : + SynAttributes +
+
+
+ + optional + + : + bool +
+
+
+ + id + + : + Ident option +
+
+
+ + usedType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + StaticConstant(constant, range) + + +

+ +
+
+ Full Usage: + StaticConstant(constant, range) +
+
+ Parameters: +
    + + + constant + + : + SynConst + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 1, "abc" etc, used in parameters to type providers + For the dimensionless units i.e. 1, and static parameters to provided types +

+
+ +
+
+ + constant + + : + SynConst +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + StaticConstantExpr(expr, range) + + +

+ +
+
+ Full Usage: + StaticConstantExpr(expr, range) +
+
+ Parameters: +
    + + + expr + + : + SynExpr + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: const expr, used in static parameters to type providers +

+
+ +
+
+ + expr + + : + SynExpr +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + StaticConstantNamed(ident, value, range) + + +

+ +
+
+ Full Usage: + StaticConstantNamed(ident, value, range) +
+
+ Parameters: +
    + + + ident + + : + SynType + +
    + + + value + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: ident=1 etc., used in static parameters to type providers +

+
+ +
+
+ + ident + + : + SynType +
+
+
+ + value + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Tuple(isStruct, path, range) + + +

+ +
+
+ Full Usage: + Tuple(isStruct, path, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: type * ... * type + F# syntax: struct (type * ... * type) +

+
+ +
+
+ + isStruct + + : + bool +
+
+
+ + path + + : + SynTupleTypeSegment list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Var(typar, range) + + +

+ +
+
+ Full Usage: + Var(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: 'Var +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WithGlobalConstraints(typeName, constraints, range) + + +

+ +
+
+ Full Usage: + WithGlobalConstraints(typeName, constraints, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: typ with constraints +

+
+ +
+
+ + typeName + + : + SynType +
+
+
+ + constraints + + : + SynTypeConstraint list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypeconstraint.html b/reference/fsharp-compiler-syntax-syntypeconstraint.html new file mode 100644 index 0000000000..ea7de68e2d --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypeconstraint.html @@ -0,0 +1,1589 @@ + + + + + + + + + + + + + + + + + + SynTypeConstraint (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeConstraint Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ The unchecked abstract syntax tree of F# type constraints +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + WhereSelfConstrained(selfConstraint, range) + + +

+ +
+
+ Full Usage: + WhereSelfConstrained(selfConstraint, range) +
+
+ Parameters: +
    + + + selfConstraint + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is SomeThing<'T> +

+
+ +
+
+ + selfConstraint + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparDefaultsToType(typar, typeName, range) + + +

+ +
+
+ Full Usage: + WhereTyparDefaultsToType(typar, typeName, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + typeName + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is default ^T: type +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + typeName + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsComparable(typar, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsComparable(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar: comparison +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsDelegate(typar, typeArgs, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsDelegate(typar, typeArgs, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + typeArgs + + : + SynType list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar: delegate<'Args, unit> +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + typeArgs + + : + SynType list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsEnum(typar, typeArgs, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsEnum(typar, typeArgs, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + typeArgs + + : + SynType list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar: enum<'UnderlyingType> +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + typeArgs + + : + SynType list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsEquatable(typar, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsEquatable(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar: equality +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsReferenceType(typar, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsReferenceType(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: is 'typar: not struct +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsUnmanaged(typar, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsUnmanaged(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar: unmanaged +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparIsValueType(typar, range) + + +

+ +
+
+ Full Usage: + WhereTyparIsValueType(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax: is 'typar: struct +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparSubtypeOfType(typar, typeName, range) + + +

+ +
+
+ Full Usage: + WhereTyparSubtypeOfType(typar, typeName, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + typeName + + : + SynType + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar :> type +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + typeName + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparSupportsMember(typars, memberSig, range) + + +

+ +
+
+ Full Usage: + WhereTyparSupportsMember(typars, memberSig, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is ^T: (static member MemberName: ^T * int -> ^T) +

+
+ +
+
+ + typars + + : + SynType +
+
+
+ + memberSig + + : + SynMemberSig +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + WhereTyparSupportsNull(typar, range) + + +

+ +
+
+ Full Usage: + WhereTyparSupportsNull(typar, range) +
+
+ Parameters: +
    + + + typar + + : + SynTypar + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ F# syntax is 'typar: null +

+
+ +
+
+ + typar + + : + SynTypar +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypedefn.html b/reference/fsharp-compiler-syntax-syntypedefn.html new file mode 100644 index 0000000000..410ccbe218 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypedefn.html @@ -0,0 +1,755 @@ + + + + + + + + + + + + + + + + + + SynTypeDefn (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefn Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents a type or exception declaration 'type C = ... ' plus + any additional member definitions for the type +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynTypeDefn(typeInfo, typeRepr, members, implicitConstructor, range, trivia) + + +

+ +
+
+ Full Usage: + SynTypeDefn(typeInfo, typeRepr, members, implicitConstructor, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + typeInfo + + : + SynComponentInfo +
+
+
+ + typeRepr + + : + SynTypeDefnRepr +
+
+
+ + members + + : + SynMemberDefns +
+
+
+ + implicitConstructor + + : + SynMemberDefn option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynTypeDefnTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypedefnkind.html b/reference/fsharp-compiler-syntax-syntypedefnkind.html new file mode 100644 index 0000000000..781c8529cf --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypedefnkind.html @@ -0,0 +1,959 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the kind of a type definition whether explicit or inferred +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Abbrev + + +

+ +
+
+ Full Usage: + Abbrev +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Augmentation withKeyword + + +

+ +
+
+ Full Usage: + Augmentation withKeyword +
+
+ Parameters: +
    + + + withKeyword + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + withKeyword + + : + range +
+
+
+
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Delegate(signature, signatureInfo) + + +

+ +
+
+ Full Usage: + Delegate(signature, signatureInfo) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + signature + + : + SynType +
+
+
+ + signatureInfo + + : + SynValInfo +
+
+
+
+
+ +

+ + + IL + + +

+ +
+
+ Full Usage: + IL +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Opaque + + +

+ +
+
+ Full Usage: + Opaque +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Record + + +

+ +
+
+ Full Usage: + Record +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Struct + + +

+ +
+
+ Full Usage: + Struct +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Union + + +

+ +
+
+ Full Usage: + Union +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Unspecified + + +

+ +
+
+ Full Usage: + Unspecified +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypedefnrepr.html b/reference/fsharp-compiler-syntax-syntypedefnrepr.html new file mode 100644 index 0000000000..921227f4b9 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypedefnrepr.html @@ -0,0 +1,853 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnRepr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnRepr Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the right hand side of a type or exception declaration 'type C = ... ' plus + any additional member definitions for the type +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Exception exnRepr + + +

+ +
+
+ Full Usage: + Exception exnRepr +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An exception definition +

+
+ +
+
+ + exnRepr + + : + SynExceptionDefnRepr +
+
+
+
+
+
+ +

+ + + ObjectModel(kind, members, range) + + +

+ +
+
+ Full Usage: + ObjectModel(kind, members, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An object model type definition (class or interface) +

+
+ +
+
+ + kind + + : + SynTypeDefnKind +
+
+
+ + members + + : + SynMemberDefns +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Simple(simpleRepr, range) + + +

+ +
+
+ Full Usage: + Simple(simpleRepr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A simple type definition (record, union, abbreviation) +

+
+ +
+
+ + simpleRepr + + : + SynTypeDefnSimpleRepr +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypedefnsig.html b/reference/fsharp-compiler-syntax-syntypedefnsig.html new file mode 100644 index 0000000000..59b5fff650 --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypedefnsig.html @@ -0,0 +1,750 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnSig (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnSig Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for a type definition in a signature +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynTypeDefnSig(typeInfo, typeRepr, members, range, trivia) + + +

+ +
+
+ Full Usage: + SynTypeDefnSig(typeInfo, typeRepr, members, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ The information for a type definition in a signature +

+
+ +
+
+ + typeInfo + + : + SynComponentInfo +
+
+
+ + typeRepr + + : + SynTypeDefnSigRepr +
+
+
+ + members + + : + SynMemberSig list +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynTypeDefnSigTrivia +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html b/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html new file mode 100644 index 0000000000..83bd46514a --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypedefnsigrepr.html @@ -0,0 +1,842 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnSigRepr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnSigRepr Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for the right-hand-side of a type definition in a signature. + Note: in practice, using a discriminated union to make a distinction between + "simple" types and "object oriented" types is not particularly useful. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Exception repr + + +

+ +
+
+ Full Usage: + Exception repr +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + repr + + : + SynExceptionDefnRepr +
+
+
+
+
+ +

+ + + ObjectModel(kind, memberSigs, range) + + +

+ +
+
+ Full Usage: + ObjectModel(kind, memberSigs, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates the right right-hand-side is a class, struct, interface or other object-model type +

+
+ +
+
+ + kind + + : + SynTypeDefnKind +
+
+
+ + memberSigs + + : + SynMemberSig list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Simple(repr, range) + + +

+ +
+
+ Full Usage: + Simple(repr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates the right right-hand-side is a record, union or other simple type. +

+
+ +
+
+ + repr + + : + SynTypeDefnSimpleRepr +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html b/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html new file mode 100644 index 0000000000..df6f3475de --- /dev/null +++ b/reference/fsharp-compiler-syntax-syntypedefnsimplerepr.html @@ -0,0 +1,1343 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnSimpleRepr (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnSimpleRepr Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for the core of a simple type definition, in either signature + or implementation. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Enum(cases, range) + + +

+ +
+
+ Full Usage: + Enum(cases, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An enum type definition, type X = A = 1 | B = 2 +

+
+ +
+
+ + cases + + : + SynEnumCase list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Exception exnRepr + + +

+ +
+
+ Full Usage: + Exception exnRepr +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An exception definition, "exception E = ..." +

+
+ +
+
+ + exnRepr + + : + SynExceptionDefnRepr +
+
+
+
+
+
+ +

+ + + General(kind, inherits, slotsigs, fields, isConcrete, isIncrClass, implicitCtorSynPats, range) + + +

+ +
+
+ Full Usage: + General(kind, inherits, slotsigs, fields, isConcrete, isIncrClass, implicitCtorSynPats, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ An object oriented type definition. This is not a parse-tree form, but represents the core + type representation which the type checker splits out from the "ObjectModel" cases of type definitions. +

+
+ +
+
+ + kind + + : + SynTypeDefnKind +
+
+
+ + inherits + + : + (SynType * range * Ident option) list +
+
+
+ + slotsigs + + : + (SynValSig * SynMemberFlags) list +
+
+
+ + fields + + : + SynField list +
+
+
+ + isConcrete + + : + bool +
+
+
+ + isIncrClass + + : + bool +
+
+
+ + implicitCtorSynPats + + : + SynPat option +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + LibraryOnlyILAssembly(ilType, range) + + +

+ +
+
+ Full Usage: + LibraryOnlyILAssembly(ilType, range) +
+
+ Parameters: +
    + + + ilType + + : + obj + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A type defined by using an IL assembly representation. Only used in FSharp.Core. + + F# syntax: "type X = (# "..."#) +

+
+ +
+
+ + ilType + + : + obj +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + None range + + +

+ +
+
+ Full Usage: + None range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ An abstract definition, "type X" +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Record(accessibility, recordFields, range) + + +

+ +
+
+ Full Usage: + Record(accessibility, recordFields, range) +
+
+ Parameters: +
    + + + accessibility + + : + SynAccess option + +
    + + + recordFields + + : + SynField list + +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ A record type definition, type X = { A: int; B: int } +

+
+ +
+
+ + accessibility + + : + SynAccess option +
+
+
+ + recordFields + + : + SynField list +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + TypeAbbrev(detail, rhsType, range) + + +

+ +
+
+ Full Usage: + TypeAbbrev(detail, rhsType, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A type abbreviation, "type X = A.B.C" +

+
+ +
+
+ + detail + + : + ParserDetail +
+
+
+ + rhsType + + : + SynType +
+
+
+ + range + + : + range +
+
+
+
+
+
+ +

+ + + Union(accessibility, unionCases, range) + + +

+ +
+
+ Full Usage: + Union(accessibility, unionCases, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ A union type definition, type X = A | B +

+
+ +
+
+ + accessibility + + : + SynAccess option +
+
+
+ + unionCases + + : + SynUnionCase list +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synunioncase.html b/reference/fsharp-compiler-syntax-synunioncase.html new file mode 100644 index 0000000000..cdb101c57c --- /dev/null +++ b/reference/fsharp-compiler-syntax-synunioncase.html @@ -0,0 +1,770 @@ + + + + + + + + + + + + + + + + + + SynUnionCase (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynUnionCase Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for one case in a union definition. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynUnionCase(attributes, ident, caseType, xmlDoc, accessibility, range, trivia) + + +

+ +
+
+ Full Usage: + SynUnionCase(attributes, ident, caseType, xmlDoc, accessibility, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + ident + + : + SynIdent +
+
+
+ + caseType + + : + SynUnionCaseKind +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynUnionCaseTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the syntax range of this construct +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synunioncasekind.html b/reference/fsharp-compiler-syntax-synunioncasekind.html new file mode 100644 index 0000000000..c53ff3f224 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synunioncasekind.html @@ -0,0 +1,687 @@ + + + + + + + + + + + + + + + + + + SynUnionCaseKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynUnionCaseKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for the right-hand-side of union definition, excluding members, + in either a signature or implementation. +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Fields cases + + +

+ +
+
+ Full Usage: + Fields cases +
+
+ Parameters: +
    + + + cases + + : + SynField list + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Normal style declaration +

+
+ +
+
+ + cases + + : + SynField list +
+
+
+
+
+
+ +

+ + + FullType(fullType, fullTypeInfo) + + +

+ +
+
+ Full Usage: + FullType(fullType, fullTypeInfo) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ Full type spec given by 'UnionCase: ty1 * tyN -> rty'. Only used in FSharp.Core, otherwise a warning. +

+
+ +
+
+ + fullType + + : + SynType +
+
+
+ + fullTypeInfo + + : + SynValInfo +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synvaldata.html b/reference/fsharp-compiler-syntax-synvaldata.html new file mode 100644 index 0000000000..4a73fa8143 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synvaldata.html @@ -0,0 +1,688 @@ + + + + + + + + + + + + + + + + + + SynValData (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynValData Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents extra information about the declaration of a value +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynValData(memberFlags, valInfo, thisIdOpt) + + +

+ +
+
+ Full Usage: + SynValData(memberFlags, valInfo, thisIdOpt) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + memberFlags + + : + SynMemberFlags option +
+
+
+ + valInfo + + : + SynValInfo +
+
+
+ + thisIdOpt + + : + Ident option +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.SynValInfo + + +

+ +
+
+ Full Usage: + this.SynValInfo +
+
+ + Returns: + SynValInfo + +
+
+
+
+ 		+
+
+ + Returns: + + SynValInfo +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synvalinfo.html b/reference/fsharp-compiler-syntax-synvalinfo.html new file mode 100644 index 0000000000..3a34eab791 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synvalinfo.html @@ -0,0 +1,723 @@ + + + + + + + + + + + + + + + + + + SynValInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynValInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ The argument names and other metadata for a member or function +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynValInfo(curriedArgInfos, returnInfo) + + +

+ +
+
+ Full Usage: + SynValInfo(curriedArgInfos, returnInfo) +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+ + + +

+ SynValInfo(curriedArgInfos, returnInfo) +

+
+ +
+
+ + curriedArgInfos + + : + SynArgInfo list list +
+
+
+ + returnInfo + + : + SynArgInfo +
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ArgNames + + +

+ +
+
+ Full Usage: + this.ArgNames +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+
+ + Returns: + + string list +
+
+
+
+
+ +

+ + + this.CurriedArgInfos + + +

+ +
+
+ Full Usage: + this.CurriedArgInfos +
+
+ + Returns: + SynArgInfo list list + +
+
+
+
+ 		+
+
+ + Returns: + + SynArgInfo list list +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synvalsig.html b/reference/fsharp-compiler-syntax-synvalsig.html new file mode 100644 index 0000000000..60c52ce1c2 --- /dev/null +++ b/reference/fsharp-compiler-syntax-synvalsig.html @@ -0,0 +1,910 @@ + + + + + + + + + + + + + + + + + + SynValSig (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynValSig Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the syntax tree for a 'val' definition in an abstract slot or a signature file +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynValSig(attributes, ident, explicitTypeParams, synType, arity, isInline, isMutable, xmlDoc, accessibility, synExpr, range, trivia) + + +

+ +
+
+ Full Usage: + SynValSig(attributes, ident, explicitTypeParams, synType, arity, isInline, isMutable, xmlDoc, accessibility, synExpr, range, trivia) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + attributes + + : + SynAttributes +
+
+
+ + ident + + : + SynIdent +
+
+
+ + explicitTypeParams + + : + SynValTyparDecls +
+
+
+ + synType + + : + SynType +
+
+
+ + arity + + : + SynValInfo +
+
+
+ + isInline + + : + bool +
+
+
+ + isMutable + + : + bool +
+
+
+ + xmlDoc + + : + PreXmlDoc +
+
+
+ + accessibility + + : + SynAccess option +
+
+
+ + synExpr + + : + SynExpr option +
+
+
+ + range + + : + range +
+
+
+ + trivia + + : + SynValSigTrivia +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.RangeOfId + + +

+ +
+
+ Full Usage: + this.RangeOfId +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + this.SynInfo + + +

+ +
+
+ Full Usage: + this.SynInfo +
+
+ + Returns: + SynValInfo + +
+
+
+
+ 		+
+
+ + Returns: + + SynValInfo +
+
+
+
+
+ +

+ + + this.SynType + + +

+ +
+
+ Full Usage: + this.SynType +
+
+ + Returns: + SynType + +
+
+
+
+ 		+
+
+ + Returns: + + SynType +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-synvaltypardecls.html b/reference/fsharp-compiler-syntax-synvaltypardecls.html new file mode 100644 index 0000000000..4e8e36473b --- /dev/null +++ b/reference/fsharp-compiler-syntax-synvaltypardecls.html @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + + + SynValTyparDecls (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynValTyparDecls Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the names and other metadata for the type parameters for a member or function +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + SynValTyparDecls(typars, canInfer) + + +

+ +
+
+ Full Usage: + SynValTyparDecls(typars, canInfer) +
+
+ Parameters: +
    + + + typars + + : + SynTyparDecls option + +
    + + + canInfer + + : + bool + +
    +
+
+
+
+
+ 		+
+
+ + typars + + : + SynTyparDecls option +
+
+
+ + canInfer + + : + bool +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax-typarstaticreq.html b/reference/fsharp-compiler-syntax-typarstaticreq.html new file mode 100644 index 0000000000..b2c8c48a20 --- /dev/null +++ b/reference/fsharp-compiler-syntax-typarstaticreq.html @@ -0,0 +1,628 @@ + + + + + + + + + + + + + + + + + + TyparStaticReq (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ TyparStaticReq Type +

+
+
+ Namespace: + + FSharp.Compiler.Syntax + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<TyparStaticReq> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Represents whether a type parameter has a static requirement or not (^T or 'T) +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + HeadType + + +

+ +
+
+ Full Usage: + HeadType +
+
+
+
+
+ 		+
+ + + +

+ The construct is a statically inferred type inference variable '^T' +

+
+
+
+ +

+ + + None + + +

+ +
+
+ Full Usage: + None +
+
+
+
+
+ 		+
+ + + +

+ The construct is a normal type inference variable +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntax.html b/reference/fsharp-compiler-syntax.html new file mode 100644 index 0000000000..7d56c401e0 --- /dev/null +++ b/reference/fsharp-compiler-syntax.html @@ -0,0 +1,3069 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Syntax | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Syntax Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + DebugPointAtBinding + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for a 'let' binding, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtFinally + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for the 'finally' in a 'try .. finally', + that is whether the construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtFor + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for the 'for' in a 'for...' loop, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtInOrTo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for the 'in' or 'to' of a 'for...' loop, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtLeafExpr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a debug point at a leaf expression (e.g. an application or constant). +

+
+
+

+ + + DebugPointAtSequential + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be suppressed for either the + first or second part of a sequential execution, that is whether the + construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtTarget + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for the target + of a decision tree, that is whether the construct corresponds to a debug + point in the original source. +

+
+
+

+ + + DebugPointAtTry + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for a 'try', that is whether + the construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtWhile + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for the 'while' in a 'while...' loop, + that is whether the construct corresponds to a debug point in the original source. +

+
+
+

+ + + DebugPointAtWith + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a debug point should be present for the 'with' in a 'try .. with', + that is whether the construct corresponds to a debug point in the original source. +

+
+
+

+ + + ExprAtomicFlag + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicates if an expression is an atomic expression. + + An atomic expression has no whitespace unless enclosed in parentheses, e.g. + 1, "3", ident, ident.[expr] and (expr). If an atomic expression has type T, + then the largest expression ending at the same range as the atomic expression + also has type T. +

+
+
+

+ + + Ident + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an identifier in F# code +

+
+
+

+ + + ParsedHashDirective + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a parsed hash directive +

+
+
+

+ + + ParsedHashDirectiveArgument + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a parsed hash directive argument +

+
+
+

+ + + ParsedImplFile + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a parsed implementation file made up of fragments +

+
+
+

+ + + ParsedImplFileFragment + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for the contents of a parsed implementation file +

+
+
+

+ + + ParsedImplFileInput + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the full syntax tree, file name and other parsing information for an implementation file +

+
+
+

+ + + ParsedInput + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for a parsed implementation or signature file +

+
+
+

+ + + ParsedScriptInteraction + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a parsed syntax tree for an F# Interactive interaction +

+
+
+

+ + + ParsedSigFile + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a parsed signature file made up of fragments +

+
+
+

+ + + ParsedSigFileFragment + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for the contents of a parsed signature file +

+
+
+

+ + + ParsedSigFileInput + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the full syntax tree, file name and other parsing information for a signature file +

+
+
+

+ + + ParserDetail + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicates if the construct arises from error recovery +

+
+
+

+ + + PrettyNaming + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Some general F# utilities for mangling / unmangling / manipulating names. + Anything to do with special names of identifiers and other lexical rules +

+
+
+

+ + + QualifiedNameOfFile + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a qualifying name for anonymous module specifications and implementations, +

+
+
+

+ + + ScopedPragma + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a scoped pragma +

+
+
+

+ + + SeqExprOnly + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicates if a for loop is 'for x in e1 -> e2', only valid in sequence expressions +

+
+
+

+ + + SynAccess + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an accessibility modifier in F# syntax +

+
+
+

+ + + SynArgInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the argument names and other metadata for a parameter for a member or function +

+
+
+

+ + + SynArgPats + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntax tree for arguments patterns +

+
+
+

+ + + SynAttribute + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an attribute +

+
+
+

+ + + SynAttributeList + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ List of attributes enclosed in [< ... >]. +

+
+
+

+ + + SynBinding + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a binding for a 'let' or 'member' declaration +

+
+
+

+ + + SynBindingKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The kind associated with a binding - "let", "do" or a standalone expression +

+
+
+

+ + + SynBindingReturnInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the return information in a binding for a 'let' or 'member' declaration +

+
+
+

+ + + SynByteStringKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicate if the byte string had a special format +

+
+
+

+ + + SynComponentInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree associated with the name of a type definition or module + in signature or implementation. + + This includes the name, attributes, type parameters, constraints, documentation and accessibility + for a type definition or module. For modules, entries such as the type parameters are + always empty. +

+
+
+

+ + + SynConst + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The unchecked abstract syntax tree of constants in F# types and expressions. +

+
+
+

+ + + SynEnumCase + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for one case in an enum definition. +

+
+
+

+ + + SynExceptionDefn + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the right hand side of an exception declaration 'exception E = ... ' plus + any member definitions for the exception +

+
+
+

+ + + SynExceptionDefnRepr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the right hand side of an exception declaration 'exception E = ... ' +

+
+
+

+ + + SynExceptionSig + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the right hand side of an exception definition in a signature file +

+
+
+

+ + + SynExpr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntax tree for F# expressions +

+
+
+

+ + + SynExprAndBang + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SynExprRecordField + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SynField + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for a field declaration in a record or class +

+
+
+

+ + + SynIdent + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an identifier with potentially additional trivia information. +

+
+
+

+ + + SynInterfaceImpl + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a set of bindings that implement an interface +

+
+
+

+ + + SynInterpolatedStringPart + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SynLongIdent + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a long identifier with possible '.' at end. + + Typically dotRanges.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. "Foo.Bar." + The dots mostly matter for parsing, and are typically ignored by the typechecker, but + if dotRanges.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed + more freedom about typechecking these expressions. + LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit) +

+
+
+

+ + + SynLongIdentHelpers + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SynMatchClause + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a clause in a 'match' expression +

+
+
+

+ + + SynMeasure + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an unchecked syntax tree of F# unit of measure annotations. +

+
+
+

+ + + SynMemberDefn + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a definition element within a type definition, e.g. 'member ... ' +

+
+
+

+ + + SynMemberFlags + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the flags for a 'member' declaration +

+
+
+

+ + + SynMemberKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Note the member kind is actually computed partially by a syntax tree transformation in tc.fs +

+
+
+

+ + + SynMemberSig + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for a member signature (used in signature files, abstract member declarations + and member constraints) +

+
+
+

+ + + SynModuleDecl + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a definition within a module +

+
+
+

+ + + SynModuleOrNamespace + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the definition of a module or namespace +

+
+
+

+ + + SynModuleOrNamespaceKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the kind of a module or namespace definition +

+
+
+

+ + + SynModuleOrNamespaceSig + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the definition of a module or namespace in a signature file +

+
+
+

+ + + SynModuleSigDecl + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a definition within a module or namespace in a signature file +

+
+
+

+ + + SynOpenDeclTarget + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the target of the open declaration +

+
+
+

+ + + SynPat + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntax tree for an F# pattern +

+
+
+

+ + + SynRationalConst + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an unchecked syntax tree of F# unit of measure exponents. +

+
+
+

+ + + SynReturnInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntactic elements associated with the "return" of a function or method. +

+
+
+

+ + + SynSimplePat + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntax tree for simple F# patterns +

+
+
+

+ + + SynSimplePatAlternativeIdInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the alternative identifier for a simple pattern +

+
+
+

+ + + SynSimplePats + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a simple set of variable bindings a, (a, b) or (a: Type, b: Type) at a lambda, + function definition or other binding point, after the elimination of pattern matching + from the construct, e.g. after changing a "function pat1 -> rule1 | ..." to a + "fun v -> match v with ..." +

+
+
+

+ + + SynStaticOptimizationConstraint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntax tree for a static optimization constraint in the F# core library +

+
+
+

+ + + SynStringKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Indicate if the string had a special format +

+
+
+

+ + + SyntaxNode + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Used to track route during traversal of syntax using SyntaxTraversal.Traverse +

+
+
+

+ + + SyntaxTraversal + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SyntaxVisitorBase<'T> + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SynTupleTypeSegment + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + SynTypar + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntactic type parameter +

+
+
+

+ + + SynTyparDecl + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the explicit declaration of a type parameter +

+
+
+

+ + + SynTyparDecls + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ List of type parameter declarations with optional type constraints, + enclosed in `< ... >` (postfix) or `( ... )` (prefix), or a single prefix parameter. +

+
+
+

+ + + SynType + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a syntax tree for F# types +

+
+
+

+ + + SynTypeConstraint + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The unchecked abstract syntax tree of F# type constraints +

+
+
+

+ + + SynTypeDefn + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a type or exception declaration 'type C = ... ' plus + any additional member definitions for the type +

+
+
+

+ + + SynTypeDefnKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the kind of a type definition whether explicit or inferred +

+
+
+

+ + + SynTypeDefnRepr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the right hand side of a type or exception declaration 'type C = ... ' plus + any additional member definitions for the type +

+
+
+

+ + + SynTypeDefnSig + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for a type definition in a signature +

+
+
+

+ + + SynTypeDefnSigRepr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for the right-hand-side of a type definition in a signature. + Note: in practice, using a discriminated union to make a distinction between + "simple" types and "object oriented" types is not particularly useful. +

+
+
+

+ + + SynTypeDefnSimpleRepr + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for the core of a simple type definition, in either signature + or implementation. +

+
+
+

+ + + SynUnionCase + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for one case in a union definition. +

+
+
+

+ + + SynUnionCaseKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for the right-hand-side of union definition, excluding members, + in either a signature or implementation. +

+
+
+

+ + + SynValData + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents extra information about the declaration of a value +

+
+
+

+ + + SynValInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ The argument names and other metadata for a member or function +

+
+
+

+ + + SynValSig + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the syntax tree for a 'val' definition in an abstract slot or a signature file +

+
+
+

+ + + SynValTyparDecls + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the names and other metadata for the type parameters for a member or function +

+
+
+

+ + + TyparStaticReq + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents whether a type parameter has a static requirement or not (^T or 'T) +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-commenttrivia.html b/reference/fsharp-compiler-syntaxtrivia-commenttrivia.html new file mode 100644 index 0000000000..aa7311902f --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-commenttrivia.html @@ -0,0 +1,646 @@ + + + + + + + + + + + + + + + + + + CommentTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ CommentTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + BlockComment range + + +

+ +
+
+ Full Usage: + BlockComment range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + LineComment range + + +

+ +
+
+ Full Usage: + LineComment range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html b/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html new file mode 100644 index 0000000000..d43a3d7c94 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-conditionaldirectivetrivia.html @@ -0,0 +1,709 @@ + + + + + + + + + + + + + + + + + + ConditionalDirectiveTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ConditionalDirectiveTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Else range + + +

+ +
+
+ Full Usage: + Else range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + EndIf range + + +

+ +
+
+ Full Usage: + EndIf range +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + range + + : + range +
+
+
+
+
+ +

+ + + If(expr, range) + + +

+ +
+
+ Full Usage: + If(expr, range) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + expr + + : + IfDirectiveExpression +
+
+
+ + range + + : + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html b/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html new file mode 100644 index 0000000000..b679582b61 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-getsetkeywords.html @@ -0,0 +1,766 @@ + + + + + + + + + + + + + + + + + + GetSetKeywords (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ GetSetKeywords Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for `get, set` syntax +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Get range + + +

+ +
+
+ Full Usage: + Get range +
+
+ Parameters: +
    + + + Item + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + range +
+
+
+
+
+ +

+ + + GetSet(get, set) + + +

+ +
+
+ Full Usage: + GetSet(get, set) +
+
+ Parameters: +
    + + + get + + : + range + +
    + + + set + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + get + + : + range +
+
+
+ + set + + : + range +
+
+
+
+
+ +

+ + + Set range + + +

+ +
+
+ Full Usage: + Set range +
+
+ Parameters: +
    + + + Item + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-identtrivia.html b/reference/fsharp-compiler-syntaxtrivia-identtrivia.html new file mode 100644 index 0000000000..ecbeaee92e --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-identtrivia.html @@ -0,0 +1,783 @@ + + + + + + + + + + + + + + + + + + IdentTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IdentTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + HasParenthesis(leftParenRange, rightParenRange) + + +

+ +
+
+ Full Usage: + HasParenthesis(leftParenRange, rightParenRange) +
+
+ Parameters: +
    + + + leftParenRange + + : + range + +
    + + + rightParenRange + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ The ident had parenthesis + Example: let (|Odd|Even|) = ... + The active pattern ident will be "|Odd|Even|", while originally there were parenthesis. +

+
+ +
+
+ + leftParenRange + + : + range +
+
+
+ + rightParenRange + + : + range +
+
+
+
+
+
+ +

+ + + OriginalNotation text + + +

+ +
+
+ Full Usage: + OriginalNotation text +
+
+ Parameters: +
    + + + text + + : + string + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ The ident originally had a different notation. + Example: a + b + The operator ident will be compiled into "op_Addition", while the original notation was "+" +

+
+ +
+
+ + text + + : + string +
+
+
+
+
+
+ +

+ + + OriginalNotationWithParen(leftParenRange, text, rightParenRange) + + +

+ +
+
+ Full Usage: + OriginalNotationWithParen(leftParenRange, text, rightParenRange) +
+
+ Parameters: +
    + + + leftParenRange + + : + range + +
    + + + text + + : + string + +
    + + + rightParenRange + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ The ident originally had a different notation and parenthesis + Example: let (>=>) a b = ... + The operator ident will be compiled into "op_GreaterEqualsGreater", while the original notation was ">=>" and had parenthesis +

+
+ +
+
+ + leftParenRange + + : + range +
+
+
+ + text + + : + string +
+
+
+ + rightParenRange + + : + range +
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html b/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html new file mode 100644 index 0000000000..eef47b540a --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-ifdirectiveexpression.html @@ -0,0 +1,772 @@ + + + + + + + + + + + + + + + + + + IfDirectiveExpression (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ IfDirectiveExpression Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + And(IfDirectiveExpression, IfDirectiveExpression) + + +

+ +
+
+ Full Usage: + And(IfDirectiveExpression, IfDirectiveExpression) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item1 + + : + IfDirectiveExpression +
+
+
+ + Item2 + + : + IfDirectiveExpression +
+
+
+
+
+ +

+ + + Ident string + + +

+ +
+
+ Full Usage: + Ident string +
+
+ Parameters: +
    + + + Item + + : + string + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + string +
+
+
+
+
+ +

+ + + Not IfDirectiveExpression + + +

+ +
+
+ Full Usage: + Not IfDirectiveExpression +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item + + : + IfDirectiveExpression +
+
+
+
+
+ +

+ + + Or(IfDirectiveExpression, IfDirectiveExpression) + + +

+ +
+
+ Full Usage: + Or(IfDirectiveExpression, IfDirectiveExpression) +
+
+ Parameters: + +
+
+
+
+ 		+
+
+ + Item1 + + : + IfDirectiveExpression +
+
+
+ + Item2 + + : + IfDirectiveExpression +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-parsedimplfileinputtrivia.html b/reference/fsharp-compiler-syntaxtrivia-parsedimplfileinputtrivia.html new file mode 100644 index 0000000000..776252d319 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-parsedimplfileinputtrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + ParsedImplFileInputTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedImplFileInputTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for ParsedImplFileInput +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CodeComments + + +

+ +
+
+ Full Usage: + CodeComments +
+
+ + Field type: + CommentTrivia list + +
+
+
+
+ 		+
+ +
+ + + +

+ Represent code comments found in the source file +

+
+ +
+
+ + Field type: + + CommentTrivia list +
+
+
+
+
+
+ +

+ + + ConditionalDirectives + + +

+ +
+
+ Full Usage: + ConditionalDirectives +
+
+ + Field type: + ConditionalDirectiveTrivia list + +
+
+
+
+ 		+
+ +
+ + + +

+ Preprocessor directives of type #if, #else or #endif +

+
+ +
+
+ + Field type: + + ConditionalDirectiveTrivia list +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-parsedsigfileinputtrivia.html b/reference/fsharp-compiler-syntaxtrivia-parsedsigfileinputtrivia.html new file mode 100644 index 0000000000..4008c8f02b --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-parsedsigfileinputtrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + ParsedSigFileInputTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ParsedSigFileInputTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for ParsedSigFileInputTrivia +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CodeComments + + +

+ +
+
+ Full Usage: + CodeComments +
+
+ + Field type: + CommentTrivia list + +
+
+
+
+ 		+
+ +
+ + + +

+ Represent code comments found in the source file +

+
+ +
+
+ + Field type: + + CommentTrivia list +
+
+
+
+
+
+ +

+ + + ConditionalDirectives + + +

+ +
+
+ Full Usage: + ConditionalDirectives +
+
+ + Field type: + ConditionalDirectiveTrivia list + +
+
+
+
+ 		+
+ +
+ + + +

+ Preprocessor directives of type #if, #else or #endif +

+
+ +
+
+ + Field type: + + ConditionalDirectiveTrivia list +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synargpatsnamepatpairstrivia.html b/reference/fsharp-compiler-syntaxtrivia-synargpatsnamepatpairstrivia.html new file mode 100644 index 0000000000..b54f4ef30c --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synargpatsnamepatpairstrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynArgPatsNamePatPairsTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynArgPatsNamePatPairsTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynArgPats.NamePatPairs +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ParenRange + + +

+ +
+
+ Full Usage: + ParenRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range from the beginning of the `(` token till the end of the `)` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synbindingreturninfotrivia.html b/reference/fsharp-compiler-syntaxtrivia-synbindingreturninfotrivia.html new file mode 100644 index 0000000000..671d8825e1 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synbindingreturninfotrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynBindingReturnInfoTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynBindingReturnInfoTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynBindingReturnInfo +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ColonRange + + +

+ +
+
+ Full Usage: + ColonRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `:` token +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html new file mode 100644 index 0000000000..8c9140bc03 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synbindingtrivia.html @@ -0,0 +1,762 @@ + + + + + + + + + + + + + + + + + + SynBindingTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynBindingTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynBinding +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + InlineKeyword + + +

+ +
+
+ Full Usage: + InlineKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `inline` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ Used leading keyword of SynBinding +

+
+ +
+
+ + Field type: + + SynLeadingKeyword +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynBindingTrivia.Zero + + +

+ +
+
+ Full Usage: + SynBindingTrivia.Zero +
+
+ + Returns: + SynBindingTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynBindingTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synenumcasetrivia.html b/reference/fsharp-compiler-syntaxtrivia-synenumcasetrivia.html new file mode 100644 index 0000000000..6ea3c9fdf8 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synenumcasetrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + SynEnumCaseTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynEnumCaseTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + BarRange + + +

+ +
+
+ Full Usage: + BarRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `|` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprandbangtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprandbangtrivia.html new file mode 100644 index 0000000000..a5cc16aac4 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprandbangtrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + SynExprAndBangTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprAndBangTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExprAndBang +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + InKeyword + + +

+ +
+
+ Full Usage: + InKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `in` keyword. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexpranonrecdtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexpranonrecdtrivia.html new file mode 100644 index 0000000000..d344994163 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexpranonrecdtrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynExprAnonRecdTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprAnonRecdTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.AnonRecd +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + OpeningBraceRange + + +

+ +
+
+ Full Usage: + OpeningBraceRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `{|` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprdotlambdatrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprdotlambdatrivia.html new file mode 100644 index 0000000000..ce4c38795a --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprdotlambdatrivia.html @@ -0,0 +1,630 @@ + + + + + + + + + + + + + + + + + + SynExprDotLambdaTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprDotLambdaTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.DotLambda +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + DotRange + + +

+ +
+
+ Full Usage: + DotRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+ +

+ + + UnderscoreRange + + +

+ +
+
+ Full Usage: + UnderscoreRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html new file mode 100644 index 0000000000..eb348b032a --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprifthenelsetrivia.html @@ -0,0 +1,807 @@ + + + + + + + + + + + + + + + + + + SynExprIfThenElseTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprIfThenElseTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.IfThenElse +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ElseKeyword + + +

+ +
+
+ Full Usage: + ElseKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `else` keyword. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + IfKeyword + + +

+ +
+
+ Full Usage: + IfKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `if` keyword. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + IfToThenRange + + +

+ +
+
+ Full Usage: + IfToThenRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range from the beginning of the `if` keyword till the end of the `then` keyword. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + IsElif + + +

+ +
+
+ Full Usage: + IsElif +
+
+ + Field type: + bool + +
+
+
+
+ 		+
+ +
+ + + +

+ Indicates if the `elif` keyword was used +

+
+ +
+
+ + Field type: + + bool +
+
+
+
+
+
+ +

+ + + ThenKeyword + + +

+ +
+
+ Full Usage: + ThenKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `then` keyword. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprlambdatrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprlambdatrivia.html new file mode 100644 index 0000000000..b20e2fbfa2 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprlambdatrivia.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + SynExprLambdaTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprLambdaTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.Lambda +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ArrowRange + + +

+ +
+
+ Full Usage: + ArrowRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `->` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynExprLambdaTrivia.Zero + + +

+ +
+
+ Full Usage: + SynExprLambdaTrivia.Zero +
+
+ + Returns: + SynExprLambdaTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynExprLambdaTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprletorusebangtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprletorusebangtrivia.html new file mode 100644 index 0000000000..2d56588a1a --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprletorusebangtrivia.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + SynExprLetOrUseBangTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprLetOrUseBangTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.LetOrUseBang +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynExprLetOrUseBangTrivia.Zero + + +

+ +
+
+ Full Usage: + SynExprLetOrUseBangTrivia.Zero +
+
+ + Returns: + SynExprLetOrUseBangTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynExprLetOrUseBangTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprletorusetrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprletorusetrivia.html new file mode 100644 index 0000000000..87efcc424e --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprletorusetrivia.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + SynExprLetOrUseTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprLetOrUseTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.LetOrUse +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + InKeyword + + +

+ +
+
+ Full Usage: + InKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `in` keyword. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynExprLetOrUseTrivia.Zero + + +

+ +
+
+ Full Usage: + SynExprLetOrUseTrivia.Zero +
+
+ + Returns: + SynExprLetOrUseTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynExprLetOrUseTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprmatchbangtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprmatchbangtrivia.html new file mode 100644 index 0000000000..70bac372a1 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprmatchbangtrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + SynExprMatchBangTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprMatchBangTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.MatchBang +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + MatchBangKeyword + + +

+ +
+
+ Full Usage: + MatchBangKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `match!` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprmatchtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprmatchtrivia.html new file mode 100644 index 0000000000..54fdce991f --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprmatchtrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + SynExprMatchTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprMatchTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.Match +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + MatchKeyword + + +

+ +
+
+ Full Usage: + MatchKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `match` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprtryfinallytrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprtryfinallytrivia.html new file mode 100644 index 0000000000..607d1fca85 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprtryfinallytrivia.html @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + SynExprTryFinallyTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprTryFinallyTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.TryFinally +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + FinallyKeyword + + +

+ +
+
+ Full Usage: + FinallyKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `finally` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + TryKeyword + + +

+ +
+
+ Full Usage: + TryKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `try` keyword. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html new file mode 100644 index 0000000000..6cdc49906e --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synexprtrywithtrivia.html @@ -0,0 +1,756 @@ + + + + + + + + + + + + + + + + + + SynExprTryWithTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynExprTryWithTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynExpr.TryWith +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + TryKeyword + + +

+ +
+
+ Full Usage: + TryKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `try` keyword. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + TryToWithRange + + +

+ +
+
+ Full Usage: + TryToWithRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range from the beginning of the `try` keyword till the end of the `with` keyword. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+ +

+ + + WithToEndRange + + +

+ +
+
+ Full Usage: + WithToEndRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range from the beginning of the `with` keyword till the end of the TryWith expression. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html new file mode 100644 index 0000000000..f9e1667111 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synfieldtrivia.html @@ -0,0 +1,711 @@ + + + + + + + + + + + + + + + + + + SynFieldTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynFieldTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynField +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynLeadingKeyword option + +
+
+
+
+ 		+
+ +
+ + + +

+ Used leading keyword of SynField +

+
+ +
+
+ + Field type: + + SynLeadingKeyword option +
+
+
+
+
+
+ +

+ + + MutableKeyword + + +

+ +
+
+ Full Usage: + MutableKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `mutable` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynFieldTrivia.Zero + + +

+ +
+
+ Full Usage: + SynFieldTrivia.Zero +
+
+ + Returns: + SynFieldTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynFieldTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html b/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html new file mode 100644 index 0000000000..51a7bf9436 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synleadingkeyword.html @@ -0,0 +1,2136 @@ + + + + + + + + + + + + + + + + + + SynLeadingKeyword (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynLeadingKeyword Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the leading keyword in a SynBinding or SynValSig +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Abstract abstractRange + + +

+ +
+
+ Full Usage: + Abstract abstractRange +
+
+ Parameters: +
    + + + abstractRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + abstractRange + + : + range +
+
+
+
+
+ +

+ + + AbstractMember(abstractRange, memberRange) + + +

+ +
+
+ Full Usage: + AbstractMember(abstractRange, memberRange) +
+
+ Parameters: +
    + + + abstractRange + + : + range + +
    + + + memberRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + abstractRange + + : + range +
+
+
+ + memberRange + + : + range +
+
+
+
+
+ +

+ + + And andRange + + +

+ +
+
+ Full Usage: + And andRange +
+
+ Parameters: +
    + + + andRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + andRange + + : + range +
+
+
+
+
+ +

+ + + Default defaultRange + + +

+ +
+
+ Full Usage: + Default defaultRange +
+
+ Parameters: +
    + + + defaultRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + defaultRange + + : + range +
+
+
+
+
+ +

+ + + DefaultVal(defaultRange, valRange) + + +

+ +
+
+ Full Usage: + DefaultVal(defaultRange, valRange) +
+
+ Parameters: +
    + + + defaultRange + + : + range + +
    + + + valRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + defaultRange + + : + range +
+
+
+ + valRange + + : + range +
+
+
+
+
+ +

+ + + Do doRange + + +

+ +
+
+ Full Usage: + Do doRange +
+
+ Parameters: +
    + + + doRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + doRange + + : + range +
+
+
+
+
+ +

+ + + Extern externRange + + +

+ +
+
+ Full Usage: + Extern externRange +
+
+ Parameters: +
    + + + externRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + externRange + + : + range +
+
+
+
+
+ +

+ + + Let letRange + + +

+ +
+
+ Full Usage: + Let letRange +
+
+ Parameters: +
    + + + letRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + letRange + + : + range +
+
+
+
+
+ +

+ + + LetRec(letRange, recRange) + + +

+ +
+
+ Full Usage: + LetRec(letRange, recRange) +
+
+ Parameters: +
    + + + letRange + + : + range + +
    + + + recRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + letRange + + : + range +
+
+
+ + recRange + + : + range +
+
+
+
+
+ +

+ + + Member memberRange + + +

+ +
+
+ Full Usage: + Member memberRange +
+
+ Parameters: +
    + + + memberRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + memberRange + + : + range +
+
+
+
+
+ +

+ + + MemberVal(memberRange, valRange) + + +

+ +
+
+ Full Usage: + MemberVal(memberRange, valRange) +
+
+ Parameters: +
    + + + memberRange + + : + range + +
    + + + valRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + memberRange + + : + range +
+
+
+ + valRange + + : + range +
+
+
+
+
+ +

+ + + New newRange + + +

+ +
+
+ Full Usage: + New newRange +
+
+ Parameters: +
    + + + newRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + newRange + + : + range +
+
+
+
+
+ +

+ + + Override overrideRange + + +

+ +
+
+ Full Usage: + Override overrideRange +
+
+ Parameters: +
    + + + overrideRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + overrideRange + + : + range +
+
+
+
+
+ +

+ + + OverrideVal(overrideRange, valRange) + + +

+ +
+
+ Full Usage: + OverrideVal(overrideRange, valRange) +
+
+ Parameters: +
    + + + overrideRange + + : + range + +
    + + + valRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + overrideRange + + : + range +
+
+
+ + valRange + + : + range +
+
+
+
+
+ +

+ + + Static staticRange + + +

+ +
+
+ Full Usage: + Static staticRange +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+
+
+ +

+ + + StaticAbstract(staticRange, abstractRange) + + +

+ +
+
+ Full Usage: + StaticAbstract(staticRange, abstractRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + abstractRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + abstractRange + + : + range +
+
+
+
+
+ +

+ + + StaticAbstractMember(staticRange, abstractMember, memberRange) + + +

+ +
+
+ Full Usage: + StaticAbstractMember(staticRange, abstractMember, memberRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + abstractMember + + : + range + +
    + + + memberRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + abstractMember + + : + range +
+
+
+ + memberRange + + : + range +
+
+
+
+
+ +

+ + + StaticDo(staticRange, doRange) + + +

+ +
+
+ Full Usage: + StaticDo(staticRange, doRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + doRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + doRange + + : + range +
+
+
+
+
+ +

+ + + StaticLet(staticRange, letRange) + + +

+ +
+
+ Full Usage: + StaticLet(staticRange, letRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + letRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + letRange + + : + range +
+
+
+
+
+ +

+ + + StaticLetRec(staticRange, letRange, recRange) + + +

+ +
+
+ Full Usage: + StaticLetRec(staticRange, letRange, recRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + letRange + + : + range + +
    + + + recRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + letRange + + : + range +
+
+
+ + recRange + + : + range +
+
+
+
+
+ +

+ + + StaticMember(staticRange, memberRange) + + +

+ +
+
+ Full Usage: + StaticMember(staticRange, memberRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + memberRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + memberRange + + : + range +
+
+
+
+
+ +

+ + + StaticMemberVal(staticRange, memberRange, valRange) + + +

+ +
+
+ Full Usage: + StaticMemberVal(staticRange, memberRange, valRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + memberRange + + : + range + +
    + + + valRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + memberRange + + : + range +
+
+
+ + valRange + + : + range +
+
+
+
+
+ +

+ + + StaticVal(staticRange, valRange) + + +

+ +
+
+ Full Usage: + StaticVal(staticRange, valRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + valRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + staticRange + + : + range +
+
+
+ + valRange + + : + range +
+
+
+
+
+ +

+ + + Synthetic + + +

+ +
+
+ Full Usage: + Synthetic +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Use useRange + + +

+ +
+
+ Full Usage: + Use useRange +
+
+ Parameters: +
    + + + useRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + useRange + + : + range +
+
+
+
+
+ +

+ + + UseRec(useRange, recRange) + + +

+ +
+
+ Full Usage: + UseRec(useRange, recRange) +
+
+ Parameters: +
    + + + useRange + + : + range + +
    + + + recRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + useRange + + : + range +
+
+
+ + recRange + + : + range +
+
+
+
+
+ +

+ + + Val valRange + + +

+ +
+
+ Full Usage: + Val valRange +
+
+ Parameters: +
    + + + valRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + valRange + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html new file mode 100644 index 0000000000..1db51decbb --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmatchclausetrivia.html @@ -0,0 +1,711 @@ + + + + + + + + + + + + + + + + + + SynMatchClauseTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMatchClauseTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynMatchClause +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ArrowRange + + +

+ +
+
+ Full Usage: + ArrowRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `->` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + BarRange + + +

+ +
+
+ Full Usage: + BarRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `|` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynMatchClauseTrivia.Zero + + +

+ +
+
+ Full Usage: + SynMatchClauseTrivia.Zero +
+
+ + Returns: + SynMatchClauseTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynMatchClauseTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmeasureconstanttrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmeasureconstanttrivia.html new file mode 100644 index 0000000000..4e57a02723 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmeasureconstanttrivia.html @@ -0,0 +1,630 @@ + + + + + + + + + + + + + + + + + + SynMeasureConstantTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMeasureConstantTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynConst.Measure +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + GreaterRange + + +

+ +
+
+ Full Usage: + GreaterRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+ +

+ + + LessRange + + +

+ +
+
+ Full Usage: + LessRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmemberdefnabstractslottrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmemberdefnabstractslottrivia.html new file mode 100644 index 0000000000..63a34f1279 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmemberdefnabstractslottrivia.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + SynMemberDefnAbstractSlotTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberDefnAbstractSlotTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynMemberDefn.AbstractSlot +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + GetSetKeywords + + +

+ +
+
+ Full Usage: + GetSetKeywords +
+
+ + Field type: + GetSetKeywords option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of 'get, set' +

+
+ +
+
+ + Field type: + + GetSetKeywords option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynMemberDefnAbstractSlotTrivia.Zero + + +

+ +
+
+ Full Usage: + SynMemberDefnAbstractSlotTrivia.Zero +
+
+ + Returns: + SynMemberDefnAbstractSlotTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynMemberDefnAbstractSlotTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html new file mode 100644 index 0000000000..bd6c1da648 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmemberdefnautopropertytrivia.html @@ -0,0 +1,756 @@ + + + + + + + + + + + + + + + + + + SynMemberDefnAutoPropertyTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberDefnAutoPropertyTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynMemberDefn.AutoProperty +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + GetSetKeywords + + +

+ +
+
+ Full Usage: + GetSetKeywords +
+
+ + Field type: + GetSetKeywords option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of 'get, set' +

+
+ +
+
+ + Field type: + + GetSetKeywords option +
+
+
+
+
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ Used leading keyword of AutoProperty +

+
+ +
+
+ + Field type: + + SynLeadingKeyword +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmemberdefnimplicitctortrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmemberdefnimplicitctortrivia.html new file mode 100644 index 0000000000..7ce75ada71 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmemberdefnimplicitctortrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynMemberDefnImplicitCtorTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberDefnImplicitCtorTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynMemberDefn.ImplicitCtor +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AsKeyword + + +

+ +
+
+ Full Usage: + AsKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `as` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html new file mode 100644 index 0000000000..d3c29bb6f4 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmembergetsettrivia.html @@ -0,0 +1,807 @@ + + + + + + + + + + + + + + + + + + SynMemberGetSetTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberGetSetTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynMemberDefn.GetSetMember +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AndKeyword + + +

+ +
+
+ Full Usage: + AndKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `and` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + GetKeyword + + +

+ +
+
+ Full Usage: + GetKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `get` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + InlineKeyword + + +

+ +
+
+ Full Usage: + InlineKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `inline` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + SetKeyword + + +

+ +
+
+ Full Usage: + SetKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `set` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmembersigmembertrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmembersigmembertrivia.html new file mode 100644 index 0000000000..a186b4891f --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmembersigmembertrivia.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + SynMemberSigMemberTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynMemberSigMemberTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynMemberSig.Member +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + GetSetKeywords + + +

+ +
+
+ Full Usage: + GetSetKeywords +
+
+ + Field type: + GetSetKeywords option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of 'get, set' +

+
+ +
+
+ + Field type: + + GetSetKeywords option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynMemberSigMemberTrivia.Zero + + +

+ +
+
+ Full Usage: + SynMemberSigMemberTrivia.Zero +
+
+ + Returns: + SynMemberSigMemberTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynMemberSigMemberTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html new file mode 100644 index 0000000000..fddb154b24 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmoduledeclnestedmoduletrivia.html @@ -0,0 +1,711 @@ + + + + + + + + + + + + + + + + + + SynModuleDeclNestedModuleTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleDeclNestedModuleTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynModuleDecl.NestedModule +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + ModuleKeyword + + +

+ +
+
+ Full Usage: + ModuleKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `module` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynModuleDeclNestedModuleTrivia.Zero + + +

+ +
+
+ Full Usage: + SynModuleDeclNestedModuleTrivia.Zero +
+
+ + Returns: + SynModuleDeclNestedModuleTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynModuleDeclNestedModuleTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html b/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html new file mode 100644 index 0000000000..c9c8b30273 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespaceleadingkeyword.html @@ -0,0 +1,679 @@ + + + + + + + + + + + + + + + + + + SynModuleOrNamespaceLeadingKeyword (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleOrNamespaceLeadingKeyword Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the leading keyword in a SynModuleOrNamespace or SynModuleOrNamespaceSig +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Module moduleRange + + +

+ +
+
+ Full Usage: + Module moduleRange +
+
+ Parameters: +
    + + + moduleRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + moduleRange + + : + range +
+
+
+
+
+ +

+ + + Namespace namespaceRange + + +

+ +
+
+ Full Usage: + Namespace namespaceRange +
+
+ Parameters: +
    + + + namespaceRange + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + namespaceRange + + : + range +
+
+
+
+
+ +

+ + + None + + +

+ +
+
+ Full Usage: + None +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacesigtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacesigtrivia.html new file mode 100644 index 0000000000..5fe24fb3fe --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacesigtrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynModuleOrNamespaceSigTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleOrNamespaceSigTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynModuleOrNamespaceSig +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynModuleOrNamespaceLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `module` or `namespace` keyword +

+
+ +
+
+ + Field type: + + SynModuleOrNamespaceLeadingKeyword +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacetrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacetrivia.html new file mode 100644 index 0000000000..d396c68e02 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmoduleornamespacetrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynModuleOrNamespaceTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleOrNamespaceTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynModuleOrNamespace +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynModuleOrNamespaceLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `module` or `namespace` keyword +

+
+ +
+
+ + Field type: + + SynModuleOrNamespaceLeadingKeyword +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html b/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html new file mode 100644 index 0000000000..95babb2ac3 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synmodulesigdeclnestedmoduletrivia.html @@ -0,0 +1,711 @@ + + + + + + + + + + + + + + + + + + SynModuleSigDeclNestedModuleTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynModuleSigDeclNestedModuleTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynModuleSigDecl.NestedModule +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + ModuleKeyword + + +

+ +
+
+ Full Usage: + ModuleKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `module` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynModuleSigDeclNestedModuleTrivia.Zero + + +

+ +
+
+ Full Usage: + SynModuleSigDeclNestedModuleTrivia.Zero +
+
+ + Returns: + SynModuleSigDeclNestedModuleTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynModuleSigDeclNestedModuleTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synpatlistconstrivia.html b/reference/fsharp-compiler-syntaxtrivia-synpatlistconstrivia.html new file mode 100644 index 0000000000..5b13a4e930 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synpatlistconstrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynPatListConsTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynPatListConsTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynPat.Cons +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ColonColonRange + + +

+ +
+
+ Full Usage: + ColonColonRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `::` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synpatortrivia.html b/reference/fsharp-compiler-syntaxtrivia-synpatortrivia.html new file mode 100644 index 0000000000..f43e883c40 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synpatortrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynPatOrTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynPatOrTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynPat.Or +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + BarRange + + +

+ +
+
+ Full Usage: + BarRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `|` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-syntypardecltrivia.html b/reference/fsharp-compiler-syntaxtrivia-syntypardecltrivia.html new file mode 100644 index 0000000000..caa081d7ef --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-syntypardecltrivia.html @@ -0,0 +1,660 @@ + + + + + + + + + + + + + + + + + + SynTyparDeclTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTyparDeclTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynTyparDecl +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + AmpersandRanges + + +

+ +
+
+ Full Usage: + AmpersandRanges +
+
+ + Field type: + range list + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax ranges of the `&` tokens +

+
+ +
+
+ + Field type: + + range list +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynTyparDeclTrivia.Zero + + +

+ +
+
+ Full Usage: + SynTyparDeclTrivia.Zero +
+
+ + Returns: + SynTyparDeclTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynTyparDeclTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html b/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html new file mode 100644 index 0000000000..2763259e2f --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-syntypedefnleadingkeyword.html @@ -0,0 +1,811 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnLeadingKeyword (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnLeadingKeyword Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the leading keyword in a SynTypeDefn or SynTypeDefnSig +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + And range + + +

+ +
+
+ Full Usage: + And range +
+
+ Parameters: +
    + + + Item + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + range +
+
+
+
+
+ +

+ + + StaticType(staticRange, typeRange) + + +

+ +
+
+ Full Usage: + StaticType(staticRange, typeRange) +
+
+ Parameters: +
    + + + staticRange + + : + range + +
    + + + typeRange + + : + range + +
    +
+
+
+
+
+ 		+
+ +
+ + + +

+ Can happen in SynMemberDefn.NestedType or SynMemberSig.NestedType +

+
+ +
+
+ + staticRange + + : + range +
+
+
+ + typeRange + + : + range +
+
+
+
+
+
+ +

+ + + Synthetic + + +

+ +
+
+ Full Usage: + Synthetic +
+
+
+
+
+ 		+
+ + + +

+ Produced during type checking, should not be used in actual parsed trees. +

+
+
+
+ +

+ + + Type range + + +

+ +
+
+ Full Usage: + Type range +
+
+ Parameters: +
    + + + Item + + : + range + +
    +
+
+
+
+
+ 		+
+
+ + Item + + : + range +
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html b/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html new file mode 100644 index 0000000000..b63c6837d7 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-syntypedefnsigtrivia.html @@ -0,0 +1,762 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnSigTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnSigTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynTypeDefnSig +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynTypeDefnLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `type` or `and` keyword. +

+
+ +
+
+ + Field type: + + SynTypeDefnLeadingKeyword +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynTypeDefnSigTrivia.Zero + + +

+ +
+
+ Full Usage: + SynTypeDefnSigTrivia.Zero +
+
+ + Returns: + SynTypeDefnSigTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynTypeDefnSigTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html b/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html new file mode 100644 index 0000000000..1e06a72721 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-syntypedefntrivia.html @@ -0,0 +1,762 @@ + + + + + + + + + + + + + + + + + + SynTypeDefnTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeDefnTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynTypeDefn +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynTypeDefnLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `type` or `and` keyword. +

+
+ +
+
+ + Field type: + + SynTypeDefnLeadingKeyword +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynTypeDefnTrivia.Zero + + +

+ +
+
+ Full Usage: + SynTypeDefnTrivia.Zero +
+
+ + Returns: + SynTypeDefnTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynTypeDefnTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-syntypefuntrivia.html b/reference/fsharp-compiler-syntaxtrivia-syntypefuntrivia.html new file mode 100644 index 0000000000..d424940482 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-syntypefuntrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynTypeFunTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeFunTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynType.Fun +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ArrowRange + + +

+ +
+
+ Full Usage: + ArrowRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `->` token. +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-syntypeortrivia.html b/reference/fsharp-compiler-syntaxtrivia-syntypeortrivia.html new file mode 100644 index 0000000000..6968ff05bc --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-syntypeortrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynTypeOrTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynTypeOrTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynType.Or +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + OrKeyword + + +

+ +
+
+ Full Usage: + OrKeyword +
+
+ + Field type: + range + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `or` keyword +

+
+ +
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synunioncasetrivia.html b/reference/fsharp-compiler-syntaxtrivia-synunioncasetrivia.html new file mode 100644 index 0000000000..06890557b7 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synunioncasetrivia.html @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + SynUnionCaseTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynUnionCaseTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynUnionCase +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + BarRange + + +

+ +
+
+ Full Usage: + BarRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `|` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html b/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html new file mode 100644 index 0000000000..9caee54645 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia-synvalsigtrivia.html @@ -0,0 +1,815 @@ + + + + + + + + + + + + + + + + + + SynValSigTrivia (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SynValSigTrivia Type +

+
+
+ Namespace: + + FSharp.Compiler.SyntaxTrivia + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents additional information for SynValSig +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + EqualsRange + + +

+ +
+
+ Full Usage: + EqualsRange +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `=` token. +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + InlineKeyword + + +

+ +
+
+ Full Usage: + InlineKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `inline` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+ +

+ + + LeadingKeyword + + +

+ +
+
+ Full Usage: + LeadingKeyword +
+
+ + Field type: + SynLeadingKeyword + +
+
+
+
+ 		+
+ +
+ + + +

+ Used leading keyword of SynValSig + In most cases this will be `val`, + but in case of `SynMemberDefn.AutoProperty` or `SynMemberDefn.AbstractSlot` it could be something else. +

+
+ +
+
+ + Field type: + + SynLeadingKeyword +
+
+
+
+
+
+ +

+ + + WithKeyword + + +

+ +
+
+ Full Usage: + WithKeyword +
+
+ + Field type: + range option + +
+
+
+
+ 		+
+ +
+ + + +

+ The syntax range of the `with` keyword +

+
+ +
+
+ + Field type: + + range option +
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + SynValSigTrivia.Zero + + +

+ +
+
+ Full Usage: + SynValSigTrivia.Zero +
+
+ + Returns: + SynValSigTrivia + +
+
+
+
+ 		+
+
+ + Returns: + + SynValSigTrivia +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-syntaxtrivia.html b/reference/fsharp-compiler-syntaxtrivia.html new file mode 100644 index 0000000000..d45607c3b8 --- /dev/null +++ b/reference/fsharp-compiler-syntaxtrivia.html @@ -0,0 +1,1760 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.SyntaxTrivia | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.SyntaxTrivia Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + CommentTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ConditionalDirectiveTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + GetSetKeywords + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for `get, set` syntax +

+
+
+

+ + + IdentTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + IfDirectiveExpression + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + ParsedImplFileInputTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for ParsedImplFileInput +

+
+
+

+ + + ParsedSigFileInputTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for ParsedSigFileInputTrivia +

+
+
+

+ + + SynArgPatsNamePatPairsTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynArgPats.NamePatPairs +

+
+
+

+ + + SynBindingReturnInfoTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynBindingReturnInfo +

+
+
+

+ + + SynBindingTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynBinding +

+
+
+

+ + + SynEnumCaseTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for +

+
+
+

+ + + SynExprAndBangTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExprAndBang +

+
+
+

+ + + SynExprAnonRecdTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.AnonRecd +

+
+
+

+ + + SynExprDotLambdaTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.DotLambda +

+
+
+

+ + + SynExprIfThenElseTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.IfThenElse +

+
+
+

+ + + SynExprLambdaTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.Lambda +

+
+
+

+ + + SynExprLetOrUseBangTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.LetOrUseBang +

+
+
+

+ + + SynExprLetOrUseTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.LetOrUse +

+
+
+

+ + + SynExprMatchBangTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.MatchBang +

+
+
+

+ + + SynExprMatchTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.Match +

+
+
+

+ + + SynExprTryFinallyTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.TryFinally +

+
+
+

+ + + SynExprTryWithTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynExpr.TryWith +

+
+
+

+ + + SynFieldTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynField +

+
+
+

+ + + SynLeadingKeyword + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the leading keyword in a SynBinding or SynValSig +

+
+
+

+ + + SynMatchClauseTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynMatchClause +

+
+
+

+ + + SynMeasureConstantTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynConst.Measure +

+
+
+

+ + + SynMemberDefnAbstractSlotTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynMemberDefn.AbstractSlot +

+
+
+

+ + + SynMemberDefnAutoPropertyTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynMemberDefn.AutoProperty +

+
+
+

+ + + SynMemberDefnImplicitCtorTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynMemberDefn.ImplicitCtor +

+
+
+

+ + + SynMemberGetSetTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynMemberDefn.GetSetMember +

+
+
+

+ + + SynMemberSigMemberTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynMemberSig.Member +

+
+
+

+ + + SynModuleDeclNestedModuleTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynModuleDecl.NestedModule +

+
+
+

+ + + SynModuleOrNamespaceLeadingKeyword + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the leading keyword in a SynModuleOrNamespace or SynModuleOrNamespaceSig +

+
+
+

+ + + SynModuleOrNamespaceSigTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynModuleOrNamespaceSig +

+
+
+

+ + + SynModuleOrNamespaceTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynModuleOrNamespace +

+
+
+

+ + + SynModuleSigDeclNestedModuleTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynModuleSigDecl.NestedModule +

+
+
+

+ + + SynPatListConsTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynPat.Cons +

+
+
+

+ + + SynPatOrTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynPat.Or +

+
+
+

+ + + SynTyparDeclTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynTyparDecl +

+
+
+

+ + + SynTypeDefnLeadingKeyword + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the leading keyword in a SynTypeDefn or SynTypeDefnSig +

+
+
+

+ + + SynTypeDefnSigTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynTypeDefnSig +

+
+
+

+ + + SynTypeDefnTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynTypeDefn +

+
+
+

+ + + SynTypeFunTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynType.Fun +

+
+
+

+ + + SynTypeOrTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynType.Or +

+
+
+

+ + + SynUnionCaseTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynUnionCase +

+
+
+

+ + + SynValSigTrivia + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents additional information for SynValSig +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-isourcetext.html b/reference/fsharp-compiler-text-isourcetext.html new file mode 100644 index 0000000000..5ee0159c1b --- /dev/null +++ b/reference/fsharp-compiler-text-isourcetext.html @@ -0,0 +1,1377 @@ + + + + + + + + + + + + + + + + + + ISourceText (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ ISourceText Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + ISourceText +
+
+
+
+

+ Represents an input to the F# compiler +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ContentEquals + + +

+ +
+
+ Full Usage: + this.ContentEquals +
+
+ Parameters: + +
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Checks if one input is equal to another +

+
+ +
+
+ + sourceText + + : + ISourceText +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.CopyTo + + +

+ +
+
+ Full Usage: + this.CopyTo +
+
+ Parameters: +
    + + + sourceIndex + + : + int + +
    + + + destination + + : + char[] + +
    + + + destinationIndex + + : + int + +
    + + + count + + : + int + +
    +
+
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Copies a section of the input to the given destination ad the given index +

+
+ +
+
+ + sourceIndex + + : + int +
+
+
+ + destination + + : + char[] +
+
+
+ + destinationIndex + + : + int +
+
+
+ + count + + : + int +
+
+
+
+
+
+ +

+ + + this.GetLastCharacterPosition + + +

+ +
+
+ Full Usage: + this.GetLastCharacterPosition +
+
+ + Returns: + int * int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the last character position in the input, returning line and column +

+
+ +
+
+ + Returns: + + int * int +
+
+
+
+
+
+ +

+ + + this.GetLineCount + + +

+ +
+
+ Full Usage: + this.GetLineCount +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the count of lines in the input +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.GetLineString + + +

+ +
+
+ Full Usage: + this.GetLineString +
+
+ Parameters: +
    + + + lineIndex + + : + int + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets a line of an input by index +

+
+ +
+
+ + lineIndex + + : + int +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetSubTextFromRange + + +

+ +
+
+ Full Usage: + this.GetSubTextFromRange +
+
+ Parameters: +
    + + + range + + : + range + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets a section of the input based on a given range. + Throws an exception when the input range is outside the file boundaries. +

+
+ +
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.GetSubTextString + + +

+ +
+
+ Full Usage: + this.GetSubTextString +
+
+ Parameters: +
    + + + start + + : + int + +
    + + + length + + : + int + +
    +
+
+ + Returns: + string + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets a section of the input +

+
+ +
+
+ + start + + : + int +
+
+
+ + length + + : + int +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this[index] + + +

+ +
+
+ Full Usage: + this[index] +
+
+ Parameters: +
    + + + index + + : + int + +
    +
+
+ + Returns: + char + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets a character in an input based on an index of characters from the start of the file +

+
+ +
+
+ + index + + : + int +
+
+
+
+
+ + Returns: + + char +
+
+
+
+
+
+ +

+ + + this.Length + + +

+ +
+
+ Full Usage: + this.Length +
+
+ + Returns: + int + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the total length of the input in characters +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.SubTextEquals + + +

+ +
+
+ Full Usage: + this.SubTextEquals +
+
+ Parameters: +
    + + + target + + : + string + +
    + + + startIndex + + : + int + +
    +
+
+ + Returns: + bool + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Checks if a section of the input is equal to the given string +

+
+ +
+
+ + target + + : + string +
+
+
+ + startIndex + + : + int +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-line.html b/reference/fsharp-compiler-text-line.html new file mode 100644 index 0000000000..a98ca87973 --- /dev/null +++ b/reference/fsharp-compiler-text-line.html @@ -0,0 +1,706 @@ + + + + + + + + + + + + + + + + + + Line (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Line Module +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Functions related to converting between lines indexed at 0 and 1 +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + fromZ arg1 + + +

+ +
+
+ Full Usage: + fromZ arg1 +
+
+ Parameters: +
    + + + arg0 + + : + Line0 + +
    +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a line number from zero-based line counting (used by Visual Studio) to one-based line counting (used internally in the F# compiler and in F# error messages) +

+
+ +
+
+ + arg0 + + : + Line0 +
+
+
+
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + toZ arg1 + + +

+ +
+
+ Full Usage: + toZ arg1 +
+
+ Parameters: +
    + + + arg0 + + : + int + +
    +
+
+ + Returns: + Line0 + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a line number from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio) +

+
+ +
+
+ + arg0 + + : + int +
+
+
+
+
+ + Returns: + + Line0 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-line0.html b/reference/fsharp-compiler-text-line0.html new file mode 100644 index 0000000000..a882231b28 --- /dev/null +++ b/reference/fsharp-compiler-text-line0.html @@ -0,0 +1,593 @@ + + + + + + + + + + + + + + + + + + Line0 (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Line0 Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Abbreviation For: + int +
+
+ Base Type: + ValueType +
+
+ All Interfaces: + IConvertible + , + IBinaryInteger<int> + , + IBinaryNumber<int> + , + IBitwiseOperators<int, int, int> + , + INumber<int> + , + IComparable + , + IComparable<int> + , + IComparisonOperators<int, int, bool> + , + IModulusOperators<int, int, int> + , + IShiftOperators<int, int, int> + , + IMinMaxValue<int> + , + ISignedNumber<int> + , + INumberBase<int> + , + IEquatable<int> + , + ISpanFormattable + , + IFormattable + , + ISpanParsable<int> + , + IParsable<int> + , + IAdditionOperators<int, int, int> + , + IAdditiveIdentity<int, int> + , + IDecrementOperators<int> + , + IDivisionOperators<int, int, int> + , + IEqualityOperators<int, int, bool> + , + IIncrementOperators<int> + , + IMultiplicativeIdentity<int, int> + , + IMultiplyOperators<int, int, int> + , + ISubtractionOperators<int, int, int> + , + IUnaryNegationOperators<int, int> + , + IUnaryPlusOperators<int, int> + , + IUtf8SpanFormattable + , + IUtf8SpanParsable<int> +
+
+
+
+

+ Represents a line number when using zero-based line counting (used by Visual Studio) +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-navigabletaggedtext.html b/reference/fsharp-compiler-text-navigabletaggedtext.html new file mode 100644 index 0000000000..c49ee8010a --- /dev/null +++ b/reference/fsharp-compiler-text-navigabletaggedtext.html @@ -0,0 +1,591 @@ + + + + + + + + + + + + + + + + + + NavigableTaggedText (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ NavigableTaggedText Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + TaggedText +
+
+
+
+

+ An enhancement to TaggedText in the TaggedText layouts generated by FSharp.Compiler.Service +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-pos.html b/reference/fsharp-compiler-text-pos.html new file mode 100644 index 0000000000..bfea1fc0a2 --- /dev/null +++ b/reference/fsharp-compiler-text-pos.html @@ -0,0 +1,670 @@ + + + + + + + + + + + + + + + + + + pos (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ pos Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Abbreviation For: + Position +
+
+ Base Type: + ValueType +
+
+
+
+

+ Represents a position in a file +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Column + + +

+ +
+
+ Full Usage: + this.Column +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The column number for the position +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.Line + + +

+ +
+
+ Full Usage: + this.Line +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The line number for the position +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-position.html b/reference/fsharp-compiler-text-position.html new file mode 100644 index 0000000000..f4d6cd45a6 --- /dev/null +++ b/reference/fsharp-compiler-text-position.html @@ -0,0 +1,669 @@ + + + + + + + + + + + + + + + + + + Position (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Position Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ Kind: Struct +
+
+
+
+

+ Represents a position in a file +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Column + + +

+ +
+
+ Full Usage: + this.Column +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The column number for the position +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.Line + + +

+ +
+
+ Full Usage: + this.Line +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The line number for the position +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-positionmodule.html b/reference/fsharp-compiler-text-positionmodule.html new file mode 100644 index 0000000000..e5b932f0db --- /dev/null +++ b/reference/fsharp-compiler-text-positionmodule.html @@ -0,0 +1,1414 @@ + + + + + + + + + + + + + + + + + + Position (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Position Module +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + fromZ line column + + +

+ +
+
+ Full Usage: + fromZ line column +
+
+ Parameters: +
    + + + line + + : + Line0 + +
    + + + column + + : + int + +
    +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a position from zero-based line counting (used by Visual Studio) to one-based line counting (used internally in the F# compiler and in F# error messages) +

+
+ +
+
+ + line + + : + Line0 +
+
+
+ + column + + : + int +
+
+
+
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + mkPos line column + + +

+ +
+
+ Full Usage: + mkPos line column +
+
+ Parameters: +
    + + + line + + : + int + +
    + + + column + + : + int + +
    +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a position for the given line and column +

+
+ +
+
+ + line + + : + int +
+
+
+ + column + + : + int +
+
+
+
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + outputPos arg1 arg2 + + +

+ +
+
+ Full Usage: + outputPos arg1 arg2 +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Output a position +

+
+ +
+
+ + arg0 + + : + TextWriter +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+
+ +

+ + + pos0 + + +

+ +
+
+ Full Usage: + pos0 +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The zero position +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + posEq arg1 arg2 + + +

+ +
+
+ Full Usage: + posEq arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    + + + arg1 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compare positions for equality +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + posGeq arg1 arg2 + + +

+ +
+
+ Full Usage: + posGeq arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    + + + arg1 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compare positions for greater-than-or-equal-to +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + posGt arg1 arg2 + + +

+ +
+
+ Full Usage: + posGt arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    + + + arg1 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compare positions for greater-than +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + posLt arg1 arg2 + + +

+ +
+
+ Full Usage: + posLt arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    + + + arg1 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Compare positions for less-than +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + stringOfPos arg1 + + +

+ +
+
+ Full Usage: + stringOfPos arg1 +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a position to a string +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + toZ arg1 + + +

+ +
+
+ Full Usage: + toZ arg1 +
+
+ Parameters: +
    + + + arg0 + + : + pos + +
    +
+
+ + Returns: + Position01 + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a position from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio) +

+
+ +
+
+ + arg0 + + : + pos +
+
+
+
+
+ + Returns: + + Position01 +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-range-0.html b/reference/fsharp-compiler-text-range-0.html new file mode 100644 index 0000000000..2c3242982f --- /dev/null +++ b/reference/fsharp-compiler-text-range-0.html @@ -0,0 +1,1203 @@ + + + + + + + + + + + + + + + + + + range (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ range Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Abbreviation For: + Range +
+
+ Base Type: + ValueType +
+
+
+
+

+ Represents a range within a file +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.End + + +

+ +
+
+ Full Usage: + this.End +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The end position of the range +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.EndColumn + + +

+ +
+
+ Full Usage: + this.EndColumn +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The column number for the end position of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.EndLine + + +

+ +
+
+ Full Usage: + this.EndLine +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The line number for the end position of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.EndRange + + +

+ +
+
+ Full Usage: + this.EndRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The empty range that is located at the end position of the range +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The file name for the file of the range +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.IsSynthetic + + +

+ +
+
+ Full Usage: + this.IsSynthetic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Synthetic marks ranges which are produced by intermediate compilation phases. This + bit signifies that the range covers something that should not be visible to language + service operations like dot-completion. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Start + + +

+ +
+
+ Full Usage: + this.Start +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start position of the range +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.StartColumn + + +

+ +
+
+ Full Usage: + this.StartColumn +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start column of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.StartLine + + +

+ +
+
+ Full Usage: + this.StartLine +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start line of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.StartRange + + +

+ +
+
+ Full Usage: + this.StartRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The empty range that is located at the start position of the range +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + Range.Zero + + +

+ +
+
+ Full Usage: + Range.Zero +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The range where all values are zero +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-range.html b/reference/fsharp-compiler-text-range.html new file mode 100644 index 0000000000..2fc43ca814 --- /dev/null +++ b/reference/fsharp-compiler-text-range.html @@ -0,0 +1,1202 @@ + + + + + + + + + + + + + + + + + + Range (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Range Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ Kind: Struct +
+
+
+
+

+ Represents a range within a file +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.End + + +

+ +
+
+ Full Usage: + this.End +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The end position of the range +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.EndColumn + + +

+ +
+
+ Full Usage: + this.EndColumn +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The column number for the end position of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.EndLine + + +

+ +
+
+ Full Usage: + this.EndLine +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The line number for the end position of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.EndRange + + +

+ +
+
+ Full Usage: + this.EndRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The empty range that is located at the end position of the range +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.FileName + + +

+ +
+
+ Full Usage: + this.FileName +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The file name for the file of the range +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.IsSynthetic + + +

+ +
+
+ Full Usage: + this.IsSynthetic +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Synthetic marks ranges which are produced by intermediate compilation phases. This + bit signifies that the range covers something that should not be visible to language + service operations like dot-completion. +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Start + + +

+ +
+
+ Full Usage: + this.Start +
+
+ + Returns: + pos + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start position of the range +

+
+ +
+
+ + Returns: + + pos +
+
+
+
+
+
+ +

+ + + this.StartColumn + + +

+ +
+
+ Full Usage: + this.StartColumn +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start column of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.StartLine + + +

+ +
+
+ Full Usage: + this.StartLine +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The start line of the range +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + this.StartRange + + +

+ +
+
+ Full Usage: + this.StartRange +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The empty range that is located at the start position of the range +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + Range.Zero + + +

+ +
+
+ Full Usage: + Range.Zero +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The range where all values are zero +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-rangemodule.html b/reference/fsharp-compiler-text-rangemodule.html new file mode 100644 index 0000000000..eb8232fd3b --- /dev/null +++ b/reference/fsharp-compiler-text-rangemodule.html @@ -0,0 +1,2574 @@ + + + + + + + + + + + + + + + + + + Range (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Range Module +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + comparer + + +

+ +
+
+ Full Usage: + comparer +
+
+ + Returns: + IEqualityComparer<range> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Equality comparer for range. +

+
+ +
+
+ + Returns: + + IEqualityComparer<range> +
+
+
+
+
+
+ +

+ + + equals arg1 arg2 + + +

+ +
+
+ Full Usage: + equals arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    + + + arg1 + + : + range + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + arg0 + + : + range +
+
+
+ + arg1 + + : + range +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + mkFileIndexRange arg1 arg2 arg3 + + +

+ +
+
+ Full Usage: + mkFileIndexRange arg1 arg2 arg3 +
+
+ Parameters: +
    + + + arg0 + + : + FileIndex + +
    + + + arg1 + + : + pos + +
    + + + arg2 + + : + pos + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ This view of range marks uses file indexes explicitly +

+
+ +
+
+ + arg0 + + : + FileIndex +
+
+
+ + arg1 + + : + pos +
+
+
+ + arg2 + + : + pos +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + mkFirstLineOfFile arg1 + + +

+ +
+
+ Full Usage: + mkFirstLineOfFile arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Make a range for the first non-whitespace line of the file if any. Otherwise use line 1 chars 0-80. + This involves reading the file. +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + mkRange arg1 arg2 arg3 + + +

+ +
+
+ Full Usage: + mkRange arg1 arg2 arg3 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    + + + arg1 + + : + pos + +
    + + + arg2 + + : + pos + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ This view hides the use of file indexes and just uses filenames +

+
+ +
+
+ + arg0 + + : + string +
+
+
+ + arg1 + + : + pos +
+
+
+ + arg2 + + : + pos +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + outputRange arg1 arg2 + + +

+ +
+
+ Full Usage: + outputRange arg1 arg2 +
+
+ Parameters: + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Output a range +

+
+ +
+
+ + arg0 + + : + TextWriter +
+
+
+ + arg1 + + : + range +
+
+
+
+
+
+ +

+ + + posOrder + + +

+ +
+
+ Full Usage: + posOrder +
+
+ + Returns: + IComparer<pos> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Ordering on positions +

+
+ +
+
+ + Returns: + + IComparer<pos> +
+
+
+
+
+
+ +

+ + + range0 + + +

+ +
+
+ Full Usage: + range0 +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ The zero range +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + rangeBeforePos arg1 arg2 + + +

+ +
+
+ Full Usage: + rangeBeforePos arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    + + + arg1 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Test to see if a range occurs fully before a position +

+
+ +
+
+ + arg0 + + : + range +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + rangeCmdArgs + + +

+ +
+
+ Full Usage: + rangeCmdArgs +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A range associated with a dummy file for the command line arguments +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + rangeContainsPos arg1 arg2 + + +

+ +
+
+ Full Usage: + rangeContainsPos arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    + + + arg1 + + : + pos + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Test to see if a range contains a position +

+
+ +
+
+ + arg0 + + : + range +
+
+
+ + arg1 + + : + pos +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + rangeContainsRange arg1 arg2 + + +

+ +
+
+ Full Usage: + rangeContainsRange arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    + + + arg1 + + : + range + +
    +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Test to see if one range contains another range +

+
+ +
+
+ + arg0 + + : + range +
+
+
+ + arg1 + + : + range +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + rangeN arg1 arg2 + + +

+ +
+
+ Full Usage: + rangeN arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    + + + arg1 + + : + int + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Make a dummy range for a file +

+
+ +
+
+ + arg0 + + : + string +
+
+
+ + arg1 + + : + int +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + rangeOrder + + +

+ +
+
+ Full Usage: + rangeOrder +
+
+ + Returns: + IComparer<range> + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Order ranges (file, then start pos, then end pos) +

+
+ +
+
+ + Returns: + + IComparer<range> +
+
+
+
+
+
+ +

+ + + rangeStartup + + +

+ +
+
+ Full Usage: + rangeStartup +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ A range associated with a dummy file called "startup" +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + shiftEnd arg1 arg2 arg3 + + +

+ +
+
+ Full Usage: + shiftEnd arg1 arg2 arg3 +
+
+ Parameters: +
    + + + arg0 + + : + int + +
    + + + arg1 + + : + int + +
    + + + arg2 + + : + range + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + arg0 + + : + int +
+
+
+ + arg1 + + : + int +
+
+
+ + arg2 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + shiftStart arg1 arg2 arg3 + + +

+ +
+
+ Full Usage: + shiftStart arg1 arg2 arg3 +
+
+ Parameters: +
    + + + arg0 + + : + int + +
    + + + arg1 + + : + int + +
    + + + arg2 + + : + range + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + arg0 + + : + int +
+
+
+ + arg1 + + : + int +
+
+
+ + arg2 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + stringOfRange arg1 + + +

+ +
+
+ Full Usage: + stringOfRange arg1 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a range to a string +

+
+ +
+
+ + arg0 + + : + range +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + toFileZ arg1 + + +

+ +
+
+ Full Usage: + toFileZ arg1 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    +
+
+ + Returns: + string * Range01 + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a range from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio) +

+
+ +
+
+ + arg0 + + : + range +
+
+
+
+
+ + Returns: + + string * Range01 +
+
+
+
+
+
+ +

+ + + toZ arg1 + + +

+ +
+
+ Full Usage: + toZ arg1 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    +
+
+ + Returns: + Range01 + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Convert a range from one-based line counting (used internally in the F# compiler and in F# error messages) to zero-based line counting (used by Visual Studio) +

+
+ +
+
+ + arg0 + + : + range +
+
+
+
+
+ + Returns: + + Range01 +
+
+
+
+
+
+ +

+ + + trimRangeToLine arg1 + + +

+ +
+
+ Full Usage: + trimRangeToLine arg1 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Reduce a range so it only covers a line +

+
+ +
+
+ + arg0 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + unionRanges arg1 arg2 + + +

+ +
+
+ Full Usage: + unionRanges arg1 arg2 +
+
+ Parameters: +
    + + + arg0 + + : + range + +
    + + + arg1 + + : + range + +
    +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Union two ranges, taking their first occurring start position and last occurring end position +

+
+ +
+
+ + arg0 + + : + range +
+
+
+ + arg1 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + withEnd arg1 arg2 + + +

+ +
+
+ Full Usage: + withEnd arg1 arg2 +
+
+ Parameters: + +
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + arg0 + + : + Position +
+
+
+ + arg1 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + withStart arg1 arg2 + + +

+ +
+
+ Full Usage: + withStart arg1 arg2 +
+
+ Parameters: + +
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + arg0 + + : + Position +
+
+
+ + arg1 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+ +

+ + + withStartEnd arg1 arg2 arg3 + + +

+ +
+
+ Full Usage: + withStartEnd arg1 arg2 arg3 +
+
+ Parameters: + +
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + arg0 + + : + Position +
+
+
+ + arg1 + + : + Position +
+
+
+ + arg2 + + : + range +
+
+
+
+
+ + Returns: + + range +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-sourcetext.html b/reference/fsharp-compiler-text-sourcetext.html new file mode 100644 index 0000000000..62edd7f8bc --- /dev/null +++ b/reference/fsharp-compiler-text-sourcetext.html @@ -0,0 +1,627 @@ + + + + + + + + + + + + + + + + + + SourceText (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ SourceText Module +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Functions related to ISourceText objects +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + ofString arg1 + + +

+ +
+
+ Full Usage: + ofString arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + ISourceText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates an ISourceText object from the given string +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + ISourceText +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-taggedtext.html b/reference/fsharp-compiler-text-taggedtext.html new file mode 100644 index 0000000000..9c0704285d --- /dev/null +++ b/reference/fsharp-compiler-text-taggedtext.html @@ -0,0 +1,779 @@ + + + + + + + + + + + + + + + + + + TaggedText (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ TaggedText Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents text with a tag +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + TaggedText(tag, text) + + +

+ +
+
+ Full Usage: + TaggedText(tag, text) +
+
+ Parameters: +
    + + + tag + + : + TextTag + +
    + + + text + + : + string + +
    +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Creates text with a tag +

+
+ +
+
+ + tag + + : + TextTag +
+
+
+ + text + + : + string +
+
+
+
+
+ + Returns: + + TaggedText +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Tag + + +

+ +
+
+ Full Usage: + this.Tag +
+
+ + Returns: + TextTag + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the tag +

+
+ +
+
+ + Returns: + + TextTag +
+
+
+
+
+
+ +

+ + + this.Text + + +

+ +
+
+ Full Usage: + this.Text +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Gets the text +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-taggedtextmodule.html b/reference/fsharp-compiler-text-taggedtextmodule.html new file mode 100644 index 0000000000..0811764621 --- /dev/null +++ b/reference/fsharp-compiler-text-taggedtextmodule.html @@ -0,0 +1,1087 @@ + + + + + + + + + + + + + + + + + + TaggedText (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ TaggedText Module +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + colon + + +

+ +
+
+ Full Usage: + colon +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + comma + + +

+ +
+
+ Full Usage: + comma +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + dot + + +

+ +
+
+ Full Usage: + dot +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + lineBreak + + +

+ +
+
+ Full Usage: + lineBreak +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + minus + + +

+ +
+
+ Full Usage: + minus +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + space + + +

+ +
+
+ Full Usage: + space +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + tagClass arg1 + + +

+ +
+
+ Full Usage: + tagClass arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + tagNamespace arg1 + + +

+ +
+
+ Full Usage: + tagNamespace arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + tagParameter arg1 + + +

+ +
+
+ Full Usage: + tagParameter arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + tagSpace arg1 + + +

+ +
+
+ Full Usage: + tagSpace arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + TaggedText +
+
+
+
+
+ +

+ + + tagText arg1 + + +

+ +
+
+ Full Usage: + tagText arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + TaggedText + +
+
+
+
+ 		+
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + TaggedText +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text-texttag.html b/reference/fsharp-compiler-text-texttag.html new file mode 100644 index 0000000000..4d85a61340 --- /dev/null +++ b/reference/fsharp-compiler-text-texttag.html @@ -0,0 +1,1678 @@ + + + + + + + + + + + + + + + + + + TextTag (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ TextTag Type +

+
+
+ Namespace: + + FSharp.Compiler.Text + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable +
+
+
+
+

+ Represents the tag of some tagged text +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + ActivePatternCase + + +

+ +
+
+ Full Usage: + ActivePatternCase +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ActivePatternResult + + +

+ +
+
+ Full Usage: + ActivePatternResult +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Alias + + +

+ +
+
+ Full Usage: + Alias +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Delegate + + +

+ +
+
+ Full Usage: + Delegate +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Enum + + +

+ +
+
+ Full Usage: + Enum +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Event + + +

+ +
+
+ Full Usage: + Event +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Field + + +

+ +
+
+ Full Usage: + Field +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Function + + +

+ +
+
+ Full Usage: + Function +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Keyword + + +

+ +
+
+ Full Usage: + Keyword +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LineBreak + + +

+ +
+
+ Full Usage: + LineBreak +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Local + + +

+ +
+
+ Full Usage: + Local +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Member + + +

+ +
+
+ Full Usage: + Member +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Method + + +

+ +
+
+ Full Usage: + Method +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ModuleBinding + + +

+ +
+
+ Full Usage: + ModuleBinding +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NumericLiteral + + +

+ +
+
+ Full Usage: + NumericLiteral +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Operator + + +

+ +
+
+ Full Usage: + Operator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Parameter + + +

+ +
+
+ Full Usage: + Parameter +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Property + + +

+ +
+
+ Full Usage: + Property +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Punctuation + + +

+ +
+
+ Full Usage: + Punctuation +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Record + + +

+ +
+
+ Full Usage: + Record +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RecordField + + +

+ +
+
+ Full Usage: + RecordField +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Space + + +

+ +
+
+ Full Usage: + Space +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + StringLiteral + + +

+ +
+
+ Full Usage: + StringLiteral +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Struct + + +

+ +
+
+ Full Usage: + Struct +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Text + + +

+ +
+
+ Full Usage: + Text +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + TypeParameter + + +

+ +
+
+ Full Usage: + TypeParameter +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Union + + +

+ +
+
+ Full Usage: + Union +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UnionCase + + +

+ +
+
+ Full Usage: + UnionCase +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UnknownEntity + + +

+ +
+
+ Full Usage: + UnknownEntity +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UnknownType + + +

+ +
+
+ Full Usage: + UnknownType +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-text.html b/reference/fsharp-compiler-text.html new file mode 100644 index 0000000000..5693b0c05a --- /dev/null +++ b/reference/fsharp-compiler-text.html @@ -0,0 +1,896 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Text | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Text Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + ISourceText + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents an input to the F# compiler +

+
+
+

+ + + Line + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Functions related to converting between lines indexed at 0 and 1 +

+
+
+

+ + + Line0 + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a line number when using zero-based line counting (used by Visual Studio) +

+
+
+

+ + + NavigableTaggedText + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ An enhancement to TaggedText in the TaggedText layouts generated by FSharp.Compiler.Service +

+
+
+

+ + + pos + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a position in a file +

+
+
+

+ + + Position (Module) + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + Position (Type) + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a position in a file +

+
+
+

+ + + Range (Module) + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + Range (Type) + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a range within a file +

+
+
+

+ + + range + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents a range within a file +

+
+
+

+ + + SourceText + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Functions related to ISourceText objects +

+
+
+

+ + + TaggedText (Module) + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + TaggedText (Type) + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents text with a tag +

+
+
+

+ + + TextTag + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the tag of some tagged text +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharpkeywords.html b/reference/fsharp-compiler-tokenization-fsharpkeywords.html new file mode 100644 index 0000000000..84f49ecffa --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharpkeywords.html @@ -0,0 +1,742 @@ + + + + + + + + + + + + + + + + + + FSharpKeywords (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpKeywords Module +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + KeywordNames + + +

+ +
+
+ Full Usage: + KeywordNames +
+
+ + Returns: + string list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ All the keywords in the F# language +

+
+ +
+
+ + Returns: + + string list +
+
+
+
+
+
+ +

+ + + KeywordsWithDescription + + +

+ +
+
+ Full Usage: + KeywordsWithDescription +
+
+ + Returns: + (string * string) list + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Keywords paired with their descriptions. Used in completion and quick info. +

+
+ +
+
+ + Returns: + + (string * string) list +
+
+
+
+
+
+ +

+ + + NormalizeIdentifierBackticks arg1 + + +

+ +
+
+ Full Usage: + NormalizeIdentifierBackticks arg1 +
+
+ Parameters: +
    + + + arg0 + + : + string + +
    +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Add backticks if the identifier is a keyword. + Remove backticks if present and not needed. +

+
+ +
+
+ + arg0 + + : + string +
+
+
+
+
+ + Returns: + + string +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharplexer.html b/reference/fsharp-compiler-tokenization-fsharplexer.html new file mode 100644 index 0000000000..94ac4a34e7 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharplexer.html @@ -0,0 +1,727 @@ + + + + + + + + + + + + + + + + + + FSharpLexer (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpLexer Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpLexer.Tokenize(text, tokenCallback, ?langVersion, ?strictIndentation, ?filePath, ?conditionalDefines, ?flags, ?pathMap, ?ct) + + +

+ +
+
+ Full Usage: + FSharpLexer.Tokenize(text, tokenCallback, ?langVersion, ?strictIndentation, ?filePath, ?conditionalDefines, ?flags, ?pathMap, ?ct) +
+
+ Parameters: +
    + + + text + + : + ISourceText + +
    + + + tokenCallback + + : + FSharpToken -> unit + +
    + + + ?langVersion + + : + string + +
    + + + ?strictIndentation + + : + bool + +
    + + + ?filePath + + : + string + +
    + + + ?conditionalDefines + + : + string list + +
    + + + ?flags + + : + FSharpLexerFlags + +
    + + + ?pathMap + + : + Map<string, string> + +
    + + + ?ct + + : + CancellationToken + +
    +
+
+
+
+
+ 		+
+
+ + text + + : + ISourceText +
+
+
+ + tokenCallback + + : + FSharpToken -> unit +
+
+
+ + ?langVersion + + : + string +
+
+
+ + ?strictIndentation + + : + bool +
+
+
+ + ?filePath + + : + string +
+
+
+ + ?conditionalDefines + + : + string list +
+
+
+ + ?flags + + : + FSharpLexerFlags +
+
+
+ + ?pathMap + + : + Map<string, string> +
+
+
+ + ?ct + + : + CancellationToken +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharplexerflags.html b/reference/fsharp-compiler-tokenization-fsharplexerflags.html new file mode 100644 index 0000000000..2f40619b37 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharplexerflags.html @@ -0,0 +1,820 @@ + + + + + + + + + + + + + + + + + + FSharpLexerFlags (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpLexerFlags Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Compiling + + +

+ +
+
+ Full Usage: + Compiling +
+
+ + Field type: + FSharpLexerFlags + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpLexerFlags +
+
+
+
+
+ +

+ + + CompilingFSharpCore + + +

+ +
+
+ Full Usage: + CompilingFSharpCore +
+
+ + Field type: + FSharpLexerFlags + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpLexerFlags +
+
+
+
+
+ +

+ + + Default + + +

+ +
+
+ Full Usage: + Default +
+
+ + Field type: + FSharpLexerFlags + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpLexerFlags +
+
+
+
+
+ +

+ + + LightSyntaxOn + + +

+ +
+
+ Full Usage: + LightSyntaxOn +
+
+ + Field type: + FSharpLexerFlags + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpLexerFlags +
+
+
+
+
+ +

+ + + SkipTrivia + + +

+ +
+
+ Full Usage: + SkipTrivia +
+
+ + Field type: + FSharpLexerFlags + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpLexerFlags +
+
+
+
+
+ +

+ + + UseLexFilter + + +

+ +
+
+ Full Usage: + UseLexFilter +
+
+ + Field type: + FSharpLexerFlags + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpLexerFlags +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html b/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html new file mode 100644 index 0000000000..d47542c19c --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharplinetokenizer.html @@ -0,0 +1,817 @@ + + + + + + + + + + + + + + + + + + FSharpLineTokenizer (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpLineTokenizer Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Object to tokenize a line of F# source code, starting with the given lexState. The lexState should be FSharpTokenizerLexState.Initial for + the first line of text. Returns an array of ranges of the text and two enumerations categorizing the + tokens and characters covered by that range, i.e. FSharpTokenColorKind and FSharpTokenCharKind. The enumerations + are somewhat adhoc but useful enough to give good colorization options to the user in an IDE. + + A new lexState is also returned. An IDE-plugin should in general cache the lexState + values for each line of the edited code. +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.ScanToken + + +

+ +
+
+ Full Usage: + this.ScanToken +
+
+ Parameters: + +
+ + Returns: + FSharpTokenInfo option * FSharpTokenizerLexState + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Scan one token from the line +

+
+ +
+
+ + lexState + + : + FSharpTokenizerLexState +
+
+
+
+
+ + Returns: + + FSharpTokenInfo option * FSharpTokenizerLexState +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpLineTokenizer.ColorStateOfLexState(arg1) + + +

+ +
+
+ Full Usage: + FSharpLineTokenizer.ColorStateOfLexState(arg1) +
+
+ Parameters: + +
+ + Returns: + FSharpTokenizerColorState + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the color state from the lexer state +

+
+ +
+
+ + arg0 + + : + FSharpTokenizerLexState +
+
+
+
+
+ + Returns: + + FSharpTokenizerColorState +
+
+
+
+
+
+ +

+ + + FSharpLineTokenizer.LexStateOfColorState(arg1) + + +

+ +
+
+ Full Usage: + FSharpLineTokenizer.LexStateOfColorState(arg1) +
+
+ Parameters: + +
+ + Returns: + FSharpTokenizerLexState + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get a default lexer state for a color state. + + NOTE: This may result in an inaccurate lexer state + not taking into account things such as the #if/#endif and string interpolation context + within the file +

+
+ +
+
+ + arg0 + + : + FSharpTokenizerColorState +
+
+
+
+
+ + Returns: + + FSharpTokenizerLexState +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html b/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html new file mode 100644 index 0000000000..d123eceb77 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharpsourcetokenizer.html @@ -0,0 +1,855 @@ + + + + + + + + + + + + + + + + + + FSharpSourceTokenizer (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpSourceTokenizer Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Tokenizer for a source file. Holds some expensive-to-compute resources at the scope of the file. +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + FSharpSourceTokenizer(conditionalDefines, fileName, langVersion, strictIndentation) + + +

+ +
+
+ Full Usage: + FSharpSourceTokenizer(conditionalDefines, fileName, langVersion, strictIndentation) +
+
+ Parameters: +
    + + + conditionalDefines + + : + string list + +
    + + + fileName + + : + string option + +
    + + + langVersion + + : + string option + +
    + + + strictIndentation + + : + bool option + +
    +
+
+ + Returns: + FSharpSourceTokenizer + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a tokenizer for a source file. +

+
+ +
+
+ + conditionalDefines + + : + string list +
+
+
+ + fileName + + : + string option +
+
+
+ + langVersion + + : + string option +
+
+
+ + strictIndentation + + : + bool option +
+
+
+
+
+ + Returns: + + FSharpSourceTokenizer +
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CreateBufferTokenizer + + +

+ +
+
+ Full Usage: + this.CreateBufferTokenizer +
+
+ Parameters: +
    + + + bufferFiller + + : + char[] * int * int -> int + +
    +
+
+ + Returns: + FSharpLineTokenizer + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a tokenizer for a line of this source file using a buffer filler +

+
+ +
+
+ + bufferFiller + + : + char[] * int * int -> int +
+
+
+
+
+ + Returns: + + FSharpLineTokenizer +
+
+
+
+
+
+ +

+ + + this.CreateLineTokenizer + + +

+ +
+
+ Full Usage: + this.CreateLineTokenizer +
+
+ Parameters: +
    + + + lineText + + : + string + +
    +
+
+ + Returns: + FSharpLineTokenizer + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a tokenizer for a line of this source file +

+
+ +
+
+ + lineText + + : + string +
+
+
+
+
+ + Returns: + + FSharpLineTokenizer +
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptoken.html b/reference/fsharp-compiler-tokenization-fsharptoken.html new file mode 100644 index 0000000000..cccd35e0d2 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptoken.html @@ -0,0 +1,924 @@ + + + + + + + + + + + + + + + + + + FSharpToken (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpToken Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ Kind: Struct +
+
+
+
+

+ +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + tok + + +

+ +
+
+ Full Usage: + tok +
+
+ + Field type: + token + +
+
+
+
+ 		+
+
+ + Field type: + + token +
+
+
+
+
+ +

+ + + tokRange + + +

+ +
+
+ Full Usage: + tokRange +
+
+ + Field type: + range + +
+
+
+
+ 		+
+
+ + Field type: + + range +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsCommentTrivia + + +

+ +
+
+ Full Usage: + this.IsCommentTrivia +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsIdentifier + + +

+ +
+
+ Full Usage: + this.IsIdentifier +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsKeyword + + +

+ +
+
+ Full Usage: + this.IsKeyword +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsNumericLiteral + + +

+ +
+
+ Full Usage: + this.IsNumericLiteral +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.IsStringLiteral + + +

+ +
+
+ Full Usage: + this.IsStringLiteral +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Kind + + +

+ +
+
+ Full Usage: + this.Kind +
+
+ + Returns: + FSharpTokenKind + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpTokenKind +
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+
+ + Returns: + + range +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokencharkind.html b/reference/fsharp-compiler-tokenization-fsharptokencharkind.html new file mode 100644 index 0000000000..90eabda025 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokencharkind.html @@ -0,0 +1,1030 @@ + + + + + + + + + + + + + + + + + + FSharpTokenCharKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenCharKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ Gives an indication of the class to assign to the characters of the token an IDE +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Comment + + +

+ +
+
+ Full Usage: + Comment +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Default + + +

+ +
+
+ Full Usage: + Default +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Delimiter + + +

+ +
+
+ Full Usage: + Delimiter +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Identifier + + +

+ +
+
+ Full Usage: + Identifier +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Keyword + + +

+ +
+
+ Full Usage: + Keyword +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + LineComment + + +

+ +
+
+ Full Usage: + LineComment +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Literal + + +

+ +
+
+ Full Usage: + Literal +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Operator + + +

+ +
+
+ Full Usage: + Operator +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + String + + +

+ +
+
+ Full Usage: + String +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + Text + + +

+ +
+
+ Full Usage: + Text +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+ +

+ + + WhiteSpace + + +

+ +
+
+ Full Usage: + WhiteSpace +
+
+ + Field type: + FSharpTokenCharKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html b/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html new file mode 100644 index 0000000000..ef85b2968f --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokencolorkind.html @@ -0,0 +1,1072 @@ + + + + + + + + + + + + + + + + + + FSharpTokenColorKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenColorKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ Gives an indication of the color class to assign to the token an IDE +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + Comment + + +

+ +
+
+ Full Usage: + Comment +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Default + + +

+ +
+
+ Full Usage: + Default +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Identifier + + +

+ +
+
+ Full Usage: + Identifier +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + InactiveCode + + +

+ +
+
+ Full Usage: + InactiveCode +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Keyword + + +

+ +
+
+ Full Usage: + Keyword +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Number + + +

+ +
+
+ Full Usage: + Number +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Operator + + +

+ +
+
+ Full Usage: + Operator +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + PreprocessorKeyword + + +

+ +
+
+ Full Usage: + PreprocessorKeyword +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Punctuation + + +

+ +
+
+ Full Usage: + Punctuation +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + String + + +

+ +
+
+ Full Usage: + String +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + Text + + +

+ +
+
+ Full Usage: + Text +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + UpperIdentifier + + +

+ +
+
+ Full Usage: + UpperIdentifier +
+
+ + Field type: + FSharpTokenColorKind + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokeninfo.html b/reference/fsharp-compiler-tokenization-fsharptokeninfo.html new file mode 100644 index 0000000000..2bbe251117 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokeninfo.html @@ -0,0 +1,958 @@ + + + + + + + + + + + + + + + + + + FSharpTokenInfo (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenInfo Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpTokenInfo> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ Information about a particular token from the tokenizer +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CharClass + + +

+ +
+
+ Full Usage: + CharClass +
+
+ + Field type: + FSharpTokenCharKind + +
+
+
+
+ 		+
+ +
+ + + +

+ Gives an indication of the class to assign to the token an IDE +

+
+ +
+
+ + Field type: + + FSharpTokenCharKind +
+
+
+
+
+
+ +

+ + + ColorClass + + +

+ +
+
+ Full Usage: + ColorClass +
+
+ + Field type: + FSharpTokenColorKind + +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenColorKind +
+
+
+
+
+ +

+ + + FSharpTokenTriggerClass + + +

+ +
+
+ Full Usage: + FSharpTokenTriggerClass +
+
+ + Field type: + FSharpTokenTriggerClass + +
+
+
+
+ 		+
+ +
+ + + +

+ Actions taken when the token is typed +

+
+ +
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+
+ +

+ + + FullMatchedLength + + +

+ +
+
+ Full Usage: + FullMatchedLength +
+
+ + Field type: + int + +
+
+
+
+ 		+
+ +
+ + + +

+ The full length consumed by this match, including delayed tokens (which can be ignored in naive lexers) +

+
+ +
+
+ + Field type: + + int +
+
+
+
+
+
+ +

+ + + LeftColumn + + +

+ +
+
+ Full Usage: + LeftColumn +
+
+ + Field type: + int + +
+
+
+
+ 		+
+ +
+ + + +

+ Left column of the token. +

+
+ +
+
+ + Field type: + + int +
+
+
+
+
+
+ +

+ + + RightColumn + + +

+ +
+
+ Full Usage: + RightColumn +
+
+ + Field type: + int + +
+
+
+
+ 		+
+ +
+ + + +

+ Right column of the token. +

+
+ +
+
+ + Field type: + + int +
+
+
+
+
+
+ +

+ + + Tag + + +

+ +
+
+ Full Usage: + Tag +
+
+ + Field type: + int + +
+
+
+
+ 		+
+ +
+ + + +

+ The tag is an integer identifier for the token +

+
+ +
+
+ + Field type: + + int +
+
+
+
+
+
+ +

+ + + TokenName + + +

+ +
+
+ Full Usage: + TokenName +
+
+ + Field type: + string + +
+
+
+
+ 		+
+ +
+ + + +

+ Provides additional information about the token +

+
+ +
+
+ + Field type: + + string +
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html b/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html new file mode 100644 index 0000000000..ec6a564bb7 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokenizercolorstate.html @@ -0,0 +1,1156 @@ + + + + + + + + + + + + + + + + + + FSharpTokenizerColorState (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenizerColorState Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ Represents stable information for the state of the lexing engine at the end of a line +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + CamlOnly + + +

+ +
+
+ Full Usage: + CamlOnly +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + Comment + + +

+ +
+
+ Full Usage: + Comment +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + EndLineThenSkip + + +

+ +
+
+ Full Usage: + EndLineThenSkip +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + EndLineThenToken + + +

+ +
+
+ Full Usage: + EndLineThenToken +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + IfDefSkip + + +

+ +
+
+ Full Usage: + IfDefSkip +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + InitialState + + +

+ +
+
+ Full Usage: + InitialState +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + SingleLineComment + + +

+ +
+
+ Full Usage: + SingleLineComment +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + String + + +

+ +
+
+ Full Usage: + String +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + StringInComment + + +

+ +
+
+ Full Usage: + StringInComment +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + Token + + +

+ +
+
+ Full Usage: + Token +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + TripleQuoteString + + +

+ +
+
+ Full Usage: + TripleQuoteString +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + TripleQuoteStringInComment + + +

+ +
+
+ Full Usage: + TripleQuoteStringInComment +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + VerbatimString + + +

+ +
+
+ Full Usage: + VerbatimString +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+ +

+ + + VerbatimStringInComment + + +

+ +
+
+ Full Usage: + VerbatimStringInComment +
+
+ + Field type: + FSharpTokenizerColorState + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenizerColorState +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html b/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html new file mode 100644 index 0000000000..bedae6361b --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokenizerlexstate.html @@ -0,0 +1,769 @@ + + + + + + + + + + + + + + + + + + FSharpTokenizerLexState (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenizerLexState Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + ValueType +
+
+ Kind: Struct +
+
+
+
+

+ Represents encoded information for the end-of-line continuation of lexing +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + OtherBits + + +

+ +
+
+ Full Usage: + OtherBits +
+
+ + Field type: + int64 + +
+
+
+
+ 		+
+
+ + Field type: + + int64 +
+
+
+
+
+ +

+ + + PosBits + + +

+ +
+
+ Full Usage: + PosBits +
+
+ + Field type: + int64 + +
+
+
+
+ 		+
+
+ + Field type: + + int64 +
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Equals + + +

+ +
+
+ Full Usage: + this.Equals +
+
+ Parameters: + +
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + arg0 + + : + FSharpTokenizerLexState +
+
+
+
+
+ + Returns: + + bool +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + FSharpTokenizerLexState.Initial + + +

+ +
+
+ Full Usage: + FSharpTokenizerLexState.Initial +
+
+ + Returns: + FSharpTokenizerLexState + +
+
+
+
+ 		+
+
+ + Returns: + + FSharpTokenizerLexState +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokenkind.html b/reference/fsharp-compiler-tokenization-fsharptokenkind.html new file mode 100644 index 0000000000..c8339df762 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokenkind.html @@ -0,0 +1,6865 @@ + + + + + + + + + + + + + + + + + + FSharpTokenKind (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenKind Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+ All Interfaces: + IStructuralEquatable + , + IComparable<FSharpTokenKind> + , + IComparable + , + IStructuralComparable +
+
+
+
+

+ +

+
+
+
+
+
+
+

+ Union cases +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Union case + + Description +
+
+ +

+ + + Abstract + + +

+ +
+
+ Full Usage: + Abstract +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + AdjacentPrefixOperator + + +

+ +
+
+ Full Usage: + AdjacentPrefixOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Ampersand + + +

+ +
+
+ Full Usage: + Ampersand +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + AmpersandAmpersand + + +

+ +
+
+ Full Usage: + AmpersandAmpersand +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + And + + +

+ +
+
+ Full Usage: + And +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + As + + +

+ +
+
+ Full Usage: + As +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Asr + + +

+ +
+
+ Full Usage: + Asr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Assert + + +

+ +
+
+ Full Usage: + Assert +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Bar + + +

+ +
+
+ Full Usage: + Bar +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + BarBar + + +

+ +
+
+ Full Usage: + BarBar +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + BarRightBrace + + +

+ +
+
+ Full Usage: + BarRightBrace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + BarRightBracket + + +

+ +
+
+ Full Usage: + BarRightBracket +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Base + + +

+ +
+
+ Full Usage: + Base +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Begin + + +

+ +
+
+ Full Usage: + Begin +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + BigNumber + + +

+ +
+
+ Full Usage: + BigNumber +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Binder + + +

+ +
+
+ Full Usage: + Binder +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ByteArray + + +

+ +
+
+ Full Usage: + ByteArray +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Char + + +

+ +
+
+ Full Usage: + Char +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Class + + +

+ +
+
+ Full Usage: + Class +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Colon + + +

+ +
+
+ Full Usage: + Colon +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ColonColon + + +

+ +
+
+ Full Usage: + ColonColon +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ColonEquals + + +

+ +
+
+ Full Usage: + ColonEquals +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ColonGreater + + +

+ +
+
+ Full Usage: + ColonGreater +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ColonQuestionMark + + +

+ +
+
+ Full Usage: + ColonQuestionMark +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + ColonQuestionMarkGreater + + +

+ +
+
+ Full Usage: + ColonQuestionMarkGreater +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Comma + + +

+ +
+
+ Full Usage: + Comma +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + CommentTrivia + + +

+ +
+
+ Full Usage: + CommentTrivia +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Const + + +

+ +
+
+ Full Usage: + Const +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Constraint + + +

+ +
+
+ Full Usage: + Constraint +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Constructor + + +

+ +
+
+ Full Usage: + Constructor +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Decimal + + +

+ +
+
+ Full Usage: + Decimal +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Default + + +

+ +
+
+ Full Usage: + Default +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Delegate + + +

+ +
+
+ Full Usage: + Delegate +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Do + + +

+ +
+
+ Full Usage: + Do +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + DoBang + + +

+ +
+
+ Full Usage: + DoBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Dollar + + +

+ +
+
+ Full Usage: + Dollar +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Done + + +

+ +
+
+ Full Usage: + Done +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Dot + + +

+ +
+
+ Full Usage: + Dot +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + DotDot + + +

+ +
+
+ Full Usage: + DotDot +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + DotDotHat + + +

+ +
+
+ Full Usage: + DotDotHat +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + DownTo + + +

+ +
+
+ Full Usage: + DownTo +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Downcast + + +

+ +
+
+ Full Usage: + Downcast +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Elif + + +

+ +
+
+ Full Usage: + Elif +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Else + + +

+ +
+
+ Full Usage: + Else +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + End + + +

+ +
+
+ Full Usage: + End +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Equals + + +

+ +
+
+ Full Usage: + Equals +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Exception + + +

+ +
+
+ Full Usage: + Exception +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Extern + + +

+ +
+
+ Full Usage: + Extern +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + False + + +

+ +
+
+ Full Usage: + False +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Finally + + +

+ +
+
+ Full Usage: + Finally +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Fixed + + +

+ +
+
+ Full Usage: + Fixed +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + For + + +

+ +
+
+ Full Usage: + For +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Fun + + +

+ +
+
+ Full Usage: + Fun +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Function + + +

+ +
+
+ Full Usage: + Function +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + FunkyOperatorName + + +

+ +
+
+ Full Usage: + FunkyOperatorName +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Global + + +

+ +
+
+ Full Usage: + Global +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Greater + + +

+ +
+
+ Full Usage: + Greater +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + GreaterBarRightBracket + + +

+ +
+
+ Full Usage: + GreaterBarRightBracket +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + GreaterRightBracket + + +

+ +
+
+ Full Usage: + GreaterRightBracket +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Hash + + +

+ +
+
+ Full Usage: + Hash +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HashElse + + +

+ +
+
+ Full Usage: + HashElse +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HashEndIf + + +

+ +
+
+ Full Usage: + HashEndIf +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HashIf + + +

+ +
+
+ Full Usage: + HashIf +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HashLight + + +

+ +
+
+ Full Usage: + HashLight +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HashLine + + +

+ +
+
+ Full Usage: + HashLine +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HighPrecedenceBracketApp + + +

+ +
+
+ Full Usage: + HighPrecedenceBracketApp +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HighPrecedenceParenthesisApp + + +

+ +
+
+ Full Usage: + HighPrecedenceParenthesisApp +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + HighPrecedenceTypeApp + + +

+ +
+
+ Full Usage: + HighPrecedenceTypeApp +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Identifier + + +

+ +
+
+ Full Usage: + Identifier +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Ieee32 + + +

+ +
+
+ Full Usage: + Ieee32 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Ieee64 + + +

+ +
+
+ Full Usage: + Ieee64 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + If + + +

+ +
+
+ Full Usage: + If +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + In + + +

+ +
+
+ Full Usage: + In +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InactiveCode + + +

+ +
+
+ Full Usage: + InactiveCode +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixAmpersandOperator + + +

+ +
+
+ Full Usage: + InfixAmpersandOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixAsr + + +

+ +
+
+ Full Usage: + InfixAsr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixAtHatOperator + + +

+ +
+
+ Full Usage: + InfixAtHatOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixBarOperator + + +

+ +
+
+ Full Usage: + InfixBarOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixCompareOperator + + +

+ +
+
+ Full Usage: + InfixCompareOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixLand + + +

+ +
+
+ Full Usage: + InfixLand +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixLor + + +

+ +
+
+ Full Usage: + InfixLor +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixLsl + + +

+ +
+
+ Full Usage: + InfixLsl +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixLsr + + +

+ +
+
+ Full Usage: + InfixLsr +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixLxor + + +

+ +
+
+ Full Usage: + InfixLxor +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixMod + + +

+ +
+
+ Full Usage: + InfixMod +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixStarDivideModuloOperator + + +

+ +
+
+ Full Usage: + InfixStarDivideModuloOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + InfixStarStarOperator + + +

+ +
+
+ Full Usage: + InfixStarStarOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Inherit + + +

+ +
+
+ Full Usage: + Inherit +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Inline + + +

+ +
+
+ Full Usage: + Inline +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Instance + + +

+ +
+
+ Full Usage: + Instance +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int16 + + +

+ +
+
+ Full Usage: + Int16 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int32 + + +

+ +
+
+ Full Usage: + Int32 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int32DotDot + + +

+ +
+
+ Full Usage: + Int32DotDot +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int64 + + +

+ +
+
+ Full Usage: + Int64 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Int8 + + +

+ +
+
+ Full Usage: + Int8 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Interface + + +

+ +
+
+ Full Usage: + Interface +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Internal + + +

+ +
+
+ Full Usage: + Internal +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + JoinIn + + +

+ +
+
+ Full Usage: + JoinIn +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + KeywordString + + +

+ +
+
+ Full Usage: + KeywordString +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Lazy + + +

+ +
+
+ Full Usage: + Lazy +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftArrow + + +

+ +
+
+ Full Usage: + LeftArrow +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftBrace + + +

+ +
+
+ Full Usage: + LeftBrace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftBraceBar + + +

+ +
+
+ Full Usage: + LeftBraceBar +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftBracket + + +

+ +
+
+ Full Usage: + LeftBracket +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftBracketBar + + +

+ +
+
+ Full Usage: + LeftBracketBar +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftBracketLess + + +

+ +
+
+ Full Usage: + LeftBracketLess +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftParenthesis + + +

+ +
+
+ Full Usage: + LeftParenthesis +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftParenthesisStarRightParenthesis + + +

+ +
+
+ Full Usage: + LeftParenthesisStarRightParenthesis +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LeftQuote + + +

+ +
+
+ Full Usage: + LeftQuote +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Less + + +

+ +
+
+ Full Usage: + Less +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Let + + +

+ +
+
+ Full Usage: + Let +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + LineCommentTrivia + + +

+ +
+
+ Full Usage: + LineCommentTrivia +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Match + + +

+ +
+
+ Full Usage: + Match +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + MatchBang + + +

+ +
+
+ Full Usage: + MatchBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Member + + +

+ +
+
+ Full Usage: + Member +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Minus + + +

+ +
+
+ Full Usage: + Minus +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Module + + +

+ +
+
+ Full Usage: + Module +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Mutable + + +

+ +
+
+ Full Usage: + Mutable +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Namespace + + +

+ +
+
+ Full Usage: + Namespace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + NativeInt + + +

+ +
+
+ Full Usage: + NativeInt +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + New + + +

+ +
+
+ Full Usage: + New +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + None + + +

+ +
+
+ Full Usage: + None +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Null + + +

+ +
+
+ Full Usage: + Null +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Of + + +

+ +
+
+ Full Usage: + Of +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideAssert + + +

+ +
+
+ Full Usage: + OffsideAssert +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideBinder + + +

+ +
+
+ Full Usage: + OffsideBinder +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideBlockBegin + + +

+ +
+
+ Full Usage: + OffsideBlockBegin +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideBlockEnd + + +

+ +
+
+ Full Usage: + OffsideBlockEnd +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideBlockSep + + +

+ +
+
+ Full Usage: + OffsideBlockSep +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideDeclEnd + + +

+ +
+
+ Full Usage: + OffsideDeclEnd +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideDo + + +

+ +
+
+ Full Usage: + OffsideDo +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideDoBang + + +

+ +
+
+ Full Usage: + OffsideDoBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideElse + + +

+ +
+
+ Full Usage: + OffsideElse +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideEnd + + +

+ +
+
+ Full Usage: + OffsideEnd +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideFun + + +

+ +
+
+ Full Usage: + OffsideFun +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideFunction + + +

+ +
+
+ Full Usage: + OffsideFunction +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideInterfaceMember + + +

+ +
+
+ Full Usage: + OffsideInterfaceMember +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideLazy + + +

+ +
+
+ Full Usage: + OffsideLazy +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideLet + + +

+ +
+
+ Full Usage: + OffsideLet +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideReset + + +

+ +
+
+ Full Usage: + OffsideReset +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideRightBlockEnd + + +

+ +
+
+ Full Usage: + OffsideRightBlockEnd +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideThen + + +

+ +
+
+ Full Usage: + OffsideThen +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + OffsideWith + + +

+ +
+
+ Full Usage: + OffsideWith +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Open + + +

+ +
+
+ Full Usage: + Open +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Or + + +

+ +
+
+ Full Usage: + Or +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Override + + +

+ +
+
+ Full Usage: + Override +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + PercentOperator + + +

+ +
+
+ Full Usage: + PercentOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + PlusMinusOperator + + +

+ +
+
+ Full Usage: + PlusMinusOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + PrefixOperator + + +

+ +
+
+ Full Usage: + PrefixOperator +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Private + + +

+ +
+
+ Full Usage: + Private +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Public + + +

+ +
+
+ Full Usage: + Public +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + QuestionMark + + +

+ +
+
+ Full Usage: + QuestionMark +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + QuestionMarkQuestionMark + + +

+ +
+
+ Full Usage: + QuestionMarkQuestionMark +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Quote + + +

+ +
+
+ Full Usage: + Quote +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Rec + + +

+ +
+
+ Full Usage: + Rec +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Reserved + + +

+ +
+
+ Full Usage: + Reserved +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RightArrow + + +

+ +
+
+ Full Usage: + RightArrow +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RightBrace + + +

+ +
+
+ Full Usage: + RightBrace +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RightBracket + + +

+ +
+
+ Full Usage: + RightBracket +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RightParenthesis + + +

+ +
+
+ Full Usage: + RightParenthesis +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RightQuote + + +

+ +
+
+ Full Usage: + RightQuote +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + RightQuoteDot + + +

+ +
+
+ Full Usage: + RightQuoteDot +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Semicolon + + +

+ +
+
+ Full Usage: + Semicolon +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + SemicolonSemicolon + + +

+ +
+
+ Full Usage: + SemicolonSemicolon +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Sig + + +

+ +
+
+ Full Usage: + Sig +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Star + + +

+ +
+
+ Full Usage: + Star +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Static + + +

+ +
+
+ Full Usage: + Static +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + String + + +

+ +
+
+ Full Usage: + String +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + StringText + + +

+ +
+
+ Full Usage: + StringText +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Struct + + +

+ +
+
+ Full Usage: + Struct +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Then + + +

+ +
+
+ Full Usage: + Then +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + To + + +

+ +
+
+ Full Usage: + To +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + True + + +

+ +
+
+ Full Usage: + True +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Try + + +

+ +
+
+ Full Usage: + Try +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Type + + +

+ +
+
+ Full Usage: + Type +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt16 + + +

+ +
+
+ Full Usage: + UInt16 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt32 + + +

+ +
+
+ Full Usage: + UInt32 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt64 + + +

+ +
+
+ Full Usage: + UInt64 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UInt8 + + +

+ +
+
+ Full Usage: + UInt8 +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + UNativeInt + + +

+ +
+
+ Full Usage: + UNativeInt +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Underscore + + +

+ +
+
+ Full Usage: + Underscore +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Upcast + + +

+ +
+
+ Full Usage: + Upcast +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Val + + +

+ +
+
+ Full Usage: + Val +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Void + + +

+ +
+
+ Full Usage: + Void +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + When + + +

+ +
+
+ Full Usage: + When +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + While + + +

+ +
+
+ Full Usage: + While +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + WhileBang + + +

+ +
+
+ Full Usage: + WhileBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + WhitespaceTrivia + + +

+ +
+
+ Full Usage: + WhitespaceTrivia +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + With + + +

+ +
+
+ Full Usage: + With +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + Yield + + +

+ +
+
+ Full Usage: + Yield +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+ +

+ + + YieldBang + + +

+ +
+
+ Full Usage: + YieldBang +
+
+
+
+
+ 		+
+ + + +

+ +

+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokentag.html b/reference/fsharp-compiler-tokenization-fsharptokentag.html new file mode 100644 index 0000000000..cd1e3c0c91 --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokentag.html @@ -0,0 +1,4196 @@ + + + + + + + + + + + + + + + + + + FSharpTokenTag (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenTag Module +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ Some of the values in the field FSharpTokenInfo.Tag +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + AMP_AMP + + +

+ +
+
+ Full Usage: + AMP_AMP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `@@` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + BAR + + +

+ +
+
+ Full Usage: + BAR +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `_` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + BAR_BAR + + +

+ +
+
+ Full Usage: + BAR_BAR +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `||` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + BAR_RBRACK + + +

+ +
+
+ Full Usage: + BAR_RBRACK +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `|]` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + BEGIN + + +

+ +
+
+ Full Usage: + BEGIN +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `begin` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + CLASS + + +

+ +
+
+ Full Usage: + CLASS +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `class` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COLON + + +

+ +
+
+ Full Usage: + COLON +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `:` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COLON_COLON + + +

+ +
+
+ Full Usage: + COLON_COLON +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `::` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COLON_EQUALS + + +

+ +
+
+ Full Usage: + COLON_EQUALS +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `:=` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COLON_GREATER + + +

+ +
+
+ Full Usage: + COLON_GREATER +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `:>` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COLON_QMARK + + +

+ +
+
+ Full Usage: + COLON_QMARK +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `:?` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COLON_QMARK_GREATER + + +

+ +
+
+ Full Usage: + COLON_QMARK_GREATER +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `:?>` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COMMA + + +

+ +
+
+ Full Usage: + COMMA +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `,` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + COMMENT + + +

+ +
+
+ Full Usage: + COMMENT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a comment +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + DO + + +

+ +
+
+ Full Usage: + DO +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `do` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + DOT + + +

+ +
+
+ Full Usage: + DOT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `.` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + DOT_DOT + + +

+ +
+
+ Full Usage: + DOT_DOT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `..` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + DOT_DOT_HAT + + +

+ +
+
+ Full Usage: + DOT_DOT_HAT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `..` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + ELSE + + +

+ +
+
+ Full Usage: + ELSE +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `else` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + EQUALS + + +

+ +
+
+ Full Usage: + EQUALS +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `=` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + FUNCTION + + +

+ +
+
+ Full Usage: + FUNCTION +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `function` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + GREATER + + +

+ +
+
+ Full Usage: + GREATER +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `>` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + GREATER_RBRACK + + +

+ +
+
+ Full Usage: + GREATER_RBRACK +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `>]` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + IDENT + + +

+ +
+
+ Full Usage: + IDENT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is an identifier (synonym for FSharpTokenTag.Identifier) +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INFIX_AT_HAT_OP + + +

+ +
+
+ Full Usage: + INFIX_AT_HAT_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `^` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INFIX_BAR_OP + + +

+ +
+
+ Full Usage: + INFIX_BAR_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `|` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INFIX_COMPARE_OP + + +

+ +
+
+ Full Usage: + INFIX_COMPARE_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `|` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INFIX_STAR_DIV_MOD_OP + + +

+ +
+
+ Full Usage: + INFIX_STAR_DIV_MOD_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `%` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INT32_DOT_DOT + + +

+ +
+
+ Full Usage: + INT32_DOT_DOT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `..^` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INTERP_STRING_BEGIN_END + + +

+ +
+
+ Full Usage: + INTERP_STRING_BEGIN_END +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a part of an interpolated string +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INTERP_STRING_BEGIN_PART + + +

+ +
+
+ Full Usage: + INTERP_STRING_BEGIN_PART +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a part of an interpolated string +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INTERP_STRING_END + + +

+ +
+
+ Full Usage: + INTERP_STRING_END +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a part of an interpolated string +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + INTERP_STRING_PART + + +

+ +
+
+ Full Usage: + INTERP_STRING_PART +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a part of an interpolated string +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + Identifier + + +

+ +
+
+ Full Usage: + Identifier +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is an identifier +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LARROW + + +

+ +
+
+ Full Usage: + LARROW +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `<-` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LBRACE + + +

+ +
+
+ Full Usage: + LBRACE +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `{` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LBRACK + + +

+ +
+
+ Full Usage: + LBRACK +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `[` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LBRACK_BAR + + +

+ +
+
+ Full Usage: + LBRACK_BAR +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `[|` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LBRACK_LESS + + +

+ +
+
+ Full Usage: + LBRACK_LESS +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `[<` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LESS + + +

+ +
+
+ Full Usage: + LESS +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `<` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LINE_COMMENT + + +

+ +
+
+ Full Usage: + LINE_COMMENT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a line comment +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + LPAREN + + +

+ +
+
+ Full Usage: + LPAREN +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `(` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + MINUS + + +

+ +
+
+ Full Usage: + MINUS +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `-` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + NEW + + +

+ +
+
+ Full Usage: + NEW +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `new` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + OWITH + + +

+ +
+
+ Full Usage: + OWITH +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `with` in #light +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + PERCENT_OP + + +

+ +
+
+ Full Usage: + PERCENT_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `%` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + PLUS_MINUS_OP + + +

+ +
+
+ Full Usage: + PLUS_MINUS_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `+` or `-` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + PREFIX_OP + + +

+ +
+
+ Full Usage: + PREFIX_OP +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `~` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + QMARK + + +

+ +
+
+ Full Usage: + QMARK +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `?` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + QUOTE + + +

+ +
+
+ Full Usage: + QUOTE +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `"` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + RARROW + + +

+ +
+
+ Full Usage: + RARROW +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `->` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + RBRACE + + +

+ +
+
+ Full Usage: + RBRACE +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `}` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + RBRACK + + +

+ +
+
+ Full Usage: + RBRACK +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `]` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + RPAREN + + +

+ +
+
+ Full Usage: + RPAREN +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `)` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + SEMICOLON + + +

+ +
+
+ Full Usage: + SEMICOLON +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `;` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + STAR + + +

+ +
+
+ Full Usage: + STAR +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `*` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + STRING + + +

+ +
+
+ Full Usage: + STRING +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a string (synonym for FSharpTokenTag.String) +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + STRUCT + + +

+ +
+
+ Full Usage: + STRUCT +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `struct` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + String + + +

+ +
+
+ Full Usage: + String +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a string +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + THEN + + +

+ +
+
+ Full Usage: + THEN +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `then` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + TRY + + +

+ +
+
+ Full Usage: + TRY +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `try` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + UNDERSCORE + + +

+ +
+
+ Full Usage: + UNDERSCORE +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a `..` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + WHITESPACE + + +

+ +
+
+ Full Usage: + WHITESPACE +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is a whitespace +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+ +

+ + + WITH + + +

+ +
+
+ Full Usage: + WITH +
+
+ + Returns: + int + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the token is keyword `with` +

+
+ +
+
+ + Returns: + + int +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html b/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html new file mode 100644 index 0000000000..a8ce6542fd --- /dev/null +++ b/reference/fsharp-compiler-tokenization-fsharptokentriggerclass.html @@ -0,0 +1,904 @@ + + + + + + + + + + + + + + + + + + FSharpTokenTriggerClass (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharpTokenTriggerClass Type +

+
+
+ Namespace: + + FSharp.Compiler.Tokenization + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + Enum +
+
+ All Interfaces: + IComparable + , + IConvertible + , + ISpanFormattable + , + IFormattable +
+
+ Kind: Struct +
+
+ This is an enum type definition +
+
+
+
+

+ Gives an indication of what should happen when the token is typed in an IDE +

+
+
+
+
+
+
+
+

+ Record fields +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Record Field + + Description +
+
+ +

+ + + ChoiceSelect + + +

+ +
+
+ Full Usage: + ChoiceSelect +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + MatchBraces + + +

+ +
+
+ Full Usage: + MatchBraces +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + MemberSelect + + +

+ +
+
+ Full Usage: + MemberSelect +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + MethodTip + + +

+ +
+
+ Full Usage: + MethodTip +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + None + + +

+ +
+
+ Full Usage: + None +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + ParamEnd + + +

+ +
+
+ Full Usage: + ParamEnd +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + ParamNext + + +

+ +
+
+ Full Usage: + ParamNext +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+ +

+ + + ParamStart + + +

+ +
+
+ Full Usage: + ParamStart +
+
+ + Field type: + FSharpTokenTriggerClass + +
+ Modifiers: + static +
+
+
+
+ 		+
+
+ + Field type: + + FSharpTokenTriggerClass +
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-tokenization.html b/reference/fsharp-compiler-tokenization.html new file mode 100644 index 0000000000..c2114211cc --- /dev/null +++ b/reference/fsharp-compiler-tokenization.html @@ -0,0 +1,902 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Tokenization | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Tokenization Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + FSharpKeywords + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpLexer + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpLexerFlags + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpLineTokenizer + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Object to tokenize a line of F# source code, starting with the given lexState. The lexState should be FSharpTokenizerLexState.Initial for + the first line of text. Returns an array of ranges of the text and two enumerations categorizing the + tokens and characters covered by that range, i.e. FSharpTokenColorKind and FSharpTokenCharKind. The enumerations + are somewhat adhoc but useful enough to give good colorization options to the user in an IDE. + + A new lexState is also returned. An IDE-plugin should in general cache the lexState + values for each line of the edited code. +

+
+
+

+ + + FSharpSourceTokenizer + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Tokenizer for a source file. Holds some expensive-to-compute resources at the scope of the file. +

+
+
+

+ + + FSharpToken + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpTokenCharKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Gives an indication of the class to assign to the characters of the token an IDE +

+
+
+

+ + + FSharpTokenColorKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Gives an indication of the color class to assign to the token an IDE +

+
+
+

+ + + FSharpTokenInfo + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Information about a particular token from the tokenizer +

+
+
+

+ + + FSharpTokenizerColorState + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents stable information for the state of the lexing engine at the end of a line +

+
+
+

+ + + FSharpTokenizerLexState + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents encoded information for the end-of-line continuation of lexing +

+
+
+

+ + + FSharpTokenKind + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + FSharpTokenTag + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Some of the values in the field FSharpTokenInfo.Tag +

+
+
+

+ + + FSharpTokenTriggerClass + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Gives an indication of what should happen when the token is typed in an IDE +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-xml-prexmldoc.html b/reference/fsharp-compiler-xml-prexmldoc.html new file mode 100644 index 0000000000..eaff34aff0 --- /dev/null +++ b/reference/fsharp-compiler-xml-prexmldoc.html @@ -0,0 +1,1026 @@ + + + + + + + + + + + + + + + + + + PreXmlDoc (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ PreXmlDoc Type +

+
+
+ Namespace: + + FSharp.Compiler.Xml + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents the XmlDoc fragments as collected from the lexer during parsing +

+
+
+
+
+
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.IsEmpty + + +

+ +
+
+ Full Usage: + this.IsEmpty +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the PreXmlDoc is non-empty +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + Range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the overall range of the PreXmlDoc +

+
+ +
+
+ + Returns: + + Range +
+
+
+
+
+
+ +

+ + + this.ToXmlDoc + + +

+ +
+
+ Full Usage: + this.ToXmlDoc +
+
+ Parameters: +
    + + + check + + : + bool + +
    + + + paramNamesOpt + + : + string list option + +
    +
+
+ + Returns: + XmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Process and check the PreXmlDoc, checking with respect to the given parameter names +

+
+ +
+
+ + check + + : + bool +
+
+
+ + paramNamesOpt + + : + string list option +
+
+
+
+
+ + Returns: + + XmlDoc +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + PreXmlDoc.Create(unprocessedLines, range) + + +

+ +
+
+ Full Usage: + PreXmlDoc.Create(unprocessedLines, range) +
+
+ Parameters: +
    + + + unprocessedLines + + : + string[] + +
    + + + range + + : + range + +
    +
+
+ + Returns: + PreXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Create a PreXmlDoc from a collection of unprocessed lines +

+
+ +
+
+ + unprocessedLines + + : + string[] +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + PreXmlDoc +
+
+
+
+
+
+ +

+ + + PreXmlDoc.Empty + + +

+ +
+
+ Full Usage: + PreXmlDoc.Empty +
+
+ + Returns: + PreXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the empty PreXmlDoc +

+
+ +
+
+ + Returns: + + PreXmlDoc +
+
+
+
+
+
+ +

+ + + PreXmlDoc.Merge(a) (b) + + +

+ +
+
+ Full Usage: + PreXmlDoc.Merge(a) (b) +
+
+ Parameters: + +
+ + Returns: + PreXmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Merge two PreXmlDoc +

+
+ +
+
+ + a + + : + PreXmlDoc +
+
+
+ + b + + : + PreXmlDoc +
+
+
+
+
+ + Returns: + + PreXmlDoc +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-xml-xmldoc.html b/reference/fsharp-compiler-xml-xmldoc.html new file mode 100644 index 0000000000..c067b748d1 --- /dev/null +++ b/reference/fsharp-compiler-xml-xmldoc.html @@ -0,0 +1,1159 @@ + + + + + + + + + + + + + + + + + + XmlDoc (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ XmlDoc Type +

+
+
+ Namespace: + + FSharp.Compiler.Xml + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ Represents collected XmlDoc lines +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + XmlDoc(unprocessedLines, range) + + +

+ +
+
+ Full Usage: + XmlDoc(unprocessedLines, range) +
+
+ Parameters: +
    + + + unprocessedLines + + : + string[] + +
    + + + range + + : + range + +
    +
+
+ + Returns: + XmlDoc + +
+
+
+
+ 		+
+
+ + unprocessedLines + + : + string[] +
+
+
+ + range + + : + range +
+
+
+
+
+ + Returns: + + XmlDoc +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.GetElaboratedXmlLines + + +

+ +
+
+ Full Usage: + this.GetElaboratedXmlLines +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the lines after insertion of implicit summary tags and encoding +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+ +

+ + + this.GetXmlText + + +

+ +
+
+ Full Usage: + this.GetXmlText +
+
+ + Returns: + string + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the elaborated XML documentation as XML text +

+
+ +
+
+ + Returns: + + string +
+
+
+
+
+
+ +

+ + + this.IsEmpty + + +

+ +
+
+ Full Usage: + this.IsEmpty +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the XmlDoc is empty +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.NonEmpty + + +

+ +
+
+ Full Usage: + this.NonEmpty +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates if the XmlDoc is non-empty +

+
+ +
+
+ + Returns: + + bool +
+
+
+
+
+
+ +

+ + + this.Range + + +

+ +
+
+ Full Usage: + this.Range +
+
+ + Returns: + range + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Indicates the overall original source range of the XmlDoc +

+
+ +
+
+ + Returns: + + range +
+
+
+
+
+
+ +

+ + + this.UnprocessedLines + + +

+ +
+
+ Full Usage: + this.UnprocessedLines +
+
+ + Returns: + string[] + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the lines before insertion of implicit summary tags and encoding +

+
+ +
+
+ + Returns: + + string[] +
+
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + XmlDoc.Empty + + +

+ +
+
+ Full Usage: + XmlDoc.Empty +
+
+ + Returns: + XmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Get the empty XmlDoc +

+
+ +
+
+ + Returns: + + XmlDoc +
+
+
+
+
+
+ +

+ + + XmlDoc.Merge(doc1) (doc2) + + +

+ +
+
+ Full Usage: + XmlDoc.Merge(doc1) (doc2) +
+
+ Parameters: +
    + + + doc1 + + : + XmlDoc + +
    + + + doc2 + + : + XmlDoc + +
    +
+
+ + Returns: + XmlDoc + +
+
+
+
+ 		+
+ +
+
+ +
+
+ +
+ + + +

+ Merge two XML documentation +

+
+ +
+
+ + doc1 + + : + XmlDoc +
+
+
+ + doc2 + + : + XmlDoc +
+
+
+
+
+ + Returns: + + XmlDoc +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler-xml.html b/reference/fsharp-compiler-xml.html new file mode 100644 index 0000000000..46c464399b --- /dev/null +++ b/reference/fsharp-compiler-xml.html @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Xml | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler.Xml Namespace +

+
+ + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + PreXmlDoc + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents the XmlDoc fragments as collected from the lexer during parsing +

+
+
+

+ + + XmlDoc + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Represents collected XmlDoc lines +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-compiler.html b/reference/fsharp-compiler.html new file mode 100644 index 0000000000..421268d3ac --- /dev/null +++ b/reference/fsharp-compiler.html @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ FSharp.Compiler Namespace +

+
+ + + + + + + + + + + + + + + + + +
+ Type + + Description +
+

+ + + Cancellable + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + CompilerEnvironment + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ Information about the compilation environment +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/index.html b/reference/index.html new file mode 100644 index 0000000000..7b142d298c --- /dev/null +++ b/reference/index.html @@ -0,0 +1,640 @@ + + + + + + + + + + + + + + + + + + F# Compiler Guide (API Reference) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ API Reference +

+

+ Available Namespaces: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Namespace + + Description +
+ + FSharp.Compiler + +
+ + FSharp.Compiler.AbstractIL + +
+ + FSharp.Compiler.CodeAnalysis + +
+ + FSharp.Compiler.DependencyManager + +
+ + FSharp.Compiler.Diagnostics + +
+ + FSharp.Compiler.EditorServices + +
+ + FSharp.Compiler.IO + +
+ + FSharp.Compiler.Interactive + +
+ + FSharp.Compiler.Symbols + +
+ + FSharp.Compiler.Syntax + +
+ + FSharp.Compiler.SyntaxTrivia + +
+ + FSharp.Compiler.Text + +
+ + FSharp.Compiler.Tokenization + +
+ + FSharp.Compiler.Xml + +
+ + Internal.Utilities.Library + +
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/internal-utilities-library-delayinitarraymap-3.html b/reference/internal-utilities-library-delayinitarraymap-3.html new file mode 100644 index 0000000000..9819391717 --- /dev/null +++ b/reference/internal-utilities-library-delayinitarraymap-3.html @@ -0,0 +1,773 @@ + + + + + + + + + + + + + + + + + + DelayInitArrayMap<'T, 'TDictKey, 'TDictValue> (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ DelayInitArrayMap<'T, 'TDictKey, 'TDictValue> Type +

+
+
+ Namespace: + + Internal.Utilities.Library + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + DelayInitArrayMap(f) + + +

+ +
+
+ Full Usage: + DelayInitArrayMap(f) +
+
+ Parameters: +
    + + + f + + : + unit -> 'T[] + +
    +
+
+ + Returns: + DelayInitArrayMap<'T, 'TDictKey, 'TDictValue> + +
+
+
+
+ 		+
+
+ + f + + : + unit -> 'T[] +
+
+
+
+
+ + Returns: + + DelayInitArrayMap<'T, 'TDictKey, 'TDictValue> +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.CreateDictionary + + +

+ +
+
+ Full Usage: + this.CreateDictionary +
+
+ Parameters: +
    + + + arg0 + + : + 'T[] + +
    +
+
+ + Returns: + IDictionary<'TDictKey, 'TDictValue> + +
+ Modifiers: + abstract +
+
+
+
+ 		+
+
+ + arg0 + + : + 'T[] +
+
+
+
+
+ + Returns: + + IDictionary<'TDictKey, 'TDictValue> +
+
+
+
+
+ +

+ + + this.GetArray + + +

+ +
+
+ Full Usage: + this.GetArray +
+
+ + Returns: + 'T[] + +
+
+
+
+ 		+
+
+ + Returns: + + 'T[] +
+
+
+
+
+ +

+ + + this.GetDictionary + + +

+ +
+
+ Full Usage: + this.GetDictionary +
+
+ + Returns: + IDictionary<'TDictKey, 'TDictValue> + +
+
+
+
+ 		+
+
+ + Returns: + + IDictionary<'TDictKey, 'TDictValue> +
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/internal-utilities-library-interruptiblelazy-1.html b/reference/internal-utilities-library-interruptiblelazy-1.html new file mode 100644 index 0000000000..ffc531a99a --- /dev/null +++ b/reference/internal-utilities-library-interruptiblelazy-1.html @@ -0,0 +1,827 @@ + + + + + + + + + + + + + + + + + + InterruptibleLazy<'T> (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InterruptibleLazy<'T> Type +

+
+
+ Namespace: + + Internal.Utilities.Library + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+ Base Type: + obj +
+
+
+
+

+ +

+
+
+
+
+
+
+
+
+
+

+ Constructors +

+ + + + + + + + + + + + + +
+ Constructor + + Description +
+
+ +

+ + + InterruptibleLazy(valueFactory) + + +

+ +
+
+ Full Usage: + InterruptibleLazy(valueFactory) +
+
+ Parameters: +
    + + + valueFactory + + : + unit -> 'T + +
    +
+
+ + Returns: + InterruptibleLazy<'T> + +
+
+
+
+ 		+
+
+ + valueFactory + + : + unit -> 'T +
+
+
+
+
+ + Returns: + + InterruptibleLazy<'T> +
+
+
+
+
+
+

+ Instance members +

+ + + + + + + + + + + + + + + + + + + + + +
+ Instance member + + Description +
+
+ +

+ + + this.Force + + +

+ +
+
+ Full Usage: + this.Force +
+
+ + Returns: + 'T + +
+
+
+
+ 		+
+
+ + Returns: + + 'T +
+
+
+
+
+ +

+ + + this.IsValueCreated + + +

+ +
+
+ Full Usage: + this.IsValueCreated +
+
+ + Returns: + bool + +
+
+
+
+ 		+
+
+ + Returns: + + bool +
+
+
+
+
+ +

+ + + this.Value + + +

+ +
+
+ Full Usage: + this.Value +
+
+ + Returns: + 'T + +
+
+
+
+ 		+
+
+ + Returns: + + 'T +
+
+
+
+
+
+

+ Static members +

+ + + + + + + + + + + + + +
+ Static member + + Description +
+
+ +

+ + + InterruptibleLazy.FromValue(value) + + +

+ +
+
+ Full Usage: + InterruptibleLazy.FromValue(value) +
+
+ Parameters: +
    + + + value + + : + 'T + +
    +
+
+ + Returns: + InterruptibleLazy<'T> + +
+
+
+
+ 		+
+
+ + value + + : + 'T +
+
+
+
+
+ + Returns: + + InterruptibleLazy<'T> +
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/internal-utilities-library-interruptiblelazy.html b/reference/internal-utilities-library-interruptiblelazy.html new file mode 100644 index 0000000000..a345f1bcde --- /dev/null +++ b/reference/internal-utilities-library-interruptiblelazy.html @@ -0,0 +1,609 @@ + + + + + + + + + + + + + + + + + + InterruptibleLazy (F# Compiler Guide) | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ InterruptibleLazy Module +

+
+
+ Namespace: + + Internal.Utilities.Library + +
+
+ Assembly: FSharp.Compiler.Service.dll +
+
+
+
+

+ +

+
+
+
+

+ Functions and values +

+ + + + + + + + + + + + + +
+ Function or value + + Description +
+
+ +

+ + + force arg1 + + +

+ +
+
+ Full Usage: + force arg1 +
+
+ Parameters: + +
+ + Returns: + 'T + +
+
+
+
+ 		+
+
+ + arg0 + + : + InterruptibleLazy<'T> +
+
+
+
+
+ + Returns: + + 'T +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/reference/internal-utilities-library.html b/reference/internal-utilities-library.html new file mode 100644 index 0000000000..ab87293d9b --- /dev/null +++ b/reference/internal-utilities-library.html @@ -0,0 +1,599 @@ + + + + + + + + + + + + + + + + + + Internal.Utilities.Library | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+
+

+ Internal.Utilities.Library Namespace +

+
+ + + + + + + + + + + + + + + + + + + + + +
+ Type/Module + + Description +
+

+ + + DelayInitArrayMap<'T, 'TDictKey, 'TDictValue> + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + InterruptibleLazy + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+

+ + + InterruptibleLazy<'T> + + +

+ 		+
+
+ +
+
+ +
+ + + +

+ +

+
+
+
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/release-notes/About.html b/release-notes/About.html new file mode 100644 index 0000000000..7d68616d20 --- /dev/null +++ b/release-notes/About.html @@ -0,0 +1,564 @@ + + + + + + + + + + + + + + + + + + About | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

About

+

The release notes for the F# language, FSharp.Core and FSharp.Compiler.Service are based on the Keep a Changelog format.
+The target audience of these release notes are the respective end-users.

+

Writing a changelog entry

+

In order to keep the change logs consistent the following format was proposed for each entry:

+
* <Informative description>. ([PR #16106](https://github.com/dotnet/fsharp/pull/16106))
+
+

Some tips:

+ +

Example:

+
* Correctly handle assembly imports with public key token of 0 length. ([Issue #16359](https://github.com/dotnet/fsharp/issues/16359), [PR #16363](https://github.com/dotnet/fsharp/pull/16363))
+
+ +

Example:

+
* `while!` ([Language suggestion #1038](https://github.com/fsharp/fslang-suggestions/issues/1038), [PR #14238](https://github.com/dotnet/fsharp/pull/14238))
+
+ +

Example:

+
* Miscellaneous fixes to parentheses analysis. ([PR #16262](https://github.com/dotnet/fsharp/pull/16262), [PR #16391](https://github.com/dotnet/fsharp/pull/16391), [PR #16370](https://github.com/dotnet/fsharp/pull/16370))
+
+

The release process

+

General

+

How does it work? Different stages/phases?

+

FSharp.Compiler.Service

+

Perhaps add some specific info if available?

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/release-notes/FSharp.Compiler.Service.html b/release-notes/FSharp.Compiler.Service.html new file mode 100644 index 0000000000..cba2f6eeb5 --- /dev/null +++ b/release-notes/FSharp.Compiler.Service.html @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + FSharp.Compiler.Service | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

FSharp.Compiler.Service

+

43.8.200 - Unreleased

Fixed

+ +

Added

+ +

Changed

+ + +

43.8.100 - 2023-11-14

Nuget

Fixed

+ + + +
namespace System
+
namespace System.IO
+
namespace System.Xml
+
namespace System.Xml.XPath
+
namespace Markdig
+
module Common
+
val path: 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 fcsMajorVersion: string
+
val versionPropsDoc: System.Xml.Linq.XDocument
+
(extension) System.Xml.Linq.XNode.XPathSelectElement(expression: string) : System.Xml.Linq.XElement
(extension) System.Xml.Linq.XNode.XPathSelectElement(expression: string, resolver: System.Xml.IXmlNamespaceResolver) : System.Xml.Linq.XElement
+
val nugetPackage: string
+
val availableNuGetVersions: Set<string>
+
val getAvailableNuGetVersions: packageName: string -> Set<string>
 Find all published versions of a package on NuGet
+
val processFolder: path: string -> processFile: (string -> string) -> string
 Process all MarkDown files from the given release folder
+
val file: string
+
val versionInFileName: string
+
Path.GetFileNameWithoutExtension(path: string) : string
Path.GetFileNameWithoutExtension(path: System.ReadOnlySpan<char>) : System.ReadOnlySpan<char>
+
val versionParts: string array
+
System.String.Split([<System.ParamArray>] separator: char array) : string array
System.String.Split(separator: string array, options: System.StringSplitOptions) : string array
System.String.Split(separator: string, ?options: System.StringSplitOptions) : string array
System.String.Split(separator: char array, options: System.StringSplitOptions) : string array
System.String.Split(separator: char array, count: int) : string array
System.String.Split(separator: char, ?options: System.StringSplitOptions) : string array
System.String.Split(separator: string array, count: int, options: System.StringSplitOptions) : string array
System.String.Split(separator: string, count: int, ?options: System.StringSplitOptions) : string array
System.String.Split(separator: char array, count: int, options: System.StringSplitOptions) : string array
System.String.Split(separator: char, count: int, ?options: System.StringSplitOptions) : string array
+
val version: string
+
val title: string
+
member Set.Contains: value: 'T -> bool
+
val tryGetReleaseDate: packageName: string -> version: string -> string option
 Try and find the publish date on NuGet
+
union case Option.None: Option<'T>
+
union case Option.Some: Value: 'T -> Option<'T>
+
val d: string
+
val nugetBadge: string
+
Multiple items
type String = + interface IEnumerable<char> + interface IEnumerable + interface ICloneable + interface IComparable + interface IComparable<string> + interface IConvertible + interface IEquatable<string> + interface IParsable<string> + interface ISpanParsable<string> + new: value: nativeptr<char> -> unit + 8 overloads + ...
<summary>Represents text as a sequence of UTF-16 code units.</summary>

--------------------
System.String(value: nativeptr<char>) : System.String
System.String(value: char array) : System.String
System.String(value: System.ReadOnlySpan<char>) : System.String
System.String(value: nativeptr<sbyte>) : System.String
System.String(c: char, count: int) : System.String
System.String(value: nativeptr<char>, startIndex: int, length: int) : System.String
System.String(value: char array, startIndex: int, length: int) : System.String
System.String(value: nativeptr<sbyte>, startIndex: int, length: int) : System.String
System.String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: System.Text.Encoding) : System.String
+
field string.Empty: string
+
val content: string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.ReadAllText(path: string) : string
File.ReadAllText(path: string, encoding: System.Text.Encoding) : string
+
type Markdown = + static member Convert: markdown: string * renderer: IMarkdownRenderer * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> obj + static member Normalize: markdown: string * ?options: NormalizeOptions * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> string + 1 overload + static member Parse: markdown: string * ?trackTrivia: bool -> MarkdownDocument + 1 overload + static member ToHtml: markdown: string * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> string + 3 overloads + static member ToPlainText: markdown: string * writer: TextWriter * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> MarkdownDocument + 1 overload + static member Version: string
<summary> + Provides methods for parsing a Markdown string to a syntax tree and converting it to other formats. + </summary>
+
Markdown.ToHtml(document: Syntax.MarkdownDocument, ?pipeline: MarkdownPipeline) : string
Markdown.ToHtml(document: Syntax.MarkdownDocument, writer: TextWriter, ?pipeline: MarkdownPipeline) : unit
Markdown.ToHtml(markdown: string, ?pipeline: MarkdownPipeline, ?context: MarkdownParserContext) : string
Markdown.ToHtml(markdown: string, writer: TextWriter, ?pipeline: MarkdownPipeline, ?context: MarkdownParserContext) : Syntax.MarkdownDocument
+
val transformH3: version: string -> input: string -> string
 In order for the heading to appear in the page content menu in fsdocs,
 they need to follow a specific HTML structure.
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/release-notes/FSharp.Core.html b/release-notes/FSharp.Core.html new file mode 100644 index 0000000000..00428833c5 --- /dev/null +++ b/release-notes/FSharp.Core.html @@ -0,0 +1,647 @@ + + + + + + + + + + + + + + + + + + FSharp.Core | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

FSharp.Core

+

8.0.200 - Unreleased

Fixed

+ +

Added

+ +

Changed

+ + +

8.0.100 - 2023-11-14

Nuget

Fixed

+ + + +
namespace System
+
namespace System.IO
+
namespace Markdig
+
module Common
+
val path: 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 nugetPackage: string
+
val availableNuGetVersions: Set<string>
+
val getAvailableNuGetVersions: packageName: string -> Set<string>
 Find all published versions of a package on NuGet
+
val processFolder: path: string -> processFile: (string -> string) -> string
 Process all MarkDown files from the given release folder
+
val file: string
+
val version: string
+
Path.GetFileNameWithoutExtension(path: string) : string
Path.GetFileNameWithoutExtension(path: System.ReadOnlySpan<char>) : System.ReadOnlySpan<char>
+
val title: string
+
member Set.Contains: value: 'T -> bool
+
val tryGetReleaseDate: packageName: string -> version: string -> string option
 Try and find the publish date on NuGet
+
union case Option.None: Option<'T>
+
union case Option.Some: Value: 'T -> Option<'T>
+
val d: string
+
val nugetBadge: string
+
Multiple items
type String = + interface IEnumerable<char> + interface IEnumerable + interface ICloneable + interface IComparable + interface IComparable<string> + interface IConvertible + interface IEquatable<string> + interface IParsable<string> + interface ISpanParsable<string> + new: value: nativeptr<char> -> unit + 8 overloads + ...
<summary>Represents text as a sequence of UTF-16 code units.</summary>

--------------------
System.String(value: nativeptr<char>) : System.String
System.String(value: char array) : System.String
System.String(value: System.ReadOnlySpan<char>) : System.String
System.String(value: nativeptr<sbyte>) : System.String
System.String(c: char, count: int) : System.String
System.String(value: nativeptr<char>, startIndex: int, length: int) : System.String
System.String(value: char array, startIndex: int, length: int) : System.String
System.String(value: nativeptr<sbyte>, startIndex: int, length: int) : System.String
System.String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: System.Text.Encoding) : System.String
+
field System.String.Empty: string
+
val content: string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.ReadAllText(path: string) : string
File.ReadAllText(path: string, encoding: System.Text.Encoding) : string
+
type Markdown = + static member Convert: markdown: string * renderer: IMarkdownRenderer * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> obj + static member Normalize: markdown: string * ?options: NormalizeOptions * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> string + 1 overload + static member Parse: markdown: string * ?trackTrivia: bool -> MarkdownDocument + 1 overload + static member ToHtml: markdown: string * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> string + 3 overloads + static member ToPlainText: markdown: string * writer: TextWriter * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> MarkdownDocument + 1 overload + static member Version: string
<summary> + Provides methods for parsing a Markdown string to a syntax tree and converting it to other formats. + </summary>
+
Markdown.ToHtml(document: Syntax.MarkdownDocument, ?pipeline: MarkdownPipeline) : string
Markdown.ToHtml(document: Syntax.MarkdownDocument, writer: TextWriter, ?pipeline: MarkdownPipeline) : unit
Markdown.ToHtml(markdown: string, ?pipeline: MarkdownPipeline, ?context: MarkdownParserContext) : string
Markdown.ToHtml(markdown: string, writer: TextWriter, ?pipeline: MarkdownPipeline, ?context: MarkdownParserContext) : Syntax.MarkdownDocument
+
val transformH3: version: string -> input: string -> string
 In order for the heading to appear in the page content menu in fsdocs,
 they need to follow a specific HTML structure.
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/release-notes/Language.html b/release-notes/Language.html new file mode 100644 index 0000000000..935863d8a1 --- /dev/null +++ b/release-notes/Language.html @@ -0,0 +1,621 @@ + + + + + + + + + + + + + + + + + + F# Language | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

F# Language

+

Preview

Added

+ +

Fixed

+ + +

8.0

Added

+ + + +
namespace System
+
namespace System.IO
+
namespace Markdig
+
module Common
+
val path: 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
+
type Directory = + static member CreateDirectory: path: string -> DirectoryInfo + 1 overload + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateTempSubdirectory: ?prefix: string -> DirectoryInfo + static member Delete: path: string -> unit + 1 overload + static member EnumerateDirectories: path: string -> IEnumerable<string> + 3 overloads + static member EnumerateFileSystemEntries: path: string -> IEnumerable<string> + 3 overloads + static member EnumerateFiles: path: string -> IEnumerable<string> + 3 overloads + static member Exists: path: string -> bool + static member GetCreationTime: path: string -> DateTime + static member GetCreationTimeUtc: path: string -> DateTime + ...
<summary>Exposes static methods for creating, moving, and enumerating through directories and subdirectories. This class cannot be inherited.</summary>
+
Directory.EnumerateFiles(path: string) : System.Collections.Generic.IEnumerable<string>
Directory.EnumerateFiles(path: string, searchPattern: string) : System.Collections.Generic.IEnumerable<string>
Directory.EnumerateFiles(path: string, searchPattern: string, searchOption: SearchOption) : System.Collections.Generic.IEnumerable<string>
Directory.EnumerateFiles(path: string, searchPattern: string, enumerationOptions: EnumerationOptions) : System.Collections.Generic.IEnumerable<string>
+
module Seq + +from Microsoft.FSharp.Collections
+
val sortWith: comparer: ('T -> 'T -> int) -> source: 'T seq -> 'T seq
+
val a: string
+
val b: string
+
Path.GetFileNameWithoutExtension(path: string) : string
Path.GetFileNameWithoutExtension(path: System.ReadOnlySpan<char>) : System.ReadOnlySpan<char>
+
val compare: e1: 'T -> e2: 'T -> int (requires comparison)
+
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+
val map: mapping: ('T -> 'U) -> source: 'T seq -> 'U seq
+
val file: string
+
val version: string
+
val content: string
+
type File = + static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload + static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendAllText: path: string * contents: string -> unit + 1 overload + static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload + static member AppendText: path: string -> StreamWriter + static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload + static member Create: path: string -> FileStream + 2 overloads + static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo + static member CreateText: path: string -> StreamWriter + static member Decrypt: path: string -> unit + ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
+
File.ReadAllText(path: string) : string
File.ReadAllText(path: string, encoding: System.Text.Encoding) : string
+
type Markdown = + static member Convert: markdown: string * renderer: IMarkdownRenderer * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> obj + static member Normalize: markdown: string * ?options: NormalizeOptions * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> string + 1 overload + static member Parse: markdown: string * ?trackTrivia: bool -> MarkdownDocument + 1 overload + static member ToHtml: markdown: string * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> string + 3 overloads + static member ToPlainText: markdown: string * writer: TextWriter * ?pipeline: MarkdownPipeline * ?context: MarkdownParserContext -> MarkdownDocument + 1 overload + static member Version: string
<summary> + Provides methods for parsing a Markdown string to a syntax tree and converting it to other formats. + </summary>
+
Markdown.ToHtml(document: Syntax.MarkdownDocument, ?pipeline: MarkdownPipeline) : string
Markdown.ToHtml(document: Syntax.MarkdownDocument, writer: TextWriter, ?pipeline: MarkdownPipeline) : unit
Markdown.ToHtml(markdown: string, ?pipeline: MarkdownPipeline, ?context: MarkdownParserContext) : string
Markdown.ToHtml(markdown: string, writer: TextWriter, ?pipeline: MarkdownPipeline, ?context: MarkdownParserContext) : Syntax.MarkdownDocument
+
val transformH3: version: string -> input: string -> string
 In order for the heading to appear in the page content menu in fsdocs,
 they need to follow a specific HTML structure.
+
module String + +from Microsoft.FSharp.Core
+
val concat: sep: string -> strings: string seq -> string
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/representations.html b/representations.html new file mode 100644 index 0000000000..9027cae321 --- /dev/null +++ b/representations.html @@ -0,0 +1,565 @@ + + + + + + + + + + + + + + + + + + Representations | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Representation Decisions in the F# Compiler

+

Consider the following declarations, all of which look very similar.

+
module M = 
+    let z = 1                   
+    let f = x + z               
+                                
+
+type C(w: int, z: int) =        
+                                
+    let f x = x + z             
+    let f x = f 3 + x           
+                                
+
+let g (z: int) =                
+    let f x = x + 1             
+
+

Part of the job of the F# compiler is to "decide" how these declarations are compiled. The following acts as a guide to how these different bindings are represented and where these decisions are made.

+

First for module-level let bindings. These representations are decided by code in CheckExpressions.fs and CheckDeclarations.fs based on syntax.

+
module M = 
+    let z = 1              // z --> static property + field, required by spec, compiled name mandated
+    let f x = x + z          // f --> static method, required by spec, compiled name mandated
+
+

Next for class-level let bindings. These representations are decided by code in CheckIncrementalClasses.fs based on analysis of use.

+
//    Decided in CheckIncrementalClasses.fs based on analysis of use
+type C(w: int, z: int) =   // w --> local to object constructor, required by spec
+                           // z --> private instance field, required by spec
+    let f x = x + z        // f --> private instance method, required by spec, compiled name not mandated
+                           // Note: initially uses an ephemeral 'f' Val then creates a member Val with compiled name
+                           
+    let f x = f 3 + x      // f --> private instance method, required by spec, compiled name not mandated
+                           // Note: initially uses an ephemeral 'f' Val then creates a member Val with compiled name
+                           
+    static let g x = x + 1 // g --> private static method, required by spec, compiled name not mandated, initially uses an ephemeral 'g' Val then creates a member Val with compiled name
+    
+    static let g x = g 3   // g --> private static method, required by spec, compiled name not mandated, initially uses an ephemeral 'g' Val then creates a member Val with compiled name
+
+

Next for expression-level let bindings. These representations are decided by code in various optimization phases.

+
let g (z: int) =          // z --> local + field in closure for 'f', not mandated
+    let f x = x + 1       // f --> FSharpFunc value, or maybe a static method, not mandated 
+                          //    Decided in various optimization phases
+
+
+

NOTE: The representation decision is implied by the addition of ValReprInfo to the Val node.

+
+ +
module M + +from representations
+
val z: int
+
val f: int
+
type C = + new: w: int * z: int -> C
+
val w: int
+
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = + int
+
val f: x: int -> int
+
val x: int
+
val g: z: int -> 'a
+
Multiple items
type C = + new: w: int * z: int -> C

--------------------
new: w: int * z: int -> C
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/running-documentation-locally.html b/running-documentation-locally.html new file mode 100644 index 0000000000..989f77dd70 --- /dev/null +++ b/running-documentation-locally.html @@ -0,0 +1,548 @@ + + + + + + + + + + + + + + + + + + Running the documentation locally | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Running the documentation locally

+

The source of this documentation website is hosted on https://github.com/fsharp/fsharp-compiler-docs.
+You can follow this guide to see the results of your document changes rendered in the browser.

+

Setup

+

fsharp/fsharp-compiler-docs will clone the dotnet/fsharp repository first to generate the documentation.
+You can however, easily run the documentation locally and modify the docs from dotnet/fsharp.

+ +
git clone https://github.com/fsharp/fsharp-compiler-docs.git
+
+ +
cd fsharp-compiler-docs/FSharp.Compiler.Service
+dotnet restore
+
+ +
cd ..
+dotnet tool restore
+
+ +
dotnet fsdocs watch --eval --sourcefolder ../fsharp/ --input ../fsharp/docs/
+
+

Release notes caveat

+

The release notes pages from docs/release-notes are composed from the MarkDown files in subfolders.
+Changing any of these files, won't regenerate the served webpage. Only the changes to the .fsx will trigger the tool. This is a known limitation.

+ +
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
+ +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file diff --git a/tooling-features.html b/tooling-features.html new file mode 100644 index 0000000000..ec1ce34f5f --- /dev/null +++ b/tooling-features.html @@ -0,0 +1,741 @@ + + + + + + + + + + + + + + + + + + Overview | F# Compiler Guide + + + + + + + + + + + +
+
+ + + Header menu logo + F# Compiler Guide + +
+
+ + + + + +
+
+ +
+
+ +

Overview

+

The F# Language Service (FSharp.Editor, using FSharp.Compiler.Service) is designed to support tooling in Visual Studio and other IDEs. This document gives an overview of the features supported and notes on their technical characteristics.

+

Kinds of data processed and served in F# tooling

+

The following tables are split into two categories: syntactic and semantic. They contain common kinds of information requested, the kind of data that is involved, and roughly how expensive the operation is in terms of expected memory allocation and CPU processing.

+

IDE actions based on syntax

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Action

Data inspected

Data returned

Expected CPU/Allocations (S/M/L/XL)

Syntactic Classification

Current doc's source text

Text span and classification type for each token in the document

S

Breakpoint Resolution

Current doc's syntax tree

Text span representing where breakpoints were resolved

S

Debugging data tip info

Current doc's source text

Text span representing the token being inspected

S

Brace pair matching

Current doc's source text

Text spans representing brace pairs that match in the input document

S

"Smart" indentation

Current doc's source text

Indentation location in a document

S

Code fixes operating only on syntax

Current doc's source text

Small text change for document

S

XML doc template generation

Current doc's syntax tree

Small (usually) text change for document

S

Brace pair completion

Current doc's source text

Additional brace pair inserted into source text

S

Souce document navigation

Current doc's syntax tree

"Navigation Items" with optional child navigation items containing ranges in source code

S

Code outlining

Current doc's source text

Text spans representing blocks of F# code that are collapsable as a group

S - M

Editor formatting

Current doc's source text

New source text for the document

S - L

Syntax diagnostics

Current doc's source text

List of diagnostic data including the span of text corresponding to the diagnostic

S

Global construct search and navigation

All syntax trees for all projects

All items that match a user's search pattern with spans of text that represent where a given item is located

S-L

+ +

You likely noticed that nearly all of the syntactical operations are marked S. Aside from extreme cases, like files with 50k lines or higher, syntax-only operations typically finish very quickly. In addition to being computationally inexpensive, they are also run asynchronously and free-threaded.

+

Editor formatting is a bit of an exception. Most IDEs offer common commands for format an entire document, and although they also offer commands to format a given text selection, users typically choose to format the whole document. This means an entire document has to be inspected and potentially rewritten based on often complex rules. In practice this isn't bad when working with a document that has already been formatted, but it can be expensive for larger documents with strange stylistic choices.

+

Most of the syntax operations require an entire document's source text or parse tree. It stands to reason that this could be improved by operating on a diff of a parse tree instead of the whole thing. This is likely a very complex thing to implement though, since none of the F# compiler infrastructure works in this way today.

+

IDE actions based on semantics

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Action

Data inspected

Data returned

Expected CPU/Allocations (S/M/L/XL)

Most code fixes

Current document's typecheck data

Set (1 or more) of suggested text replacements

S-M

Semantic classification

Current document's typecheck data

Spans of text with semantic classification type for all constructs in a document

S-L

Code generation / refactorings

Current document's typecheck data and/or current resolved symbol/symbols

Text replacement(s)

S-L

Code completion

Current document's typecheck data and currently-resolved symbol user is typing at

List of all symbols in scope that are "completable" based on where completion is invoked

S-L

Editor tooltips

Current document's typecheck data and resolved symbol where user invoked a tooltip

F# tooltip data based on inspecting a type and its declarations, then pretty-printing them

S-XL

Diagnostics based on F# semantics

Current document's typecheck data

Diagnostic info for each symbol with diagnostics to show, including the range of text associated with the diagnostic

M-XL

Symbol highlighting in a document

Current document's typecheck data and currently-resolved symbol where user's caret is located

Ranges of text representing instances of that symbol in the document

S-M

Semantic navigation (for example, Go to Definition)

Current document's typecheck data and currently-resolved symbol where the user invoked navigation

Location of a symbol's declaration

S-M

Rename

Graph of all projects that use the symbol that rename is triggered on and the typecheck data for each of those projects

List of all uses of all symbols that are to be renamed

S-XL

Find all references

Graph of all projects that Find References is triggered on and the typecheck data for each of those projects

List of all uses of all symbols that are found

S-XL

Unused value/symbol analysis

Typecheck data for the current document

List of all symbols that aren't a public API and are unused

S-M

Unused open analysis

Typecheck data for the current document and all symbol data brought into scope by each open declaration

List of open declarations whose symbols it exposes aren't used in the current document

S-L

Missing open analysis

Typecheck data for the current document, resolved symbol with an error, and list of available namespaces or modules

List of candidate namespaces or modules that can be opened

S-M

Misspelled name suggestion analysis

Typecheck data for the current document and resolved symbol with an error

List of candidates that are in scope and best match the misspelled name based on a string distance algorithm

S-M

Name simplification analysis

Typecheck data for the current document and all symbol data brought into scope by each open declaration

List of text changes available for any fully- or partially-qualified symbol that can be simplified

S-XL

+ +

You likely noticed that every cost associated with an action has a range. This is based on two factors:

+
    +
  1. If the semantic data being operated on is cached
    2. +
  2. How much semantic data must be processed for the action to be completed
    3. +
+

Most actions are S if they operate on cached data and the compiler determines that no data needs to be re-computed. The size of their range is influenced largely by the kind of semantic operations each action has to do, such as:

+ +

For example, commands like Find All References and Rename can be cheap if a codebase is small, hence the lower bound being S. But if the symbol in question is used across many documents in a large project graph, they are very expensive because the entire graph must be crawled and all symbols contained in its documents must be inspected.

+

In contrast, actions like highlighting all symbols in a document aren't terribly expensive even for very large files. That's because the symbols to be inspected are ultimately only in a single document.

+ + +
+
+ + + +
+ +

Type something to start searching.

+
+ + + + + + + + \ No newline at end of file