F# Documentation

https://learn.microsoft.com/en-us/dotnet/fsharp
Admin
F# is a functional-first programming language that enables developers to write robust, scalable...
Tokens:228,854
Snippets:2,908
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example Constructor Usage

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/creating-a-type-provider

Demonstrates how the generated constructor is called in user code.

```fsharp
new Type10()
```

--------------------------------

### Install Azure Storage Queues package

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/queue-storage

Use the #r directive to install the required NuGet package and open the namespace.

```fsharp
> #r "nuget: Azure.Storage.Queues"
open Azure.Storage.Queues
```

--------------------------------

### Output of the let bindings example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/members/let-bindings-in-classes

The console output resulting from the execution of the PointWithCounter class example.

```Console
10 52 1 204
```

--------------------------------

### Namespace example output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/namespaces

The console output resulting from the multi-module namespace example.

```F#
Module1 10 20
Module2 5 6
```

--------------------------------

### Output of for...to loop examples

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/loops-for-to-expression

The console output resulting from the provided loop examples.

```text
1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
```

--------------------------------

### Example of while...do expression

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/loops-while-do-expression

A practical example demonstrating a loop that continues until a specific random value is generated.

```fsharp
open System

let lookForValue value maxValue =
  let mutable continueLooping = true
  let randomNumberGenerator = new Random()
  while continueLooping do
    // Generate a random number between 1 and maxValue.
    let rand = randomNumberGenerator.Next(maxValue)
    printf "%d " rand
    if rand = value then
       printfn "\nFound a %d!" value
       continueLooping <- false

lookForValue 10 20
```

--------------------------------

### Console Output Example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/units-of-measure

Shows the expected console output for the temperature conversion program.

```text
Enter a temperature in degrees Fahrenheit.
90
That temperature in degrees Celsius is    32.22.
```

--------------------------------

### Output of while...do example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/loops-while-do-expression

The console output resulting from the execution of the provided while...do example.

```text
13 19 8 18 16 2 10
Found a 10!
```

--------------------------------

### Using First-Class Functions

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/using-functions

Examples of storing functions in data structures and passing them as arguments.

```fsharp
let funTuple2 = ( BMICalculator, fun n -> n * n )



let increments = List.map (fun n -> n + 1) [ 1; 2; 3; 4; 5; 6; 7 ]
```

--------------------------------

### Output of parameter array example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/parameters-and-arguments

The console output resulting from the parameter array demonstration.

```Console
a 1 10 Hello world 1 True
"a"
1
10.0
"Hello world"
1u
true
```

--------------------------------

### Instantiate Provided Type

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/creating-a-type-provider

Example of calling a provided constructor with a string argument.

```F#
new Type10("ten")
```

--------------------------------

### View #help output for List.map

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tools/fsharp-interactive

Example output displayed when querying documentation for List.map.

```text
Description:
Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection.

Parameters:
- mapping: The function to transform elements from the input list.
- list: The input list.

Returns:
The list of transformed elements.

Examples:
let inputs = [ "a"; "bbb"; "cc" ]

inputs |> List.map (fun x -> x.Length)
// Evaluates to [ 1; 3; 2 ]

Full name: Microsoft.FSharp.Collections.ListModule.map
Assembly: FSharp.Core.dll
```

--------------------------------

### Install Azure Data Tables package

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/table-storage

Use the #r directive to install the Azure.Data.Tables NuGet package in an F# script.

```fsharp
> #r "nuget: Azure.Data.Tables"
open Azure.Data.Tables
```

--------------------------------

### Basic F# syntax example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/what-is-fsharp

Demonstrates list definition, function creation, and pipeline processing to print greetings.

```fsharp
open System // Gets access to functionality in System namespace.

// Defines a list of names
let names = [ "Peter"; "Julia"; "Xi" ]

// Defines a function that takes a name and produces a greeting.
let getGreeting name = $"Hello, {name}"

// Prints a greeting for each name!
names
|> List.map getGreeting
|> List.iter (fun greeting -> printfn $"{greeting}! Enjoy your F#")
```

--------------------------------

### F# console output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/exception-handling/the-try-finally-expression

Expected console output from the resource management example.

```text
Closing stream
Exception handled.
```

--------------------------------

### Parameterized active pattern output for let-bindings

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/active-patterns

The console output resulting from the let-binding example.

```text
Hello, random citizen!
Hello, George!
```

--------------------------------

### Named argument delegate output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/delegates

Console output for the named argument delegate example.

