Array (FSharp.Core)

Returns a new array that contains all pairings of elements from the first and second arrays.

array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: ('T1 * 'T2) array: The resulting array of pairs.

 ([| 1; 2 |], [| 3; 4 |]) ||> Array.allPairs

module Array from Microsoft.FSharp.Collections

val allPairs: array1: 'T1 array -> array2: 'T2 array -> ('T1 * 'T2) array

Evaluates to

 [| (1, 3); (1, 4); (2, 3); (2, 4) |]

Builds a new array that contains the elements of the first array followed by the elements of the second array.

array1 : 'T array: The first input array.
array2 : 'T array: The second input array.

Returns: 'T array: The resulting array.

 Array.append [| 1; 2 |] [| 3; 4 |]

module Array from Microsoft.FSharp.Collections

val append: array1: 'T array -> array2: 'T array -> 'T array

Evaluates to [| 1; 2; 3; 4 |].

Returns the average of the elements in the array.

array : ^T array: The input array.

Returns: ^T: The average of the elements in the array.

 [| 1.0; 2.0; 6.0 |] |> Array.average

module Array from Microsoft.FSharp.Collections

val average: array: 'T array -> 'T (requires member (+) and member DivideByInt and member Zero)

Evaluates to 3.0

 [| |] |> Array.average

module Array from Microsoft.FSharp.Collections

val average: array: 'T array -> 'T (requires member (+) and member DivideByInt and member Zero)

Throws ArgumentException

Returns the average of the elements generated by applying the function to each element of the array.

projection : 'T -> ^U: The function to transform the array elements before averaging.
array : 'T array: The input array.

Returns: ^U: The computed average.

 type Foo = { Bar: float }

 let input = [| {Bar = 2.0}; {Bar = 4.0} |]

 input |> Array.averageBy (fun foo -> foo.Bar)

type Foo = { Bar: float }

Multiple items
val float: value: 'T -> float (requires member op_Explicit)

--------------------
type float = System.Double

--------------------
type float<'Measure> = float

val input: Foo array

module Array from Microsoft.FSharp.Collections

val averageBy: projection: ('T -> 'U) -> array: 'T array -> 'U (requires member (+) and member DivideByInt and member Zero)

val foo: Foo

Foo.Bar: float

Evaluates to 3.0

 type Foo = { Bar: float }

 let input : Foo array = [| |]

 input |> Array.averageBy (fun foo -> foo.Bar)

type Foo = { Bar: float }

Multiple items
val float: value: 'T -> float (requires member op_Explicit)

--------------------
type float = System.Double

--------------------
type float<'Measure> = float

val input: Foo array

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val averageBy: projection: ('T -> 'U) -> array: 'T array -> 'U (requires member (+) and member DivideByInt and member Zero)

val foo: Foo

Foo.Bar: float

Throws ArgumentException

Reads a range of elements from the first array and write them into the second.

 let source = [| 12; 13; 14 |]
 let target = [| 0; 1; 2; 3; 4; 5 |]
 target[3..4] <- source[1..2]

val source: int array

val target: int array

This is an O(count) operation.

source : 'T array: The source array.
sourceIndex : int: The starting index of the source array.
target : 'T array: The target array.
targetIndex : int: The starting index of the target array.
count : int: The number of elements to copy.

ArgumentNullException	Thrown when either of the input arrays is null.
ArgumentException	Thrown when any of sourceIndex, targetIndex or count are negative, or when there aren't enough elements in source or target.

 let source = [| 12; 13; 14 |]
 let target = [| 0; 1; 2; 3; 4; 5 |]

 Array.blit source 1 target 3 2

val source: int array

val target: int array

module Array from Microsoft.FSharp.Collections

val blit: source: 'T array -> sourceIndex: int -> target: 'T array -> targetIndex: int -> count: int -> unit

After evaluation target contains [| 0; 1; 2; 13; 14; 5 |].

Applies the given function to each element of the array. Returns the array comprised of the results x for each element where the function returns Some(x)

chooser : 'T -> 'U option: The function to generate options from the elements.
array : 'T array: The input array.

Returns: 'U array: The array of results.

 let input = [| Some 1; None; Some 2 |]

 input |> Array.choose id

val input: int option array

union case Option.Some: Value: 'T -> Option<'T>

union case Option.None: Option<'T>

module Array from Microsoft.FSharp.Collections

val choose: chooser: ('T -> 'U option) -> array: 'T array -> 'U array

val id: x: 'T -> 'T

Evaluates to [| 1; 2 |]

 let input = [| 1; 2; 3 |]

 input |> Array.choose (fun n -> if n % 2 = 0 then Some n else None)

val input: int array

module Array from Microsoft.FSharp.Collections

val choose: chooser: ('T -> 'U option) -> array: 'T array -> 'U array

val n: int

union case Option.Some: Value: 'T -> Option<'T>

union case Option.None: Option<'T>

Evaluates to [| 2 |]

Divides the input array into chunks of size at most chunkSize.

chunkSize : int: The maximum size of each chunk.
array : 'T array: The input array.

Returns: 'T array array: The array divided into chunks.

 let input = [| 1; 2; 3 |]

 input |> Array.chunkBySize 2

val input: int array

module Array from Microsoft.FSharp.Collections

val chunkBySize: chunkSize: int -> array: 'T array -> 'T array array

Evaluates to [| [|1; 2|]; [|3|] |]

 let input = [| 1; 2; 3 |]

 input |> Array.chunkBySize -2

val input: int array

module Array from Microsoft.FSharp.Collections

val chunkBySize: chunkSize: int -> array: 'T array -> 'T array array

Throws ArgumentException

For each element of the array, applies the given function. Concatenates all the results and return the combined array.

mapping : 'T -> 'U array: The function to create sub-arrays from the input array elements.
array : 'T array: The input array.

Returns: 'U array: The concatenation of the sub-arrays.

 type Foo = { Bar: int array }

 let input = [| {Bar = [| 1; 2 |]}; {Bar = [| 3; 4 |]} |]

 input |> Array.collect (fun foo -> foo.Bar)

type Foo = { Bar: int array }

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

val input: Foo array

module Array from Microsoft.FSharp.Collections

val collect: mapping: ('T -> 'U array) -> array: 'T array -> 'U array

val foo: Foo

Foo.Bar: int array

Evaluates to [| 1; 2; 3; 4 |]

 let input = [[1; 2]; [3; 4]]

 input |> Array.collect id

val input: int list list

module Array from Microsoft.FSharp.Collections

val collect: mapping: ('T -> 'U array) -> array: 'T array -> 'U array

val id: x: 'T -> 'T

Evaluates to [| 1; 2; 3; 4 |]

Compares two arrays using the given comparison function, element by element.

comparer : 'T -> 'T -> int: A function that takes an element from each array and returns an int. If it evaluates to a non-zero value iteration is stopped and that value is returned.
array1 : 'T array: The first input array.
array2 : 'T array: The second input array.

Returns: int: Returns the first non-zero result from the comparison function. If the first array has a larger element, the return value is always positive. If the second array has a larger element, the return value is always negative. When the elements are equal in the two arrays, 1 is returned if the first array is longer, 0 is returned if they are equal in length, and -1 is returned when the second array is longer.

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [| 1; 10 |]
 let input2 = [| 1; 10 |]

 (input1, input2) ||> Array.compareWith closerToNextDozen

val closerToNextDozen: a: int -> b: int -> int

val a: int

val b: int

val input1: int array

val input2: int array

module Array from Microsoft.FSharp.Collections

val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int

Evaluates to 0

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [| 1; 5 |]
 let input2 = [| 1; 8 |]

 (input1, input2) ||> Array.compareWith closerToNextDozen

val closerToNextDozen: a: int -> b: int -> int

val a: int

val b: int

val input1: int array

val input2: int array

module Array from Microsoft.FSharp.Collections

val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int

Evaluates to -1

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [| 1; 11 |]
 let input2 = [| 1; 13 |]

 (input1, input2) ||> Array.compareWith closerToNextDozen

val closerToNextDozen: a: int -> b: int -> int

val a: int

val b: int

val input1: int array

val input2: int array

module Array from Microsoft.FSharp.Collections

val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int

Evaluates to 1

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [| 1; 2 |]
 let input2 = [| 1 |]

 (input1, input2) ||> Array.compareWith closerToNextDozen

val closerToNextDozen: a: int -> b: int -> int

val a: int

val b: int

val input1: int array

val input2: int array

module Array from Microsoft.FSharp.Collections

val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int

Evaluates to 1

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [| 1 |]
 let input2 = [| 1; 2 |]

 (input1, input2) ||> Array.compareWith closerToNextDozen

val closerToNextDozen: a: int -> b: int -> int

val a: int

val b: int

val input1: int array

val input2: int array

module Array from Microsoft.FSharp.Collections

val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int

Evaluates to -1

Builds a new array that contains the elements of each of the given sequence of arrays.

arrays : 'T array seq: The input sequence of arrays.

Returns: 'T array: The concatenation of the sequence of input arrays.

 let inputs = [ [| 1; 2 |]; [| 3 |]; [| 4; 5 |] ]

 inputs |> Array.concat

val inputs: int array list

module Array from Microsoft.FSharp.Collections

val concat: arrays: 'T array seq -> 'T array

Evaluates to [| 1; 2; 3; 4; 5 |]

Tests if the array contains the specified element.

value : 'T: The value to locate in the input array.
array : 'T array: The input array.

Returns: bool: True if the input array contains the specified element; false otherwise.

 [| 1; 2 |] |> Array.contains 2 // evaluates to true
 [| 1; 2 |] |> Array.contains 5 // evaluates to false

module Array from Microsoft.FSharp.Collections

val contains: value: 'T -> array: 'T array -> bool (requires equality)

Builds a new array that contains the elements of the given array.