```text
aa
```

--------------------------------

### Singleton Data Source Usage

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/creating-a-type-provider

Example of referencing a singleton data source provider and accessing its data.

```F#
#r "Fabrikam.Data.Freebase.dll"

let data = Fabrikam.Data.Freebase.Astronomy.Asteroids
```

--------------------------------

### Explicit Entry Point Output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/functions/entry-point

Example output when running an F# application with an explicit entry point.

```console
Arguments passed to function : [|"1"; "2"; "3"|]
```

--------------------------------

### Create a new solution

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Initializes a new .NET solution file.

```bash
dotnet new sln -o FSharpSample
```

--------------------------------

### Console output for sequence examples

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/sequences

The expected output generated by the Seq.unfold examples.

```Console
The sequence seq1 contains numbers from 0 to 20.

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

The sequence fib contains Fibonacci numbers.

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
```

--------------------------------

### Create Sample SQL Database

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/query-expressions

SQL script to initialize the MyDatabase schema and populate it with course, student, and selection data.

```sql
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

USE [master];
GO

IF EXISTS (SELECT * FROM sys.databases WHERE name = 'MyDatabase')
DROP DATABASE MyDatabase;
GO

-- Create the MyDatabase database.
CREATE DATABASE MyDatabase COLLATE SQL_Latin1_General_CP1_CI_AS;
GO

-- Specify a simple recovery model
-- to keep the log growth to a minimum.
ALTER DATABASE MyDatabase
SET RECOVERY SIMPLE;
GO

USE MyDatabase;
GO

CREATE TABLE [dbo].[Course] (
[CourseID]   INT           NOT NULL,
[CourseName] NVARCHAR (50) NOT NULL,
PRIMARY KEY CLUSTERED ([CourseID] ASC)
);

CREATE TABLE [dbo].[Student] (
[StudentID] INT           NOT NULL,
[Name]      NVARCHAR (50) NOT NULL,
[Age]       INT           NULL,
PRIMARY KEY CLUSTERED ([StudentID] ASC)
);

CREATE TABLE [dbo].[CourseSelection] (
[ID]        INT NOT NULL,
[StudentID] INT NOT NULL,
[CourseID]  INT NOT NULL,
PRIMARY KEY CLUSTERED ([ID] ASC),
CONSTRAINT [FK_CourseSelection_ToTable] FOREIGN KEY ([StudentID]) REFERENCES [dbo].[Student] ([StudentID]) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT [FK_CourseSelection_Course_1] FOREIGN KEY ([CourseID]) REFERENCES [dbo].[Course] ([CourseID]) ON DELETE NO ACTION ON UPDATE NO ACTION
);

CREATE TABLE [dbo].[LastStudent] (
[StudentID] INT           NOT NULL,
[Name]      NVARCHAR (50) NOT NULL,
[Age]       INT           NULL,
PRIMARY KEY CLUSTERED ([StudentID] ASC)
);

-- Insert data into the tables.
USE MyDatabase
INSERT INTO Course (CourseID, CourseName)
VALUES(1, 'Algebra I');
INSERT INTO Course (CourseID, CourseName)
VALUES(2, 'Trigonometry');
INSERT INTO Course (CourseID, CourseName)
VALUES(3, 'Algebra II');
INSERT INTO Course (CourseID, CourseName)
VALUES(4, 'History');
INSERT INTO Course (CourseID, CourseName)
VALUES(5, 'English');
INSERT INTO Course (CourseID, CourseName)
VALUES(6, 'French');
INSERT INTO Course (CourseID, CourseName)
VALUES(7, 'Chinese');

INSERT INTO Student (StudentID, Name, Age)
VALUES(1, 'Abercrombie, Kim', 10);
INSERT INTO Student (StudentID, Name, Age)
VALUES(2, 'Abolrous, Hazen', 14);
INSERT INTO Student (StudentID, Name, Age)
VALUES(3, 'Hance, Jim', 12);
INSERT INTO Student (StudentID, Name, Age)
VALUES(4, 'Adams, Terry', 12);
INSERT INTO Student (StudentID, Name, Age)
VALUES(5, 'Hansen, Claus', 11);
INSERT INTO Student (StudentID, Name, Age)
VALUES(6, 'Penor, Lori', 13);
INSERT INTO Student (StudentID, Name, Age)
VALUES(7, 'Perham, Tom', 12);
INSERT INTO Student (StudentID, Name, Age)
VALUES(8, 'Peng, Yun-Feng', NULL);

INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(1, 1, 2);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(2, 1, 3);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(3, 1, 5);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(4, 2, 2);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(5, 2, 5);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(6, 2, 6);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(7, 2, 3);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(8, 3, 2);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(9, 3, 1);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(10, 4, 2);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(11, 4, 5);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(12, 4, 2);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(13, 5, 3);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(14, 5, 2);
INSERT INTO CourseSelection (ID, StudentID, CourseID)
VALUES(15, 7, 3);
```

--------------------------------

### Example hierarchical listing output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/blob-storage

Sample output showing the hierarchical structure returned by GetBlobsByHierarchy.

```text
Directory: https://<accountname>.blob.core.windows.net/photos/2015/
Directory: https://<accountname>.blob.core.windows.net/photos/2016/
Block blob of length 505623: https://<accountname>.blob.core.windows.net/photos/photo1.jpg
```

--------------------------------

### Implement static and non-static do bindings

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/members/do-bindings-in-classes

Example demonstrating a class with constructor parameters, let bindings, and both static and non-static do bindings.

```F#
open System

type MyType(a: int, b: int) as this =
    inherit Object()
    let x = 2 * a
    let y = 2 * b
    do printfn "Initializing object %d %d %d %d %d %d" a b x y (this.Prop1) (this.Prop2)
    static do printfn "Initializing MyType."
    member this.Prop1 = 4 * x
    member this.Prop2 = 4 * y

    override this.ToString() =
        System.String.Format("{0} {1}", this.Prop1, this.Prop2)

let obj1 = new MyType(1, 2)
```

--------------------------------

### Console Output Example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/conditional-expressions-if-then-else

The expected output from the provided F# conditional logic example.

```Console
10 is less than 20
What is your name? John
How old are you? 9
You are only 9 years old and already learning F#? Wow!
```

--------------------------------

### Create a new F# project

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-vscode

Use the .NET CLI to scaffold a new F# console application.

```bash
dotnet new console -lang "F#" -o FirstIonideProject
```

--------------------------------

### Console output for abstract class example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/abstract-classes

The expected output when running the provided F# code.

```text
Perimeter of square with side length 10.000000 is 40.000000
Circumference of circle with radius 5.000000 is 31.415927
Area of Square: 100.000000
Area of Circle: 78.539816
```

--------------------------------

### Create the ShareClient

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/file-storage

Initialize a ShareClient to interact with a specific file share.

```fsharp
let share = ShareClient(storageConnString, "shareName")
```

--------------------------------

### Asynchronous Computation Expression Example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions

A practical example of using the async computation expression to fetch and process data.

```fsharp
let fetchAndDownload url =
    async {
        let! data = downloadData url

        let processedData = processData data

        return processedData
    }
```

--------------------------------

### Open project in VS Code

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-vscode

Navigate to the project directory and launch Visual Studio Code.

```bash
cd FirstIonideProject
code .
```

--------------------------------

### Create a class library project

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Creates a new F# class library project in the src directory.

```bash
dotnet new classlib -lang "F#" -o src/Library
```

--------------------------------

### Multiple modules in a single file

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/modules

Example of defining multiple local modules within a single file.

```F#
// In the file multiplemodules.fs.
// MyModule1
module MyModule1 =
    // Indent all program elements within modules that are declared with an equal sign.
    let module1Value = 100

    let module1Function x =
        x + 10

// MyModule2
module MyModule2 =

    let module2Value = 121

    // Use a qualified name to access the function.
    // from MyModule1.
    let module2Function x =
        x * (MyModule1.module1Function module2Value)
```

--------------------------------

### Define an F# signature file

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/signature-files

Example of a .fsi file declaring namespaces, modules, functions, and types with attributes.

```fsharp
// Module1.fsi

namespace Library1
  module Module1 =
    val function1 : int -> int
    type Type1 =
        new : unit -> Type1
        member method1 : unit -> unit
        member method2 : unit -> unit

    [<Sealed>]
    type Type2 =
        new : unit -> Type2
        member method1 : unit -> unit
        member method2 : unit -> unit

    [<Interface>]
    type InterfaceType1 =
        abstract member method1 : int -> int
        abstract member method2 : string -> unit
```

--------------------------------

### Invalid byref scoping examples

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/byrefs

These examples demonstrate code that is disallowed because the byref reference would exceed the scope of the defined value.