array : 'T array: The input array.

Returns: 'T array: A copy of the input array.

 let source = [| 12; 13; 14 |]

 Array.copy source

val source: int array

module Array from Microsoft.FSharp.Collections

val copy: array: 'T array -> 'T array

Evaluates to a new array containing[| 12; 13; 14 |].

Applies a key-generating function to each element of an array and returns an array yielding unique keys and their number of occurrences in the original array.

projection : 'T -> 'Key: A function transforming each item of the input array into a key to be compared against the others.
array : 'T array: The input array.

Returns: ('Key * int) array: The result array.

 type Foo = { Bar: string }

 let inputs = [| {Bar = "a"}; {Bar = "b"}; {Bar = "a"} |]

 inputs |> Array.countBy (fun foo -> foo.Bar)

type Foo = { Bar: string }

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

val inputs: Foo array

module Array from Microsoft.FSharp.Collections

val countBy: projection: ('T -> 'Key) -> array: 'T array -> ('Key * int) array (requires equality)

val foo: Foo

Foo.Bar: string

Evaluates to [| ("a", 2); ("b", 1) |]

Creates an array whose elements are all initially the given value.

count : int: The length of the array to create.
value : 'T: The value for the elements.

Returns: 'T array: The created array.

 Array.create 4 "a"

module Array from Microsoft.FSharp.Collections

val create: count: int -> value: 'T -> 'T array

Evaluates to a new array containing[| "a"; "a"; "a"; "a" |].

 let cell = ref "a"
 let array = Array.create 2 cell
 cell.Value <- "b"

val cell: string ref

Multiple items
val ref: value: 'T -> 'T ref

--------------------
type 'T ref = Ref<'T>

Multiple items
val array: string ref array

--------------------
type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val create: count: int -> value: 'T -> 'T array

property Ref.Value: string with get, set

Before evaluation of the last line, array contains[| { contents = "a"}; { contents = "a"} |]. After evaluation of the last line array contains[| { contents = "b"}; { contents = "b"} |]. Note each entry in the array is the same mutable cell object.

Returns an array that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the array then the later occurrences are discarded.

array : 'T array: The input array.

Returns: 'T array: The result array.

 let input = [| 1; 1; 2; 3 |]

 input |> Array.distinct

val input: int array

module Array from Microsoft.FSharp.Collections

val distinct: array: 'T array -> 'T array (requires equality)

Evaluates to [| 1; 2; 3 |]

Returns an array that contains no duplicate entries according to the generic hash and equality comparisons on the keys returned by the given key-generating function. If an element occurs multiple times in the array then the later occurrences are discarded.

projection : 'T -> 'Key: A function transforming the array items into comparable keys.
array : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| {Bar = 1 };{Bar = 1}; {Bar = 2}; {Bar = 3} |]

 inputs |> Array.distinctBy (fun foo -> foo.Bar)

val inputs: obj array

module Array from Microsoft.FSharp.Collections

val distinctBy: projection: ('T -> 'Key) -> array: 'T array -> 'T array (requires equality)

val foo: obj

Evaluates to [| { Bar = 1 }; { Bar = 2 }; { Bar = 3 } |]

Returns an empty array of the given type.

Returns: 'T array: The empty array.

 Array.empty // Evaluates to [| |]

module Array from Microsoft.FSharp.Collections

val empty<'T> : 'T array

Returns the only element of the array.

array : 'T array: The input array.

Returns: 'T: The only element of the array.

 let inputs = [| "banana" |]

 inputs |> Array.exactlyOne

val inputs: string array

module Array from Microsoft.FSharp.Collections

val exactlyOne: array: 'T array -> 'T

Evaluates to banana

 let inputs = [| "pear"; "banana" |]

 inputs |> Array.exactlyOne

val inputs: string array

module Array from Microsoft.FSharp.Collections

val exactlyOne: array: 'T array -> 'T

Throws ArgumentException

 let inputs: int array = [| |]

 inputs |> Array.exactlyOne

val inputs: int array

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val exactlyOne: array: 'T array -> 'T

Throws ArgumentException

Returns a new list with the distinct elements of the input array which do not appear in the itemsToExclude sequence, using generic hash and equality comparisons to compare values.

itemsToExclude : 'T seq: A sequence whose elements that also occur in the input array will cause those elements to be removed from the result.
array : 'T array: An array whose elements that are not also in itemsToExclude will be returned.

Returns: 'T array: An array that contains the distinct elements of array that do not appear in itemsToExclude.

 let original = [| 1; 2; 3; 4; 5 |]
 let itemsToExclude = [| 1; 3; 5 |]

 original |> Array.except itemsToExclude

val original: int array

val itemsToExclude: int array

module Array from Microsoft.FSharp.Collections

val except: itemsToExclude: 'T seq -> array: 'T array -> 'T array (requires equality)

Evaluates to [| 2; 4 |]

Tests if any element of the array satisfies the given predicate.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: bool: True if any result from predicate is true.

 let input = [| 1; 2; 3; 4; 5 |]

 input |> Array.exists (fun elm -> elm % 4 = 0)

val input: int array

module Array from Microsoft.FSharp.Collections