```fsharp
let test2 () =
    let x = 12
    &x // Error: 'x' exceeds its defined scope!

let test () =
    let x =
        let y = 1
        &y // Error: `y` exceeds its defined scope!
    ()
```

--------------------------------

### Create the queue service client

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/queue-storage

Initialize a QueueClient instance to interact with a specific queue.

```fsharp
let queueClient = QueueClient(storageConnString, "myqueue")
```

--------------------------------

### Iterating with for...to loops

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/loops-for-to-expression

Examples demonstrating standard iteration, reverse iteration using downto, and using functions to define loop boundaries.

```fsharp
// A simple for...to loop.
let function1() =
  for i = 1 to 10 do
    printf "%d " i
  printfn ""

// A for...to loop that counts in reverse.
let function2() =
  for i = 10 downto 1 do
    printf "%d " i
  printfn ""

function1()
function2()

// A for...to loop that uses functions as the start and finish expressions.
let beginning x y = x - 2*y
let ending x y = x + 2*y

let function3 x y =
  for i = (beginning x y) to (ending x y) do
     printf "%d " i
  printfn ""

function3 10 4
```

--------------------------------

### Example output for Seq.windowed

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/sequences

The console output resulting from the Seq.windowed operation.

```text
1.0 1.5 2.0 1.5 1.0 1.5

Windows of length 3:
[|1.0; 1.5; 2.0|] [|1.5; 2.0; 1.5|] [|2.0; 1.5; 1.0|] [|1.5; 1.0; 1.5|]

Moving average:
1.5 1.666666667 1.5 1.333333333
```

--------------------------------

### Output of operator usage

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/generics/statically-resolved-type-parameters

The console output resulting from the operator examples.

```Console
2
1.500000
```

--------------------------------

### Implementing let bindings in a class

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/members/let-bindings-in-classes

Example demonstrating instance and static let bindings, including mutable variables and private functions within a class.

```F#
type PointWithCounter(a: int, b: int) =
    // A variable i.
    let mutable i = 0

    // A let binding that uses a pattern.
    let (x, y) = (a, b)

    // A private function binding.
    let privateFunction x y = x * x + 2 * y

    // A static let binding.
    static let mutable count = 0

    // A do binding.
    do count <- count + 1

    member this.Prop1 = x
    member this.Prop2 = y
    member this.CreatedCount = count
    member this.FunctionValue = privateFunction x y

let point1 = PointWithCounter(10, 52)

printfn "%d %d %d %d" (point1.Prop1) (point1.Prop2) (point1.CreatedCount) (point1.FunctionValue)
```

--------------------------------

### Pattern Matching Output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/records

The console output resulting from the pattern matching example.

```Console
Point is at the origin.
Point is on the x-axis. Value is 100.000000.
Point is at (10.000000, 0.000000, -1.000000).
```

--------------------------------

### Initialize TableServiceClient

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/table-storage

Create a client instance to interact with the Table service.

```fsharp
let tableClient = TableServiceClient storageConnString
```

--------------------------------

### Source Identifier Output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/source-line-file-path-identifiers

Example output generated by the source identifier code.

```text
Line: 4
Source Directory: C:\Users\username\Documents\Visual Studio 2017\Projects\SourceInfo\SourceInfo
Source File: Program.fs
```

--------------------------------

### Defining and invoking delegates for static and instance methods

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/delegates

Demonstrates creating delegates for static and instance methods with both tupled and curried argument forms.

```fsharp
type Test1() =
  static member add(a : int, b : int) =
     a + b
  static member add2 (a : int) (b : int) =
     a + b

  member x.Add(a : int, b : int) =
     a + b
  member x.Add2 (a : int) (b : int) =
     a + b


// Delegate1 works with tuple arguments.
type Delegate1 = delegate of (int * int) -> int
// Delegate2 works with curried arguments.
type Delegate2 = delegate of int * int -> int

let InvokeDelegate1 (dlg: Delegate1) (a: int) (b: int) =
   dlg.Invoke(a, b)
let InvokeDelegate2 (dlg: Delegate2) (a: int) (b: int) =
   dlg.Invoke(a, b)

// For static methods, use the class name, the dot operator, and the
// name of the static method.
let del1 = Delegate1(Test1.add)
let del2 = Delegate2(Test1.add2)

let testObject = Test1()

// For instance methods, use the instance value name, the dot operator, and the instance method name.
let del3 = Delegate1(testObject.Add)
let del4 = Delegate2(testObject.Add2)

for (a, b) in [ (100, 200); (10, 20) ] do
  printfn "%d + %d = %d" a b (InvokeDelegate1 del1 a b)
  printfn "%d + %d = %d" a b (InvokeDelegate2 del2 a b)
  printfn "%d + %d = %d" a b (InvokeDelegate1 del3 a b)
  printfn "%d + %d = %d" a b (InvokeDelegate2 del4 a b)
```

--------------------------------

### Initialize BlobContainerClient

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/blob-storage

Creates a client instance to manage containers and blobs using the connection string.

```fsharp
let container = BlobContainerClient(storageConnString, "mycontainer")
```

--------------------------------

### Delegate execution output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/delegates

Console output resulting from the delegate usage examples.

```text
aaaaa
bbbbb
ccccc
[|"aaa"; "bbb"|]
```

--------------------------------

### Expression Printing Output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/code-quotations

The expected output from running the expression printing example.

```fsharp
fun (x:System.Int32) -> x + 1
a + 1
let f = fun (x:System.Int32) -> x + 10 in f 10
```

--------------------------------

### Module Syntax

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/verbose-syntax

Comparison of lightweight and verbose syntax for modules.

```fsharp
module <module-name> =
    ...
```

```fsharp
module <module-name> =
    begin
        ...
    end
```

--------------------------------

### Native pointer allocation

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/compiler-messages/fs0009

Example of using NativePtr.stackalloc which triggers the FS0009 warning.

```fsharp
let n: nativeptr<bool> = NativeInterop.NativePtr.stackalloc 1
```

--------------------------------

### Opening nested modules

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/import-declarations-the-open-keyword

Demonstrates how nested modules are opened sequentially.

```fsharp
open A // opens A
open B // opens A.B
```

--------------------------------

### Formatting Lambda Arguments

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/style-guide/formatting

Lambda arguments should start on the same line as the opening parenthesis.

```fsharp
// ✔️ OK
builder
    .WithEnvironment()
    .WithLogger(fun loggerConfiguration ->
        // ...
        ())

// ❌ Not OK, formatting tools will reformat to the above
builder
    .WithEnvironment()
    .WithLogger(
        fun loggerConfiguration ->
        // ...
        ())
```

--------------------------------

### Interface Implementation Syntax

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/verbose-syntax

Comparison of lightweight and verbose syntax for interface implementations.

```fsharp
interface <interface-name>
    with
        <value-or-member-definitions>
```

```fsharp
interface <interface-name>
    with
        <value-or-member-definitions>
    end
```

--------------------------------

### Async.Start

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/async

Starts an asynchronous computation in the thread pool without waiting for completion.

```APIDOC
## Async.Start

### Description
Starts an asynchronous computation that returns unit in the thread pool. It does not wait for completion or observe exception outcomes.
```

--------------------------------

### Implement Object Expressions

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/object-expressions

Examples demonstrating overriding base class methods, implementing interfaces, and implementing multiple interfaces using object expressions.

```fsharp
// This object expression specifies a System.Object but overrides the
// ToString method.
let obj1 = { new System.Object() with member x.ToString() = "F#" }
printfn $"{obj1}"

// This object expression implements the IFormattable interface.
let delimiter(delim1: string, delim2: string, value: string) =
    { new System.IFormattable with
        member x.ToString(format: string, provider: System.IFormatProvider) =
            if format = "D" then
                delim1 + value + delim2
            else
                value }

let obj2 = delimiter("{","}", "Bananas!");

printfn "%A" (System.String.Format("{0:D}", obj2))

// Define two interfaces
type IFirst =
  abstract F : unit -> unit
  abstract G : unit -> unit

type ISecond =
  inherit IFirst
  abstract H : unit -> unit
  abstract J : unit -> unit

// This object expression implements both interfaces.
let implementer() =
    { new ISecond with
        member this.H() = ()
        member this.J() = ()
      interface IFirst with
        member this.F() = ()
        member this.G() = () }
```

--------------------------------

### Evaluate function with vowel input

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-vscode

Call the function with a word starting with a vowel.

```F#
toPigLatin "apple";;
```

--------------------------------

### Create a table

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/using-fsharp-on-azure/table-storage

Retrieve a table reference and create it if it does not exist.

```fsharp
// Retrieve a reference to the table.
let table = tableClient.GetTableClient "people"

// Create the table if it doesn't exist.
table.CreateIfNotExists () |> ignore
```

--------------------------------

### Implement console application entry point

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Main entry point for the console application that consumes the library.