val exists: predicate: ('T -> bool) -> array: 'T array -> bool

val elm: int

Evaluates to true

 let input = [| 1; 2; 3; 4; 5 |]

 input |> Array.exists (fun elm -> elm % 6 = 0)

val input: int array

module Array from Microsoft.FSharp.Collections

val exists: predicate: ('T -> bool) -> array: 'T array -> bool

val elm: int

Evaluates to false

Tests if any pair of corresponding elements of the arrays satisfies the given predicate.

predicate : 'T1 -> 'T2 -> bool: The function to test the input elements.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: bool: True if any result from predicate is true.

 let inputs1 = [| 1; 2 |]
 let inputs2 = [| 1; 2; 0 |]

 (inputs1, inputs2) ||> Array.exists2 (fun a b -> a > b)

val inputs1: int array

val inputs2: int array

module Array from Microsoft.FSharp.Collections

val exists2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool

val a: int

val b: int

Evaluates to false

 let inputs1 = [| 1; 4 |]
 let inputs2 = [| 1; 3; 5 |]

 (inputs1, inputs2) ||> Array.exists2 (fun a b -> a > b)

val inputs1: int array

val inputs2: int array

module Array from Microsoft.FSharp.Collections

val exists2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool

val a: int

val b: int

Evaluates to true

Fills a range of elements of the array with the given value.

target : 'T array: The target array.
targetIndex : int: The index of the first element to set.
count : int: The number of elements to set.
value : 'T: The value to set.

 let target = [| 0; 1; 2; 3; 4; 5 |]

 Array.fill target 3 2 100

val target: int array

module Array from Microsoft.FSharp.Collections

val fill: target: 'T array -> targetIndex: int -> count: int -> value: 'T -> unit

After evaluation target contains [| 0; 1; 2; 100; 100; 5 |].

Returns a new collection containing only the elements of the collection for which the given predicate returns "true".

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T array: An array containing the elements for which the given predicate returns true.

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.filter (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val filter: predicate: ('T -> bool) -> array: 'T array -> 'T array

val elm: int

Evaluates to [| 2; 4 |]

Returns the first element for which the given function returns 'true'. Raise KeyNotFoundException if no such element exists.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T: The first element for which predicate returns true.

 let inputs = [| 1; 2; 3 |]

 inputs |> Array.find (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val find: predicate: ('T -> bool) -> array: 'T array -> 'T

val elm: int

Evaluates to 2

 let inputs = [| 1; 2; 3 |]

 inputs |> Array.find (fun elm -> elm % 6 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val find: predicate: ('T -> bool) -> array: 'T array -> 'T

val elm: int

Throws KeyNotFoundException

Returns the last element for which the given function returns 'true'. Raise KeyNotFoundException if no such element exists.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T: The last element for which predicate returns true.

 let inputs = [| 2; 3; 4 |]

 inputs |> Array.findBack (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val findBack: predicate: ('T -> bool) -> array: 'T array -> 'T

val elm: int

Evaluates to 4

 let inputs = [| 2; 3; 4 |]

 inputs |> Array.findBack (fun elm -> elm % 6 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val findBack: predicate: ('T -> bool) -> array: 'T array -> 'T

val elm: int

Throws KeyNotFoundException

Returns the index of the first element in the array that satisfies the given predicate. Raise KeyNotFoundException if none of the elements satisfy the predicate.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: int: The index of the first element in the array that satisfies the given predicate.

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.findIndex (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val findIndex: predicate: ('T -> bool) -> array: 'T array -> int

val elm: int

Evaluates to 1

 let inputs = [| 1; 2; 3; 4; 5 |]
 inputs |> Array.findIndex (fun elm -> elm % 6 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val findIndex: predicate: ('T -> bool) -> array: 'T array -> int

val elm: int

Throws KeyNotFoundException

Returns the index of the last element in the array that satisfies the given predicate. Raise KeyNotFoundException if none of the elements satisfy the predicate.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: int: The index of the last element in the array that satisfies the given predicate.

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.findIndex (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val findIndex: predicate: ('T -> bool) -> array: 'T array -> int

val elm: int

Evaluates to 3

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.findIndex (fun elm -> elm % 6 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val findIndex: predicate: ('T -> bool) -> array: 'T array -> int

val elm: int

Throws KeyNotFoundException

Applies a function to each element of the collection, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f (... (f s i0)...) iN

folder : 'State -> 'T -> 'State: The function to update the state given the input elements.
state : 'State: The initial state.
array : 'T array: The input array.

Returns: 'State: The final state.

 type Charge =
     | In of int
     | Out of int

 let inputs = [| In 1; Out 2; In 3 |]

 (0, inputs) ||> Array.fold (fun acc charge ->
     match charge with
     | In i -> acc + i
     | Out o -> acc - o)

type Charge = | In of int | Out of int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val inputs: Charge array

union case Charge.In: int -> Charge

union case Charge.Out: int -> Charge

module Array from Microsoft.FSharp.Collections

val fold<'T,'State> : folder: ('State -> 'T -> 'State) -> state: 'State -> array: 'T array -> 'State

val acc: int

val charge: Charge

val i: int

val o: int

Evaluates to 2

Applies a function to pairs of elements drawn from the two collections, left-to-right, threading an accumulator argument through the computation. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

folder : 'State -> 'T1 -> 'T2 -> 'State: The function to update the state given the input elements.
state : 'State: The initial state.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: 'State: The final state.

 type CoinToss = Head | Tails

 let data1 = [| Tails; Head; Tails |]
 let data2 = [| Tails; Head; Head |]

 (0, data1, data2) |||> Array.fold2 (fun acc a b ->
     match (a, b) with
     | Head, Head -> acc + 1
     | Tails, Tails -> acc + 1
     | _ -> acc - 1)

type CoinToss = | Head | Tails

val data1: CoinToss array

union case CoinToss.Tails: CoinToss

union case CoinToss.Head: CoinToss

val data2: CoinToss array

module Array from Microsoft.FSharp.Collections

val fold2<'T1,'T2,'State> : folder: ('State -> 'T1 -> 'T2 -> 'State) -> state: 'State -> array1: 'T1 array -> array2: 'T2 array -> 'State

val acc: int

val a: CoinToss

val b: CoinToss

Evaluates to 1

Applies a function to each element of the array, starting from the end, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f i0 (...(f iN s))

folder : 'T -> 'State -> 'State: The function to update the state given the input elements.
array : 'T array: The input array.
state : 'State: The initial state.

Returns: 'State: The state object after the folding function is applied to each element of the array.

 type Count =
   { Positive: int
     Negative: int
     Text: string }

 let sequence = [| 1; 0; -1; -2; 3 |]
 let initialState = {Positive = 0; Negative = 0; Text = "" }

 (sequence, initialState) ||> Array.foldBack (fun a acc  ->
     let text = acc.Text + " " + string a
     if a >= 0 then
         { acc with
             Positive = acc.Positive + 1
             Text = text }
     else
         { acc with
             Negative = acc.Negative + 1
             Text = text })

type Count = { Positive: int Negative: int Text: string }

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

val sequence: int array

val initialState: Count

module Array from Microsoft.FSharp.Collections

val foldBack: folder: ('T -> 'State -> 'State) -> array: 'T array -> state: 'State -> 'State

val a: int

val acc: Count

val text: string

Count.Text: string

Count.Positive: int

Count.Negative: int

Evaluates to

 { Positive = 2
   Negative = 3
   Text = " 3 -2 -1 0 1" }

namespace Microsoft.FSharp.Text

Apply a function to pairs of elements drawn from the two collections, right-to-left, threading an accumulator argument through the computation. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

folder : 'T1 -> 'T2 -> 'State -> 'State: The function to update the state given the input elements.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.
state : 'State: The initial state.

Returns: 'State: The final state.

Count the positives, negatives and accumulate some text from back to front:
 type Count =
   { Positive: int
     Negative: int
     Text: string }

 let inputs1 = [| -1; -2; -3 |]
 let inputs2 = [| 3; 2; 1 |]
 let initialState = {Positive = 0; Negative = 0; Text = ""}

 (inputs1, inputs2, initialState) |||> Array.foldBack2 (fun a b acc  ->
     let text = acc.Text + "(" + string a + "," + string b + ") "
     if a + b >= 0 then
         { acc with
             Positive = acc.Positive + 1
             Text = text }
     else
         { acc with
             Negative = acc.Negative + 1
             Text = text }
 )

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

namespace Microsoft.FSharp.Text

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

module Array from Microsoft.FSharp.Collections

val foldBack2: folder: ('T1 -> 'T2 -> 'State -> 'State) -> array1: 'T1 array -> array2: 'T2 array -> state: 'State -> 'State

Evaluates to

 { Positive = 2
   Negative = 1
   Text = "(-3,1) (-2,2) (-1,3) " }

namespace Microsoft.FSharp.Text

Tests if all elements of the array satisfy the given predicate.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: bool: True if all of the array elements satisfy the predicate.

 let isEven a = a % 2 = 0

 [2; 42] |> Array.forall isEven // evaluates to true

 [1; 2] |> Array.forall isEven // evaluates to false

val isEven: a: int -> bool

val a: int

module Array from Microsoft.FSharp.Collections

val forall: predicate: ('T -> bool) -> array: 'T array -> bool

Tests if all corresponding elements of the array satisfy the given predicate pairwise.

predicate : 'T1 -> 'T2 -> bool: The function to test the input elements.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: bool: True if all of the array elements satisfy the predicate.

 let inputs1 = [| 1; 2; 3 |]
 let inputs2 = [| 1; 2; 3 |]

 (inputs1, inputs2) ||> Array.forall2 (=)

val inputs1: int array

val inputs2: int array

module Array from Microsoft.FSharp.Collections

val forall2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool

Evaluates to true.

 let items1 = [| 2017; 1; 1 |]
 let items2 = [| 2019; 19; 8 |]

 (items1, items2) ||> Array.forall2 (=)

val items1: int array

val items2: int array

module Array from Microsoft.FSharp.Collections

val forall2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool

Evaluates to false.

 let items1 = [| 1; 2; 3 |]
 let items2 = [| 1; 2 |]

 (items1, items2) ||> Array.forall2 (=)

val items1: int array

val items2: int array

module Array from Microsoft.FSharp.Collections

val forall2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool

Throws ArgumentException.

Gets an element from an array.

array : 'T array: The input array.
index : int: The input index.

Returns: 'T: The value of the array at the given index.

 let inputs = [| "a"; "b"; "c" |]

 Array.get inputs 1

val inputs: string array

module Array from Microsoft.FSharp.Collections

val get: array: 'T array -> index: int -> 'T

Evaluates to "b"

 let inputs = [| "a"; "b"; "c" |]

 Array.get inputs 4

val inputs: string array

module Array from Microsoft.FSharp.Collections

val get: array: 'T array -> index: int -> 'T

Throws IndexOutOfRangeException

Applies a key-generating function to each element of an array and yields an array of unique keys. Each unique key contains an array of all elements that match to this key.

projection : 'T -> 'Key: A function that transforms an element of the array into a comparable key.
array : 'T array: The input array.

Returns: ('Key * 'T array) array: The result array.

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.groupBy (fun n -> n % 2)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val groupBy: projection: ('T -> 'Key) -> array: 'T array -> ('Key * 'T array) array (requires equality)

val n: int

Evaluates to [| (1, [| 1; 3; 5 |]); (0, [| 2; 4 |]) |]

Returns the first element of the array.

array : 'T array: The input array.

Returns: 'T: The first element of the array.

 let inputs = [| "banana"; "pear" |]

 inputs |> Array.head

val inputs: string array

module Array from Microsoft.FSharp.Collections

val head: array: 'T array -> 'T

Evaluates to banana

 [| |] |> Array.head

module Array from Microsoft.FSharp.Collections

val head: array: 'T array -> 'T

Throws ArgumentException

Builds a new array whose elements are the corresponding elements of the input array paired with the integer index (from 0) of each element.

array : 'T array: The input array.

Returns: (int * 'T) array: The array of indexed elements.

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.indexed

val inputs: string array

module Array from Microsoft.FSharp.Collections

val indexed: array: 'T array -> (int * 'T) array

Evaluates to [| (0, "a"); (1, "b"); (2, "c") |]

Creates an array given the dimension and a generator function to compute the elements.

count : int: The number of elements to initialize.
initializer : int -> 'T: The function to generate the initial values for each index.

Returns: 'T array: The created array.

 Array.init 4 (fun v -> v + 5)

module Array from Microsoft.FSharp.Collections

val init: count: int -> initializer: (int -> 'T) -> 'T array

val v: int

Evaluates to [| 5; 6; 7; 8 |]

 Array.init -5 (fun v -> v + 5)

module Array from Microsoft.FSharp.Collections

val init: count: int -> initializer: (int -> 'T) -> 'T array

val v: int

Throws ArgumentException

Return a new array with a new item inserted before the given index.

index : int: The index where the item should be inserted.
value : 'T: The value to insert.
source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2 |]

 inputs |> Array.insertAt 1 9

val inputs: int array

module Array from Microsoft.FSharp.Collections

val insertAt: index: int -> value: 'T -> source: 'T array -> 'T array

Evaluates to [| 0; 9; 1; 2 |].

Return a new array with new items inserted before the given index.

index : int: The index where the items should be inserted.
values : 'T seq: The values to insert.
source : 'T array: The input array.

Returns: 'T array: A new array (even if values is empty).

 let inputs = [| 0; 1; 2 |]

 inputs |> Array.insertManyAt 1 [8; 9]

val inputs: int array

module Array from Microsoft.FSharp.Collections

val insertManyAt: index: int -> values: 'T seq -> source: 'T array -> 'T array

Evaluates to [| 0; 8; 9; 1; 2 |].

Returns true if the given array is empty, otherwise false.

array : 'T array: The input array.

Returns: bool: True if the array is empty.

 [| |] |> Array.isEmpty

module Array from Microsoft.FSharp.Collections

val isEmpty: array: 'T array -> bool

Evaluates to true

 [| "pear"; "banana" |] |> Array.isEmpty

module Array from Microsoft.FSharp.Collections

val isEmpty: array: 'T array -> bool

Evaluates to false

Gets an element from an array.

index : int: The input index.
array : 'T array: The input array.

Returns: 'T: The value of the array at the given index.

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.item 1

val inputs: string array

module Array from Microsoft.FSharp.Collections

val item: index: int -> array: 'T array -> 'T

Evaluates to "b"

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.item 4

val inputs: string array

module Array from Microsoft.FSharp.Collections

val item: index: int -> array: 'T array -> 'T

Throws ArgumentException

Applies the given function to each element of the array.

action : 'T -> unit: The function to apply.
array : 'T array: The input array.

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.iter (printfn "%s")

val inputs: string array

module Array from Microsoft.FSharp.Collections

val iter: action: ('T -> unit) -> array: 'T array -> unit

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

Evaluates to unit and prints

 a
 b
 c

in the console.

Applies the given function to pair of elements drawn from matching indices in two arrays. The two arrays must have the same lengths, otherwise an ArgumentException is raised.

action : 'T1 -> 'T2 -> unit: The function to apply.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

 let inputs1 = [| "a"; "b"; "c" |]
 let inputs2 = [| 1; 2; 3 |]

 (inputs1, inputs2) ||> Array.iter2 (printfn "%s: %i")

val inputs1: string array

val inputs2: int array

module Array from Microsoft.FSharp.Collections

val iter2: action: ('T1 -> 'T2 -> unit) -> array1: 'T1 array -> array2: 'T2 array -> unit

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

Evaluates to unit and prints

 a: 1
 b: 2
 c: 3

in the console.

Applies the given function to each element of the array. The integer passed to the function indicates the index of element.

action : int -> 'T -> unit: The function to apply to each index and element.
array : 'T array: The input array.

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.iteri (fun i v -> printfn "{i}: {v}")

val inputs: string array

module Array from Microsoft.FSharp.Collections

val iteri: action: (int -> 'T -> unit) -> array: 'T array -> unit

val i: int

val v: string

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

Evaluates to unit and prints

 0: a
 1: b
 2: c

in the console.

Applies the given function to pair of elements drawn from matching indices in two arrays, also passing the index of the elements. The two arrays must have the same lengths, otherwise an ArgumentException is raised.

action : int -> 'T1 -> 'T2 -> unit: The function to apply to each index and pair of elements.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

 let inputs1 = [| "a"; "b"; "c" |]
 let inputs2 = [| "banana"; "pear"; "apple" |]

 (inputs1, inputs2) ||> Array.iteri2 (fun i s1 s2 -> printfn "Index {i}: {s1} - {s2}")

val inputs1: string array

val inputs2: string array

module Array from Microsoft.FSharp.Collections

val iteri2: action: (int -> 'T1 -> 'T2 -> unit) -> array1: 'T1 array -> array2: 'T2 array -> unit

val i: int

val s1: string

val s2: string

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

Evaluates to unit and prints

 Index 0: a - banana
 Index 1: b - pear
 Index 2: c - apple

in the console.

Returns the last element of the array.

array : 'T array: The input array.

Returns: 'T: The last element of the array.

 [| "pear"; "banana" |] |> Array.last

module Array from Microsoft.FSharp.Collections

val last: array: 'T array -> 'T

Evaluates to banana

 [| |] |> Array.last

module Array from Microsoft.FSharp.Collections

val last: array: 'T array -> 'T

Throws ArgumentException

Returns the length of an array. You can also use property arr.Length.

array : 'T array: The input array.

Returns: int: The length of the array.

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.length

val inputs: string array

module Array from Microsoft.FSharp.Collections

val length: array: 'T array -> int

Evaluates to 3

Builds a new array whose elements are the results of applying the given function to each of the elements of the array.

mapping : 'T -> 'U: The function to transform elements of the array.
array : 'T array: The input array.

Returns: 'U array: The array of transformed elements.

 let inputs = [| "a"; "bbb"; "cc" |]

 inputs |> Array.map (fun x -> x.Length)

val inputs: string array

module Array from Microsoft.FSharp.Collections

val map: mapping: ('T -> 'U) -> array: 'T array -> 'U array

val x: string

property System.String.Length: int with get

Evaluates to [| 1; 3; 2 |]

Builds a new collection whose elements are the results of applying the given function to the corresponding elements of the two collections pairwise. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

mapping : 'T1 -> 'T2 -> 'U: The function to transform the pairs of the input elements.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: 'U array: The array of transformed elements.

 let inputs1 = [| "a"; "bad"; "good" |]
 let inputs2 = [| 0; 2; 1 |]

 (inputs1, inputs2) ||> Array.map2 (fun x y -> x[y])

val inputs1: string array

val inputs2: int array

module Array from Microsoft.FSharp.Collections

val map2: mapping: ('T1 -> 'T2 -> 'U) -> array1: 'T1 array -> array2: 'T2 array -> 'U array

val x: string

val y: int

Evaluates to [| 'a'; 'd'; 'o' |]

Builds a new collection whose elements are the results of applying the given function to the corresponding triples from the three collections. The three input arrays must have the same length, otherwise an ArgumentException is raised.

mapping : 'T1 -> 'T2 -> 'T3 -> 'U: The function to transform the pairs of the input elements.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.
array3 : 'T3 array: The third input array.

Returns: 'U array: The array of transformed elements.

 let inputs1 = [| "a"; "t"; "ti" |]
 let inputs2 = [| "l"; "h"; "m" |]
 let inputs3 = [| "l"; "e"; "e" |]

 (inputs1, inputs2, inputs3) |||> Array.map3 (fun x y z -> x + y + z)

val inputs1: string array

val inputs2: string array

val inputs3: string array

module Array from Microsoft.FSharp.Collections

val map3: mapping: ('T1 -> 'T2 -> 'T3 -> 'U) -> array1: 'T1 array -> array2: 'T2 array -> array3: 'T3 array -> 'U array

val x: string

val y: string

val z: string

Evaluates to [| "all"; "the"; "time" |]

Combines map and fold. Builds a new array whose elements are the results of applying the given function to each of the elements of the input array. The function is also used to accumulate a final value.

mapping : 'State -> 'T -> 'Result * 'State: The function to transform elements from the input array and accumulate the final value.
state : 'State: The initial state.
array : 'T array: The input array.

Returns: 'Result array * 'State: The array of transformed elements, and the final accumulated value.

Accumulate the charges, and double them as well
 type Charge =
     | In of int
     | Out of int

 let inputs = [| In 1; Out 2; In 3 |]

 let newCharges, balance =
     (0, inputs) ||> Array.mapFold (fun acc charge ->
         match charge with
         | In i -> In (i*2), acc + i
         | Out o -> Out (o*2), acc - o)

Multiple items
val double: value: 'T -> double (requires member op_Explicit)

--------------------
type double = System.Double

--------------------
type double<'Measure> = float<'Measure>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

module Array from Microsoft.FSharp.Collections

val mapFold<'T,'State,'Result> : mapping: ('State -> 'T -> 'Result * 'State) -> state: 'State -> array: 'T array -> 'Result array * 'State

Evaluates newCharges to [|In 2; Out 4; In 6|] and balance to 2.

Combines map and foldBack. Builds a new array whose elements are the results of applying the given function to each of the elements of the input array. The function is also used to accumulate a final value.

mapping : 'T -> 'State -> 'Result * 'State: The function to transform elements from the input array and accumulate the final value.
array : 'T array: The input array.
state : 'State: The initial state.

Returns: 'Result array * 'State: The array of transformed elements, and the final accumulated value.

Accumulate the charges from back to front, and double them as well

 type Charge =
     | In of int
     | Out of int

 let inputs = [| In 1; Out 2; In 3 |]

 let newCharges, balance =
     (inputs, 0) ||> Array.mapFoldBack (fun charge acc ->
         match charge with
         | In i -> In (i*2), acc + i
         | Out o -> Out (o*2), acc - o)

type Charge = | In of int | Out of int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val inputs: Charge array

union case Charge.In: int -> Charge

union case Charge.Out: int -> Charge

val newCharges: Charge array

val balance: int

module Array from Microsoft.FSharp.Collections

val mapFoldBack: mapping: ('T -> 'State -> 'Result * 'State) -> array: 'T array -> state: 'State -> 'Result array * 'State

val charge: Charge

val acc: int

val i: int

val o: int

Evaluates newCharges to [|In 2; Out 4; In 6|] and balance to 2.

Builds a new array whose elements are the results of applying the given function to each of the elements of the array. The integer index passed to the function indicates the index of element being transformed, starting at zero.

mapping : int -> 'T -> 'U: The function to transform elements and their indices.
array : 'T array: The input array.

Returns: 'U array: The array of transformed elements.

 let inputs = [| 10; 10; 10 |]

 inputs |> Array.mapi (fun i x -> i + x)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val mapi: mapping: (int -> 'T -> 'U) -> array: 'T array -> 'U array

val i: int

val x: int

Evaluates to [| 10; 11; 12 |]

Builds a new collection whose elements are the results of applying the given function to the corresponding elements of the two collections pairwise, also passing the index of the elements. The two input arrays must have the same lengths, otherwise an ArgumentException is raised.

mapping : int -> 'T1 -> 'T2 -> 'U: The function to transform pairs of input elements and their indices.
array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: 'U array: The array of transformed elements.

 let inputs1 = [| "a"; "bad"; "good" |]
 let inputs2 = [| 0; 2; 1 |]

 (inputs1, inputs2) ||> Array.mapi2 (fun i x y -> i, x[y])

val inputs1: string array

val inputs2: int array

module Array from Microsoft.FSharp.Collections

val mapi2: mapping: (int -> 'T1 -> 'T2 -> 'U) -> array1: 'T1 array -> array2: 'T2 array -> 'U array

val i: int

val x: string

val y: int

Evaluates to [|(0, 'a'); (1, 'd'); (2, 'o')|]

Returns the greatest of all elements of the array, compared via Operators.max on the function result.

array : 'T array: The input array.

Returns: 'T: The maximum element.

 let inputs = [| 10; 12; 11 |]

 inputs |> Array.max

val inputs: int array

module Array from Microsoft.FSharp.Collections

val max: array: 'T array -> 'T (requires comparison)

Evaluates to 12

 let inputs: int array= [| |]

 inputs |> Array.max

val inputs: int array

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val max: array: 'T array -> 'T (requires comparison)

Throws System.ArgumentException.

Returns the greatest of all elements of the array, compared via Operators.max on the function result.

projection : 'T -> 'U: The function to transform the elements into a type supporting comparison.
array : 'T array: The input array.

Returns: 'T: The maximum element.

 let inputs = [| "aaa"; "b"; "cccc" |]

 inputs |> Array.maxBy (fun s -> s.Length)

val inputs: string array

module Array from Microsoft.FSharp.Collections

val maxBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)

val s: string

property System.String.Length: int with get

Evaluates to "cccc"

 let inputs: string array= [| |]

 inputs |> Array.maxBy (fun s -> s.Length)

val inputs: string array

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val maxBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)

val s: string

property System.String.Length: int with get

Throws System.ArgumentException.

Returns the lowest of all elements of the array, compared via Operators.min.

array : 'T array: The input array.

Returns: 'T: The minimum element.

 let inputs = [| 10; 12; 11 |]

 inputs |> Array.min

val inputs: int array

module Array from Microsoft.FSharp.Collections

val min: array: 'T array -> 'T (requires comparison)

Evaluates to 10

 let inputs: int array= [| |]

 inputs |> Array.min

val inputs: int array

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val min: array: 'T array -> 'T (requires comparison)

Throws System.ArgumentException.

Returns the lowest of all elements of the array, compared via Operators.min on the function result.

projection : 'T -> 'U: The function to transform the elements into a type supporting comparison.
array : 'T array: The input array.

Returns: 'T: The minimum element.

 let inputs = [| "aaa"; "b"; "cccc" |]

 inputs |> Array.minBy (fun s -> s.Length)

val inputs: string array

module Array from Microsoft.FSharp.Collections

val minBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)

val s: string

property System.String.Length: int with get

Evaluates to "b"

 let inputs: string array= [| |]

 inputs |> Array.minBy (fun s -> s.Length)

val inputs: string array

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val minBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)

val s: string

property System.String.Length: int with get

Throws System.ArgumentException.

Builds an array from the given list.

list : 'T list: The input list.

Returns: 'T array: The array of elements from the list.

 let inputs = [ 1; 2; 5 ]

 inputs |> Array.ofList

val inputs: int list

module Array from Microsoft.FSharp.Collections

val ofList: list: 'T list -> 'T array

Evaluates to [| 1; 2; 5 |].

Builds a new array from the given enumerable object.

source : 'T seq: The input sequence.

Returns: 'T array: The array of elements from the sequence.

 let inputs = seq { 1; 2; 5 }

 inputs |> Array.ofSeq

val inputs: int seq

Multiple items
val seq: sequence: 'T seq -> 'T seq

--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>

module Array from Microsoft.FSharp.Collections

val ofSeq: source: 'T seq -> 'T array

Evaluates to [| 1; 2; 5 |].

Returns an array of each element in the input array paired with its predecessor, with the exception of the first element which is only returned as the predecessor of the second element. The predecessor comes first in the returned pairs.

array : 'T array: The input array.

Returns: ('T * 'T) array: The result array.

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.pairwise

val inputs: int array

module Array from Microsoft.FSharp.Collections

val pairwise: array: 'T array -> ('T * 'T) array

Evaluates to [|(1, 2); (2, 3); (3, 4)|].

Splits the collection into two collections, containing the elements for which the given predicate returns "true" and "false" respectively.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T array * 'T array: A pair of arrays. The first containing the elements the predicate evaluated to true, and the second containing those evaluated to false.

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.partition (fun x -> x % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val partition: predicate: ('T -> bool) -> array: 'T array -> 'T array * 'T array

val x: int

Evaluates to ([|2; 4|], [|1; 3|]).

Splits the collection into two arrays, by applying the given partitioning function to each element. Returns Choice1Of2 elements in the first array and Choice2Of2 elements in the second array. Element order is preserved in both of the created arrays.

partitioner : 'T -> Choice<'T1, 'T2>: The function to transform and classify each input element into one of two output types.
array : 'T array: The input array.

Returns: 'T1 array * 'T2 array: A tuple of two arrays. The first containing values from Choice1Of2 results and the second containing values from Choice2Of2 results.

 let inputs = [| 1; 2; 3; 4; 5 |]

 let evens, odds =
     inputs |> Array.partitionWith (fun x ->
         if x % 2 = 0 then Choice1Of2 (x * 10)
         else Choice2Of2 (string x))

val inputs: int array

val evens: obj

val odds: obj

module Array from Microsoft.FSharp.Collections

union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>

union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

Evaluates evens to [|20; 40|] and odds to [|"1"; "3"; "5"|].

Returns an array with all elements permuted according to the specified permutation.

indexMap : int -> int: The function that maps input indices to output indices.
array : 'T array: The input array.

Returns: 'T array: The output array.

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.permute (fun x -> (x + 1) % 4)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val permute: indexMap: (int -> int) -> array: 'T array -> 'T array

val x: int

Evaluates to [|4; 1; 2; 3|].

Applies the given function to successive elements, returning the first result where the function returns Some(x) for some x. If the function never returns Some(x) then KeyNotFoundException is raised.

chooser : 'T -> 'U option: The function to generate options from the elements.
array : 'T array: The input array.

Returns: 'U: The first result.

 let input = [| 1; 2; 3 |]

 input |> Array.pick (fun n -> if n % 2 = 0 then Some (string n) else None)

val input: int array

module Array from Microsoft.FSharp.Collections

val pick: chooser: ('T -> 'U option) -> array: 'T array -> 'U

val n: int

union case Option.Some: Value: 'T -> Option<'T>

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

union case Option.None: Option<'T>

Evaluates to "2".

 let input = [| 1; 2; 3 |]

 input |> Array.pick (fun n -> if n > 3 = 0 then Some (string n) else None)

val input: int array

module Array from Microsoft.FSharp.Collections

val pick: chooser: ('T -> 'U option) -> array: 'T array -> 'U

val n: int

union case Option.Some: Value: 'T -> Option<'T>

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

union case Option.None: Option<'T>

Throws KeyNotFoundException.

Returns a random element from the given array.

source : 'T array: The input array.

Returns: 'T: A randomly selected element from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomChoice

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to 3.

Returns a random element from the given array using the specified randomizer function.

randomizer : unit -> float: The randomizer function, must return a float number from [0.0..1.0) range.
source : 'T array: The input array.

Returns: 'T: A randomly selected element from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomChoiceBy Random.Shared.NextDouble

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to 3.

Returns a random element from the given array with the specified Random instance.

random : Random: The Random instance.
source : 'T array: The input array.

Returns: 'T: A randomly selected element from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomChoiceWith Random.Shared

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to 3.

Returns an array of random elements from the given array, each element can be selected multiple times.

count : int: The number of elements to return.
source : 'T array: The input array.

Returns: 'T array: An array of randomly selected elements from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomChoices 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 3; 1; 3 |].

Returns an array of random elements from the given array using the specified randomizer function, each element can be selected multiple times.

randomizer : unit -> float: The randomizer function, must return a float number from [0.0..1.0) range.
count : int: The number of elements to return.
source : 'T array: The input array.

Returns: 'T array: An array of randomly selected elements from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomChoicesBy Random.Shared.NextDouble 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 3; 1; 3 |].

Returns an array of random elements from the given array with the specified Random instance, each element can be selected multiple times.

random : Random: The Random instance.
count : int: The number of elements to return.
source : 'T array: The input array.

Returns: 'T array: An array of randomly selected elements from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomChoicesWith Random.Shared 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 3; 1; 3 |].

Returns a random sample of elements from the given array, each element can be selected only once.

count : int: The number of elements to return.
source : 'T array: The input array.

Returns: 'T array: An array of randomly selected elements from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomSample 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 3; 1; 2 |].

Returns a random sample of elements from the given array using the specified randomizer function, each element can be selected only once.

randomizer : unit -> float: The randomizer function, must return a float number from [0.0..1.0) range.
count : int: The number of elements to return.
source : 'T array: The input array.

Returns: 'T array: An array of randomly selected elements from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomSampleBy Random.Shared.NextDouble 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 3; 1; 2 |].

Returns a random sample of elements from the given array with the specified Random instance, each element can be selected only once.

random : Random: The Random instance.
count : int: The number of elements to return.
source : 'T array: The input array.

Returns: 'T array: An array of randomly selected elements from the input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomSampleWith Random.Shared 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 3; 1; 2 |].

Return a new array shuffled in a random order.

source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomShuffle

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 0; 2; 4; 3; 1 |].

Return a new array shuffled in a random order using the specified randomizer function.

randomizer : unit -> float: The randomizer function, must return a float number from [0.0..1.0) range.
source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomShuffleBy Random.Shared.NextDouble

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 0; 2; 4; 3; 1 |].

Sorts input array in a random order by mutating the array in-place.

source : 'T array: The input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomShuffleInPlace

val inputs: int array

module Array from Microsoft.FSharp.Collections

After evaluation array can contain [| 0; 2; 4; 3; 1 |].

Sorts input array in a random order using the specified randomizer function by mutating the array in-place.

randomizer : unit -> float: The randomizer function, must return a float number from [0.0..1.0) range.
source : 'T array: The input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomShuffleInPlaceBy Random.Shared.NextDouble

val inputs: int array

module Array from Microsoft.FSharp.Collections

After evaluation array can contain [| 0; 2; 4; 3; 1 |].

Sorts input array in a random order with the specified Random instance by mutating the array in-place.

random : Random: The Random instance.
source : 'T array: The input array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomShuffleInPlaceWith Random.Shared

val inputs: int array

module Array from Microsoft.FSharp.Collections

After evaluation array can contain [| 0; 2; 4; 3; 1 |].

Return a new array shuffled in a random order with the specified Random instance.

random : Random: The Random instance.
source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2; 3; 4 |]

 inputs |> Array.randomShuffleWith Random.Shared

val inputs: int array

module Array from Microsoft.FSharp.Collections

Can evaluate to [| 0; 2; 4; 3; 1 |].

Applies a function to each element of the array, threading an accumulator argument through the computation. If the input function is f and the elements are i0...iN then computes f (... (f i0 i1)...) iN. Raises ArgumentException if the array has size zero.

reduction : 'T -> 'T -> 'T: The function to reduce a pair of elements to a single element.
array : 'T array: The input array.

Returns: 'T: The final result of the reductions.

 let inputs = [| 1; 3; 4; 2 |]

 inputs |> Array.reduce (fun a b -> a * 10 + b)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val reduce: reduction: ('T -> 'T -> 'T) -> array: 'T array -> 'T

val a: int

val b: int

Evaluates to 1342, by computing ((1 * 10 + 3) * 10 + 4) * 10 + 2

reduction : 'T -> 'T -> 'T: A function that takes in the next-to-last element of the list and the current accumulated result to produce the next accumulated result.
array : 'T array: The input array.

Returns: 'T: The final result of the reductions.

 let inputs = [| 1; 3; 4; 2 |]

 inputs |> Array.reduceBack (fun a b -> a + b * 10)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val reduceBack: reduction: ('T -> 'T -> 'T) -> array: 'T array -> 'T

val a: int

val b: int

Evaluates to 2431, by computing 1 + (3 + (4 + 2 * 10) * 10) * 10

Return a new array with the item at a given index removed.

index : int: The index of the item to be removed.
source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2 |]

 inputs |> Array.removeAt 1

val inputs: int array

module Array from Microsoft.FSharp.Collections

val removeAt: index: int -> source: 'T array -> 'T array

Evaluates to [| 0; 2 |].

Return a new array with the number of items starting at a given index removed.

index : int: The index of the item to be removed.
count : int: The number of items to remove.
source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2; 3 |]

 inputs |> Array.removeManyAt 1 2

val inputs: int array

module Array from Microsoft.FSharp.Collections

val removeManyAt: index: int -> count: int -> source: 'T array -> 'T array

Evaluates to [| 0; 3 |].

Creates an array by replicating the given initial value.

count : int: The number of elements to replicate.
initial : 'T: The value to replicate

Returns: 'T array: The generated array.

 Array.replicate 3 "a"

module Array from Microsoft.FSharp.Collections

val replicate: count: int -> initial: 'T -> 'T array

Evaluates to [| "a"; "a"; "a" |].

Returns a new array with the elements in reverse order.

array : 'T array: The input array.

Returns: 'T array: The reversed array.

 Array.rev [| 0; 1; 2 |]

module Array from Microsoft.FSharp.Collections

val rev: array: 'T array -> 'T array

Evaluates to [| 2; 1; 0 |].

Like fold, but return the intermediary and final results.

folder : 'State -> 'T -> 'State: The function to update the state given the input elements.
state : 'State: The initial state.
array : 'T array: The input array.

Returns: 'State array: The array of state values.

Apply a list charges and collect the running balances as each is applied:

 type Charge =
     | In of int
     | Out of int

 let inputs = [| In 1; Out 2; In 3 |]

 (0, inputs) ||> Array.scan (fun acc charge ->
     match charge with
     | In i -> acc + i
     | Out o -> acc - o)

type Charge = | In of int | Out of int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val inputs: Charge array

union case Charge.In: int -> Charge

union case Charge.Out: int -> Charge

module Array from Microsoft.FSharp.Collections

val scan<'T,'State> : folder: ('State -> 'T -> 'State) -> state: 'State -> array: 'T array -> 'State array

val acc: int

val charge: Charge

val i: int

val o: int

Evaluates to [|0; 1; -1; 2|]. Note 0 is the initial state, 1 the next state, -1 the next state, and 2 the final state.

Like foldBack, but return both the intermediary and final results.

folder : 'T -> 'State -> 'State: The function to update the state given the input elements.
array : 'T array: The input array.
state : 'State: The initial state.

Returns: 'State array: The array of state values.

Apply a list charges from back to front, and collect the running balances as each is applied:

 type Charge =
     | In of int
     | Out of int

 let inputs = [| In 1; Out 2; In 3 |]

 (inputs, 0) ||> Array.scanBack (fun charge acc ->
     match charge with
     | In i -> acc + i
     | Out o -> acc - o)

type Charge = | In of int | Out of int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val inputs: Charge array

union case Charge.In: int -> Charge

union case Charge.Out: int -> Charge

module Array from Microsoft.FSharp.Collections

val scanBack: folder: ('T -> 'State -> 'State) -> array: 'T array -> state: 'State -> 'State array

val charge: Charge

val acc: int

val i: int

val o: int

Evaluates to [|2; 1; 3; 0|] by processing each input from back to front. Note 0 is the initial state, 3 the next state, 1 the next state, and 2 the final state.

Sets an element of an array.

array : 'T array: The input array.
index : int: The input index.
value : 'T: The input value.

 let inputs = [| "a"; "b"; "c" |]

 Array.set inputs 1 "B"

val inputs: string array

module Array from Microsoft.FSharp.Collections

val set: array: 'T array -> index: int -> value: 'T -> unit

After evaluation inputs contains [| "a"; "B"; "c" |]

 let inputs = [| "a"; "b"; "c" |]

 Array.set inputs 4 "d"

val inputs: string array

module Array from Microsoft.FSharp.Collections

val set: array: 'T array -> index: int -> value: 'T -> unit

Throws IndexOutOfRangeException

Returns an array that contains one item only.

value : 'T: The input item.

Returns: 'T array: The result array of one item.

 Array.singleton 7

module Array from Microsoft.FSharp.Collections

val singleton: value: 'T -> 'T array

Evaluates to [| 7 |].

Builds a new array that contains the elements of the given array, excluding the first N elements.

count : int: The number of elements to skip. If negative the full array will be returned as a copy.
array : 'T array: The input array.

Returns: 'T array: A copy of the input array, after removing the first N elements.

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.skip 2

val inputs: string array

module Array from Microsoft.FSharp.Collections

val skip: count: int -> array: 'T array -> 'T array

Evaluates to [| "c"; "d" |]

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.skip 5

val inputs: string array

module Array from Microsoft.FSharp.Collections

val skip: count: int -> array: 'T array -> 'T array

Throws ArgumentException.

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.skip -1

val inputs: string array

module Array from Microsoft.FSharp.Collections

val skip: count: int -> array: 'T array -> 'T array

Evaluates to [| "a"; "b"; "c"; "d" |].

Bypasses elements in an array while the given predicate returns True, and then returns the remaining elements in a new array.

predicate : 'T -> bool: A function that evaluates an element of the array to a boolean value.
array : 'T array: The input array.

Returns: 'T array: The created sub array.

 let inputs = [| "a"; "bbb"; "cc"; "d" |]

 inputs |> Array.skipWhile (fun x -> x.Length < 3)

val inputs: string array

module Array from Microsoft.FSharp.Collections

val skipWhile: predicate: ('T -> bool) -> array: 'T array -> 'T array

val x: string

property System.String.Length: int with get

Evaluates to [|"bbb"; "cc"; "d"|]

Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare.

array : 'T array: The input array.

Returns: 'T array: The sorted array.

 let input = [| 8; 4; 3; 1; 6; 1 |]

 Array.sort input

val input: int array

module Array from Microsoft.FSharp.Collections

val sort: array: 'T array -> 'T array (requires comparison)

Evaluates to [| 1; 1; 3; 4; 6; 8 |].

Sorts the elements of an array, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.

projection : 'T -> 'Key: The function to transform array elements into the type that is compared.
array : 'T array: The input array.

Returns: 'T array: The sorted array.

 let input = [| "a"; "bbb"; "cccc"; "dd" |]

 input |> Array.sortBy (fun s -> s.Length)

val input: string array

module Array from Microsoft.FSharp.Collections

val sortBy: projection: ('T -> 'Key) -> array: 'T array -> 'T array (requires comparison)

val s: string

property System.String.Length: int with get

Evaluates to [|"a"; "dd"; "bbb"; "cccc"|].

Sorts the elements of an array, in descending order, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.

projection : 'T -> 'Key: The function to transform array elements into the type that is compared.
array : 'T array: The input array.

Returns: 'T array: The sorted array.

 let input = [| "a"; "bbb"; "cccc"; "dd" |]

 input |> Array.sortByDescending (fun s -> s.Length)

val input: string array

module Array from Microsoft.FSharp.Collections

val sortByDescending: projection: ('T -> 'Key) -> array: 'T array -> 'T array (requires comparison)

val s: string

property System.String.Length: int with get

Evaluates to [|"cccc"; "bbb"; "dd"; "a"|].

Sorts the elements of an array, in descending order, returning a new array. Elements are compared using Operators.compare.

array : 'T array: The input array.

Returns: 'T array: The sorted array.

 let input = [| 8; 4; 3; 1; 6; 1 |]

 input |> Array.sortDescending

val input: int array

module Array from Microsoft.FSharp.Collections

val sortDescending: array: 'T array -> 'T array (requires comparison)

Evaluates to [| 8; 6; 4; 3; 1; 1 |].

Sorts the elements of an array by mutating the array in-place, using the given comparison function. Elements are compared using Operators.compare.

array : 'T array: The input array.

 let array = [| 8; 4; 3; 1; 6; 1 |]

 Array.sortInPlace array

Multiple items
val array: int array

--------------------
type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val sortInPlace: array: 'T array -> unit (requires comparison)

After evaluation array contains [| 1; 1; 3; 4; 6; 8 |].

Sorts the elements of an array by mutating the array in-place, using the given projection for the keys. Elements are compared using Operators.compare.

projection : 'T -> 'Key: The function to transform array elements into the type that is compared.
array : 'T array: The input array.

 let array = [| "a"; "bbb"; "cccc"; "dd" |]

 array |> Array.sortInPlaceBy (fun s -> s.Length)

Multiple items
val array: string array

--------------------
type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val sortInPlaceBy: projection: ('T -> 'Key) -> array: 'T array -> unit (requires comparison)

val s: string

property System.String.Length: int with get

After evaluation array contains [|"a"; "dd"; "bbb"; "cccc"|].

Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order.

comparer : 'T -> 'T -> int: The function to compare pairs of array elements.
array : 'T array: The input array.

The following sorts entries using a comparison function that compares string lengths then index numbers:

 let compareEntries (n1: int, s1: string) (n2: int, s2: string) =
     let c = compare s1.Length s2.Length
     if c <> 0 then c else
     compare n1 n2

 let array = [| (0,"aa"); (1,"bbb"); (2,"cc"); (3,"dd") |]

 array |> Array.sortInPlaceWith compareEntries

val compareEntries: n1: int * s1: string -> n2: int * s2: string -> int

val n1: int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val s1: string

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

val n2: int

val s2: string

val c: int

val compare: e1: 'T -> e2: 'T -> int (requires comparison)

property System.String.Length: int with get

Multiple items
val array: (int * string) array

--------------------
type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val sortInPlaceWith: comparer: ('T -> 'T -> int) -> array: 'T array -> unit

After evaluation array contains [|(0, "aa"); (2, "cc"); (3, "dd"); (1, "bbb")|].

Sorts the elements of an array, using the given comparison function as the order, returning a new array.

comparer : 'T -> 'T -> int: The function to compare pairs of array elements.
array : 'T array: The input array.

Returns: 'T array: The sorted array.

Sort an array of pairs using a comparison function that compares string lengths then index numbers:

 let compareEntries (n1: int, s1: string) (n2: int, s2: string) =
     let c = compare s1.Length s2.Length
     if c <> 0 then c else
     compare n1 n2

 let input = [| (0,"aa"); (1,"bbb"); (2,"cc"); (3,"dd") |]

 input |> Array.sortWith compareEntries

val compareEntries: n1: int * s1: string -> n2: int * s2: string -> int

val n1: int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val s1: string

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

val n2: int

val s2: string

val c: int

val compare: e1: 'T -> e2: 'T -> int (requires comparison)

property System.String.Length: int with get

val input: (int * string) array

module Array from Microsoft.FSharp.Collections

val sortWith: comparer: ('T -> 'T -> int) -> array: 'T array -> 'T array

Evaluates to [|(0, "aa"); (2, "cc"); (3, "dd"); (1, "bbb")|].

Splits an array into two arrays, at the given index.

index : int: The index at which the array is split.
array : 'T array: The input array.

Returns: 'T array * 'T array: The two split arrays.

 let input = [| 8; 4; 3; 1; 6; 1 |]

 let front, back = input |> Array.splitAt 3

val input: int array

val front: int array

val back: int array

module Array from Microsoft.FSharp.Collections

val splitAt: index: int -> array: 'T array -> 'T array * 'T array

Evaluates front to [|8; 4; 3|] and back to [|1; 6; 1|].

Splits the input array into at most count chunks.

count : int: The maximum number of chunks.
array : 'T array: The input array.

Returns: 'T array array: The array split into chunks.

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.splitInto 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

val splitInto: count: int -> array: 'T array -> 'T array array

Evaluates to seq [| [|1; 2|]; [|3; 4|]; [|5|] |]

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.splitInto -1

val inputs: int array

module Array from Microsoft.FSharp.Collections

val splitInto: count: int -> array: 'T array -> 'T array array

Throws ArgumentException

Builds a new array that contains the given subrange specified by starting index and length.

 let input = [| 0; 1; 2; 3; 4; 5 |]

 input.[2..4]

val input: int array

This is an O(count) operation.

array : 'T array: The input array.
startIndex : int: The index of the first element of the sub array.
count : int: The length of the sub array.

Returns: 'T array: The created sub array.

 let input = [| 0; 1; 2; 3; 4; 5 |]

 Array.sub input 2 3

val input: int array

module Array from Microsoft.FSharp.Collections

val sub: array: 'T array -> startIndex: int -> count: int -> 'T array

Evaluates to [| 2; 3; 4 |].

Returns the sum of the elements in the array.

array : ^T array: The input array.

Returns: ^T: The resulting sum.

 let input = [| 1; 5; 3; 2 |]

 input |> Array.sum

val input: int array

module Array from Microsoft.FSharp.Collections

val sum: array: 'T array -> 'T (requires member (+) and member Zero)

Evaluates to 11.

Returns the sum of the results generated by applying the function to each element of the array.

projection : 'T -> ^U: The function to transform the array elements into the type to be summed.
array : 'T array: The input array.

Returns: ^U: The resulting sum.

 let input = [| "aa"; "bbb"; "cc" |]

 input |> Array.sumBy (fun s -> s.Length)

val input: string array

module Array from Microsoft.FSharp.Collections

val sumBy: projection: ('T -> 'U) -> array: 'T array -> 'U (requires member (+) and member Zero)

val s: string

property System.String.Length: int with get

Evaluates to 7.

Returns a new array containing the elements of the original except the first element.

array : 'T array: The input array.

Returns: 'T array: A new array containing the elements of the original except the first element.

 let inputs = [| "a"; "bb"; "ccc" |]

 inputs |> Array.tail

val inputs: string array

module Array from Microsoft.FSharp.Collections

val tail: array: 'T array -> 'T array

Evaluates to [| "bb"; "ccc" |]

Returns the first N elements of the array.

count : int: The number of items to take.
array : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.take 2

val inputs: string array

module Array from Microsoft.FSharp.Collections

val take: count: int -> array: 'T array -> 'T array

Evaluates to [| "a"; "b" |]

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.take 6

val inputs: string array

module Array from Microsoft.FSharp.Collections

val take: count: int -> array: 'T array -> 'T array

Throws InvalidOperationException.

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.take 0

val inputs: string array

module Array from Microsoft.FSharp.Collections

val take: count: int -> array: 'T array -> 'T array

Evaluates to [| |].

Returns an array that contains all elements of the original array while the given predicate returns True, and then returns no further elements.

predicate : 'T -> bool: A function that evaluates to false when no more items should be returned.
array : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| "a"; "bb"; "ccc"; "d" |]

 inputs |> Array.takeWhile (fun x -> x.Length < 3)

val inputs: string array

module Array from Microsoft.FSharp.Collections

val takeWhile: predicate: ('T -> bool) -> array: 'T array -> 'T array

val x: string

property System.String.Length: int with get

Evaluates to [| "a"; "bb" |]

Builds a list from the given array.

array : 'T array: The input array.

Returns: 'T list: The list of array elements.

 let inputs = [| 1; 2; 5 |]

 inputs |> Array.toList

val inputs: int array

module Array from Microsoft.FSharp.Collections

val toList: array: 'T array -> 'T list

Evaluates to [ 1; 2; 5 ].

Views the given array as a sequence.

array : 'T array: The input array.

Returns: 'T seq: The sequence of array elements.

 let inputs = [| 1; 2; 5 |]

 inputs |> Array.toSeq

val inputs: int array

module Array from Microsoft.FSharp.Collections

val toSeq: array: 'T array -> 'T seq

Evaluates to seq { 1; 2; 5 }.

Returns the transpose of the given sequence of arrays.

arrays : 'T array seq: The input sequence of arrays.

Returns: 'T array array: The transposed array.

 let inputs =
     [| [| 10; 20; 30 |]
        [| 11; 21; 31 |] |]

 inputs |> Array.transpose

val inputs: int array array

module Array from Microsoft.FSharp.Collections

val transpose: arrays: 'T array seq -> 'T array array

Evaluates to [|[|10; 11|]; [|20; 21|]; [|30; 31|]|].

Returns at most N elements in a new array.

count : int: The maximum number of items to return.
array : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.truncate 2

val inputs: string array

module Array from Microsoft.FSharp.Collections

val truncate: count: int -> array: 'T array -> 'T array

Evaluates to [| "a"; "b" |]

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.truncate 6

val inputs: string array

module Array from Microsoft.FSharp.Collections

val truncate: count: int -> array: 'T array -> 'T array

Evaluates to [| "a"; "b"; "c"; "d" |]

 let inputs = [| "a"; "b"; "c"; "d" |]

 inputs |> Array.truncate 0

val inputs: string array

module Array from Microsoft.FSharp.Collections

val truncate: count: int -> array: 'T array -> 'T array

Evaluates to [| |].

Returns the only element of the array or None if array is empty or contains more than one element.

array : 'T array: The input array.

Returns: 'T option: The only element of the array or None.

 let inputs = [| "banana" |]

 inputs |> Array.tryExactlyOne

val inputs: string array

module Array from Microsoft.FSharp.Collections

val tryExactlyOne: array: 'T array -> 'T option

Evaluates to Some banana

 let inputs = [| "pear"; "banana" |]

 inputs |> Array.tryExactlyOne

val inputs: string array

module Array from Microsoft.FSharp.Collections

val tryExactlyOne: array: 'T array -> 'T option

Evaluates to None

 let inputs: int array = [| |]

 inputs |> Array.tryExactlyOne

val inputs: int array

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val tryExactlyOne: array: 'T array -> 'T option

Evaluates to None

Returns the first element for which the given function returns True. Return None if no such element exists.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T option: The first element that satisfies the predicate, or None.

Try to find the first even number:

 let inputs = [| 1; 2; 3 |]

 inputs |> Array.tryFind (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFind: predicate: ('T -> bool) -> array: 'T array -> 'T option

val elm: int

Evaluates to Some 2

Try to find the first even number:

 let inputs = [| 1; 5; 3 |]

 inputs |> Array.tryFind (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFind: predicate: ('T -> bool) -> array: 'T array -> 'T option

val elm: int

Evaluates to None

Returns the last element for which the given function returns True. Return None if no such element exists.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T option: The last element that satisfies the predicate, or None.

Try to find the first even number from the back:

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.tryFindBack (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFindBack: predicate: ('T -> bool) -> array: 'T array -> 'T option

val elm: int

Evaluates to Some 4

Try to find the first even number from the back:

 let inputs = [| 1; 5; 3 |]

 inputs |> Array.tryFindBack (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFindBack: predicate: ('T -> bool) -> array: 'T array -> 'T option

val elm: int

Evaluates to None

Returns the index of the first element in the array that satisfies the given predicate.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: int option: The index of the first element that satisfies the predicate, or None.

Try to find the index of the first even number:

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.tryFindIndex (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFindIndex: predicate: ('T -> bool) -> array: 'T array -> int option

val elm: int

Evaluates to Some 1

Try to find the index of the first even number:

 let inputs = [| 1; 3; 5; 7 |]

 inputs |> Array.tryFindIndex (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFindIndex: predicate: ('T -> bool) -> array: 'T array -> int option

val elm: int

Evaluates to None

Returns the index of the last element in the array that satisfies the given predicate.

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: int option: The index of the last element that satisfies the predicate, or None.

Try to find the index of the first even number from the back:

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.tryFindIndexBack (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFindIndexBack: predicate: ('T -> bool) -> array: 'T array -> int option

val elm: int

Evaluates to Some 3

Try to find the index of the first even number from the back:

 let inputs = [| 1; 3; 5; 7 |]

 inputs |> Array.tryFindIndexBack (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val tryFindIndexBack: predicate: ('T -> bool) -> array: 'T array -> int option

val elm: int

Evaluates to None

Returns the first element of the array, or None if the array is empty.

array : 'T array: The input array.

Returns: 'T option: The first element of the array or None.

 let inputs = [| "banana"; "pear" |]

 inputs |> Array.tryHead

val inputs: string array

module Array from Microsoft.FSharp.Collections

val tryHead: array: 'T array -> 'T option

Evaluates to Some "banana"

 let inputs : int array = [| |]

 inputs |> Array.tryHead

val inputs: int array

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val tryHead: array: 'T array -> 'T option

Evaluates to None

Tries to find the nth element in the array. Returns None if index is negative or the input array does not contain enough elements.

index : int: The index of element to retrieve.
array : 'T array: The input array.

Returns: 'T option: The nth element of the array or None.

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.tryItem 1

val inputs: string array

module Array from Microsoft.FSharp.Collections

val tryItem: index: int -> array: 'T array -> 'T option

Evaluates to Some "b".

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.tryItem 4

val inputs: string array

module Array from Microsoft.FSharp.Collections

val tryItem: index: int -> array: 'T array -> 'T option

Evaluates to None.

Returns the last element of the array. Return None if no such element exists.

array : 'T array: The input array.

Returns: 'T option: The last element of the array or None.

 [| "pear"; "banana" |] |> Array.tryLast

module Array from Microsoft.FSharp.Collections

val tryLast: array: 'T array -> 'T option

Evaluates to Some "banana"

 [| |] |> Array.tryLast

module Array from Microsoft.FSharp.Collections

val tryLast: array: 'T array -> 'T option

Evaluates to None

Applies the given function to successive elements, returning the first result where the function returns Some(x) for some x. If the function never returns Some(x) then None is returned.

chooser : 'T -> 'U option: The function to transform the array elements into options.
array : 'T array: The input array.

Returns: 'U option: The first transformed element that is Some(x).

 let input = [| 1; 2; 3 |]

 input |> Array.tryPick (fun n -> if n % 2 = 0 then Some (string n) else None)

val input: int array

module Array from Microsoft.FSharp.Collections

val tryPick: chooser: ('T -> 'U option) -> array: 'T array -> 'U option

val n: int

union case Option.Some: Value: 'T -> Option<'T>

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

union case Option.None: Option<'T>

Evaluates to Some "2".

 let input = [| 1; 2; 3 |]

 input |> Array.tryPick (fun n -> if n > 3 = 0 then Some (string n) else None)

val input: int array

module Array from Microsoft.FSharp.Collections

val tryPick: chooser: ('T -> 'U option) -> array: 'T array -> 'U option

val n: int

union case Option.Some: Value: 'T -> Option<'T>

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

union case Option.None: Option<'T>

Evaluates to None.

Returns an array that contains the elements generated by the given computation. The generator is repeatedly called to build the list until it returns `None`. The given initial state argument is passed to the element generator.

generator : 'State -> ('T * 'State) option: A function that takes in the current state and returns an option tuple of the next element of the array and the next state value.
state : 'State: The initial state value.

Returns: 'T array: The result array.

 1 |> Array.unfold (fun state -> if state > 100 then None else Some (state, state * 2))

module Array from Microsoft.FSharp.Collections

val unfold<'T,'State> : generator: ('State -> ('T * 'State) option) -> state: 'State -> 'T array

val state: int

union case Option.None: Option<'T>

union case Option.Some: Value: 'T -> Option<'T>

Evaluates to [| 1; 2; 4; 8; 16; 32; 64 |]

Splits an array of pairs into two arrays.

array : ('T1 * 'T2) array: The input array.

Returns: 'T1 array * 'T2 array: The two arrays.

 let inputs = [| (1, "one"); (2, "two") |]

 let numbers, names = inputs |> Array.unzip

val inputs: (int * string) array

val numbers: int array

val names: string array

module Array from Microsoft.FSharp.Collections

val unzip: array: ('T1 * 'T2) array -> 'T1 array * 'T2 array

Evaluates numbers to [|1; 2|] and names to [|"one"; "two"|].

Splits an array of triples into three arrays.

array : ('T1 * 'T2 * 'T3) array: The input array.

Returns: 'T1 array * 'T2 array * 'T3 array: The tuple of three arrays.

 let inputs = [| (1, "one", "I"); (2, "two", "II") |]

 let numbers, names, roman = inputs |> Array.unzip3

val inputs: (int * string * string) array

val numbers: int array

val names: string array

val roman: string array

module Array from Microsoft.FSharp.Collections

val unzip3: array: ('T1 * 'T2 * 'T3) array -> 'T1 array * 'T2 array * 'T3 array

Evaluates numbers to [|1; 2|], names to [|"one"; "two"|] and roman to [|"I"; "II"|].

Return a new array with the item at a given index set to the new value.

index : int: The index of the item to be replaced.
value : 'T: The new value.
source : 'T array: The input array.

Returns: 'T array: The result array.

 let inputs = [| 0; 1; 2 |]

 inputs |> Array.updateAt 1 9

val inputs: int array

module Array from Microsoft.FSharp.Collections

val updateAt: index: int -> value: 'T -> source: 'T array -> 'T array

Evaluates to [| 0; 9; 2 |].

Returns a new array containing only the elements of the array for which the given predicate returns "true".

predicate : 'T -> bool: The function to test the input elements.
array : 'T array: The input array.

Returns: 'T array: An array containing the elements for which the given predicate returns true.

Select only the even numbers:

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.where (fun elm -> elm % 2 = 0)

val inputs: int array

module Array from Microsoft.FSharp.Collections

val where: predicate: ('T -> bool) -> array: 'T array -> 'T array

val elm: int

Evaluates to [| 2; 4 |]

Returns an array of sliding windows containing elements drawn from the input array. Each window is returned as a fresh array.

windowSize : int: The number of elements in each window.
array : 'T array: The input array.

Returns: 'T array array: The result array.

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.windowed 3

val inputs: int array

module Array from Microsoft.FSharp.Collections

val windowed: windowSize: int -> array: 'T array -> 'T array array

Evaluates to [|[|1; 2; 3|]; [|2; 3; 4|]; [|3; 4; 5|]|]

Creates an array where the entries are initially the default value Unchecked.defaultof<'T>.

count : int: The length of the array to create.

Returns: 'T array: The created array.

 let arr : int array = Array.zeroCreate 4

val arr: int array

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

type 'T array = 'T array

module Array from Microsoft.FSharp.Collections

val zeroCreate: count: int -> 'T array

Evaluates to [| 0; 0; 0; 0 |]

Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is raised.

array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.

Returns: ('T1 * 'T2) array: The array of tupled elements.

 let numbers = [|1; 2|]
 let names = [|"one"; "two"|]

 Array.zip numbers names

val numbers: int array

val names: string array

module Array from Microsoft.FSharp.Collections

val zip: array1: 'T1 array -> array2: 'T2 array -> ('T1 * 'T2) array

Evaluates to [| (1, "one"); (2, "two") |].

Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is raised.

array1 : 'T1 array: The first input array.
array2 : 'T2 array: The second input array.
array3 : 'T3 array: The third input array.

Returns: ('T1 * 'T2 * 'T3) array: The array of tupled elements.

 let numbers = [| 1; 2 |]
 let names = [| "one"; "two" |]
 let roman = [| "I"; "II" |]

 Array.zip3 numbers names roman

val numbers: int array

val names: string array

val roman: string array

module Array from Microsoft.FSharp.Collections

val zip3: array1: 'T1 array -> array2: 'T2 array -> array3: 'T3 array -> ('T1 * 'T2 * 'T3) array

Evaluates to [|(1, "one", "I"); (2, "two", "II")|].