```fsharp
open System
open Library

[<EntryPoint>]
let main args =
    printfn "Nice command-line arguments! Here's what System.Text.Json has to say about them:"

    let value, json = getJson {| args=args; year=System.DateTime.Now.Year |}
    printfn $"Input: %0A{value}"
    printfn $"Output: %s{json}"

    0 // return an integer exit code
```

--------------------------------

### Define record types

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/records

Examples of defining standard records and struct records in F#.

```F#
// Labels are separated by semicolons when defined on the same line.
type Point = { X: float; Y: float; Z: float }

// You can define labels on their own line with or without a semicolon.
type Customer =
    { First: string
      Last: string
      SSN: uint32
      AccountNumber: uint32 }

// A struct record.
[<Struct>]
type StructPoint = { X: float; Y: float; Z: float }
```

--------------------------------

### Create .NET tasks using async expressions

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-6

Demonstrates the traditional approach of creating a .NET-compatible task using async expressions and Async.AwaitTask.

```fsharp
let readFilesTask (path1, path2) =
   async {
        let! bytes1 = File.ReadAllBytesAsync(path1) |> Async.AwaitTask
        let! bytes2 = File.ReadAllBytesAsync(path2) |> Async.AwaitTask
        return Array.append bytes1 bytes2
   } |> Async.StartAsTask
```

--------------------------------

### Create a generic type abbreviation

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/type-abbreviations

An example of a type abbreviation that includes generic parameters.

```fsharp
type Transform<'a> = 'a -> 'a
```

--------------------------------

### Create a simple type abbreviation

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/type-abbreviations

An example of creating a simple alias for a primitive type.

```fsharp
type SizeType = uint32
```

--------------------------------

### View solution directory structure

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Displays the directory structure after creating the solution.

```text
FSharpSample
    ├── FSharpSample.sln
```

--------------------------------

### Run console application

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Navigates to the app directory and executes the application with arguments.

```bash
cd src/App
dotnet run Hello World
```

--------------------------------

### Console Output for Discriminated Union Example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/parameters-and-arguments

The expected output from the GetSubstring1 function execution.

```Console
Data begins at 0 and ends at 4 in string Et tu, Brute?
Et tu
```

--------------------------------

### Vector Operator Output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/operator-overloading

The console output resulting from the Vector operator overloading example.

```text
1 2
2 4
2 4
-2 -4
```

--------------------------------

### Call Base Class Constructor

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/inheritance

Example showing how to pass arguments to a base class constructor using the inherit clause.

```fsharp
type MyClassBase2(x: int) =
    let mutable z = x * x

    do
        for i in 1..z do
            printf "%d " i


type MyClassDerived2(y: int) =
    inherit MyClassBase2(y * 2)

    do
        for i in 1..y do
            printf "%d " i
```

--------------------------------

### Simplifying code with open

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/import-declarations-the-open-keyword

Demonstrates how opening a namespace like System.IO removes the need for fully qualified names when accessing types like FileStream and StreamWriter.

```fsharp
// Without the import declaration, you must include the full
// path to .NET Framework namespaces such as System.IO.
let writeToFile1 filename (text: string) =
  let stream1 = new System.IO.FileStream(filename, System.IO.FileMode.Create)
  let writer = new System.IO.StreamWriter(stream1)
  writer.WriteLine(text)

// Open a .NET Framework namespace.
open System.IO

// Now you do not have to include the full paths.
let writeToFile2 filename (text: string) =
  let stream1 = new FileStream(filename, FileMode.Create)
  let writer = new StreamWriter(stream1)
  writer.WriteLine(text)

writeToFile2 "file1.txt" "Testing..."
```

--------------------------------

### Reference cell output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/reference-cells

The console output resulting from the reference cell usage example.

```text
10
11
```

--------------------------------

### Output of explicit field example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/members/explicit-fields-the-val-keyword

The console output resulting from the MyType class execution.

```Console
11 12 abc
30 def
```

--------------------------------

### Define a generic function

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/functions

Example of a function that uses automatic generalization to accept any type.

```fsharp
let f x = (x, x)
```

--------------------------------

### Add library to solution

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Registers the library project with the solution file.

```bash
dotnet sln add src/Library/Library.fsproj
```

--------------------------------

### Define a script for loading

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tools/fsharp-interactive

Create a script file containing functions to be reused elsewhere.

```fsharp
let square x = x * x
```

--------------------------------

### Output of invalidArg example

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/exception-handling/the-invalidarg-function

The console output resulting from the provided lookupMonth function execution.

```text
December
January
System.ArgumentException: Value passed in was 13. (Parameter 'month')
```

--------------------------------

### Handle Multiple Constructors with Inheritance

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/inheritance

Example demonstrating how to handle multiple constructors in a derived class using explicit fields and the inherit clause.

```fsharp
type BaseClass =
    val string1 : string
    new (str) = { string1 = str }
    new () = { string1 = "" }

type DerivedClass =
    inherit BaseClass

    val string2 : string
    new (str1, str2) = { inherit BaseClass(str1); string2 = str2 }
    new (str2) = { inherit BaseClass(); string2 = str2 }

let obj1 = DerivedClass("A", "B")
let obj2 = DerivedClass("A")
```

--------------------------------

### Demonstrating Seq.concat with Flexible Types

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/flexible-types

Examples of passing different enumerable combinations to Seq.concat.

```F#
let list1 = [1;2;3]
let list2 = [4;5;6]
let list3 = [7;8;9]

let concat1 = Seq.concat [ list1; list2; list3]
printfn "%A" concat1

let array1 = [|1;2;3|]
let array2 = [|4;5;6|]
let array3 = [|7;8;9|]

let concat2 = Seq.concat [ array1; array2; array3 ]
printfn "%A" concat2

let concat3 = Seq.concat [| list1; list2; list3 |]
printfn "%A" concat3

let concat4 = Seq.concat [| array1; array2; array3 |]
printfn "%A" concat4

let seq1 = { 1 .. 3 }
let seq2 = { 4 .. 6 }
let seq3 = { 7 .. 9 }

let concat5 = Seq.concat [| seq1; seq2; seq3 |]

printfn "%A" concat5
```

--------------------------------

### Execute script with assembly reference

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tools/fsharp-interactive

Run the script using the dotnet fsi command.

```console
dotnet fsi Script.fsx
90
```

--------------------------------

### Parameterized active pattern output

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/active-patterns

The console output resulting from the date parsing example.

```text
12/22/2008 12:00:00 AM 1/1/2009 12:00:00 AM 1/15/2008 12:00:00 AM 12/28/1995 12:00:00 AM
```

--------------------------------

### Entry Point Syntax

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/functions/entry-point

The syntax for defining an explicit entry point using the EntryPoint attribute.

```fsharp
[<EntryPoint>]
let-function-binding
```

--------------------------------

### Get function documentation with #help

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tools/fsharp-interactive

Use the #help directive followed by a function name to display its documentation in the interactive session.

```fsharp
#help List.map;;
```

--------------------------------

### Defining a delegate with named parameters

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/delegates

Example of adding names to delegate parameters for clarity.

```fsharp
// http://www.pinvoke.net/default.aspx/user32/WinEventDelegate.html
type WinEventDelegate = delegate of hWinEventHook:nativeint * eventType:uint32 * hWnd:nativeint * idObject:int * idChild:int * dwEventThread:uint32 * dwmsEventTime:uint32 -> unit
```

--------------------------------

### Applying functions with partial application

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/using-functions

Demonstrates creating specialized functions by partially applying arguments to a function.

```fsharp
let playGame = makeGame 7
// Send in some guesses.
playGame 2
playGame 9
playGame 7

// Output:
// Wrong. Try again.
// Wrong. Try again.
// You win!

// The following game specifies a character instead of an integer for target.
let alphaGame = makeGame 'q'
alphaGame 'c'
alphaGame 'r'
alphaGame 'j'
alphaGame 'q'

// Output:
// Wrong. Try again.
// Wrong. Try again.
// Wrong. Try again.
// You win!
```

--------------------------------

### Console output for byref assignment

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/byrefs

The expected output after executing the byref assignment example.

```text
Original sequence: 1 3 7 15 31 63 127 255 511 1023
New sequence:      1 3 7 30 31 63 127 255 511 1023
```

--------------------------------

### Using Source Identifiers in F#

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/source-line-file-path-identifiers

Example demonstrating how to print the current line number, source directory, and file name.

```F#
let printSourceLocation() =
    printfn "Line: %s" __LINE__
    printfn "Source Directory: %s" __SOURCE_DIRECTORY__
    printfn "Source File: %s" __SOURCE_FILE__
printSourceLocation()
```

--------------------------------

### Defining inref semantics

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/byrefs

Example of an inref parameter where the pointer is restricted to read-only access.

```fsharp
let f (x: inref<SomeStruct>) = x.SomeField
```

--------------------------------

### Explicit struct layout

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/compiler-messages/fs0009

Example of defining a struct with LayoutKind.Explicit, which triggers the FS0009 warning.

```fsharp
open System.Runtime.InteropServices

[<Struct; StructLayout(LayoutKind.Explicit)>]
type EmptyStruct = 
    struct end
```

--------------------------------

### Project elements with select

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/query-expressions

Projects each of the elements selected so far.

```fsharp
query {
    for student in db.Student do
    select student
}
```

--------------------------------

### Defining and Using Indexed Properties

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/members/indexed-properties

Demonstrates the implementation of default and non-default indexed properties with get and set methods.

```fsharp
type NumberStrings() =
    let mutable ordinals =
        [| "one"
           "two"
           "three"
           "four"
           "five"
           "six"
           "seven"
           "eight"
           "nine"
           "ten" |]

    let mutable cardinals =
        [| "first"
           "second"
           "third"
           "fourth"
           "fifth"
           "sixth"
           "seventh"
           "eighth"
           "ninth"
           "tenth" |]

    member this.Item
        with get (index) = ordinals[index]
        and set index value = ordinals[index] <- value

    member this.Ordinal
        with get (index) = ordinals[index]
        and set index value = ordinals[index] <- value

    member this.Cardinal
        with get (index) = cardinals[index]
        and set index value = cardinals[index] <- value

let nstrs = new NumberStrings()
nstrs[0] <- "ONE"

for i in 0..9 do
    printf "%s " nstrs[i]

printfn ""

nstrs.Cardinal(5) <- "6th"

for i in 0..9 do
    printf "%s " (nstrs.Ordinal(i))
    printf "%s " (nstrs.Cardinal(i))

printfn ""
```

--------------------------------

### Apply DllImport Attribute

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/attributes

Example of using an attribute with both a positional argument and a named property.

```F#
open System.Runtime.InteropServices

[<DllImport("kernel32", SetLastError=true)>]
extern bool CloseHandle(nativeint handle)
```

--------------------------------

### View directory structure after app creation

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-command-line

Displays the directory structure after adding the console application.

```text
└── FSharpSample
    ├── FSharpSample.sln
    └── src
        ├── App
        │   ├── App.fsproj
        │   ├── Program.fs
        └── Library
            ├── Library.fs
            └── Library.fsproj
```

--------------------------------

### Indentation syntax in F# 6

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-6

Examples of indentation-aware syntax that are now consistently allowed in F# 6.

```fsharp
let c = (
    printfn "aaaa"
    printfn "bbbb"
)
```

```fsharp
let c = [
    1
    2
]
```

--------------------------------

### Connectivity Protocol Namespace Convention

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/creating-a-type-provider

Example of namespace usage for connectivity protocol type providers.

```F#
  Fabrikam.Management.BasicTypeProviders.WmiConnection<…>
  Fabrikam.Management.BasicTypeProviders.DataProtocolConnection<…>
```

--------------------------------

### while...do Loop Syntax

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/verbose-syntax

Comparison of lightweight and verbose syntax for while...do loops.

```fsharp
while <condition> do
    ...
```

```fsharp
while <condition> do
    ...
done
```

--------------------------------

### Implement Virtual Method and Override

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/inheritance

Example demonstrating the declaration of a virtual method in a base class and its subsequent override in a derived class.

```fsharp
type MyClassBase1() =
    let mutable z = 0
    abstract member function1: int -> int

    default u.function1(a: int) =
        z <- z + a
        z

type MyClassDerived1() =
    inherit MyClassBase1()
    override u.function1(a: int) = a + 1
```

--------------------------------

### Create F# Tuples

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/tuples

Examples of creating tuples with various types, expressions, and struct definitions.

```F#
(1, 2)

// Triple of strings.
("one", "two", "three")

// Tuple of generic types.
(a, b)

// Tuple that has mixed types.
("one", 1, 2.0)

// Tuple of integer expressions.
(a + 1, b + 1)

// Struct Tuple of floats
struct (1.025f, 1.5f)
```

--------------------------------

### Nullable Type Examples

Source: https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/values/null-values

Demonstrates applying nullable annotations to various F# type constructs.

```fsharp
type AB = A | B
type AbNull = AB | null

type RecordField = { X: string | null }
type TupleField = string * string | null

type NestedGenerics = { Z : List<List<string | null> | null> | null }
```
Tokens:
Raw