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

array1 : 'T1[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: ('T1 * 'T2)[]

The resulting array of pairs.

Example

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

 [| (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[]

The first input array.

array2 : 'T[]

The second input array.

Returns: 'T[]

The resulting array.

Example

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

Returns the average of the elements in the array.

array : ^T[]

The input array.

Returns: ^T

The average of the elements in the array.

Example

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

Example

 [| |] |> Array.average

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[]

The input array.

Returns: ^U

The computed average.

Example

 type Foo = { Bar: float }

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

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

Example

 type Foo = { Bar: float }

 let input : Foo[] = [| |]

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

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

Slicing syntax is generally preferred, e.g.

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

source : 'T[]

The source array.

sourceIndex : int

The starting index of the source array.

target : 'T[]

The target array.

targetIndex : int

The starting index of the target array.

count : int

The number of elements to copy.

Example

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

 Array.blit source 1 target 3 2

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[]

The input array.

Returns: 'U[]

The array of results.

Example

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

 input |> Array.choose id

Example

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

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

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

chunkSize : int

The maximum size of each chunk.

array : 'T[]

The input array.

Returns: 'T[][]

The array divided into chunks.

Example

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

 input |> Array.chunkBySize 2

Example

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

 input |> Array.chunkBySize -2

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

mapping : 'T -> 'U[]

The function to create sub-arrays from the input array elements.

array : 'T[]

The input array.

Returns: 'U[]

The concatenation of the sub-arrays.

Example

 type Foo = { Bar: int[] }

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

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

Example

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

 input |> Array.collect id

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[]

The first input array.

array2 : 'T[]

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.

Example

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

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

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

Example

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

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

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

Example

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

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

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

Example

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

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

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

Example

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

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

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

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

arrays : seq<'T[]>

The input sequence of arrays.

Returns: 'T[]

The concatenation of the sequence of input arrays.

Example

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

 inputs |> Array.concat

Tests if the array contains the specified element.

value : 'T

The value to locate in the input array.

array : 'T[]

The input array.

Returns: bool

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

Example

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

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

array : 'T[]

The input array.

Returns: 'T[]

A copy of the input array.

Example

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

 Array.copy source

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[]

The input array.

Returns: ('Key * int)[]

The result array.

Example

 type Foo = { Bar: string }

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

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

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[]

The created array.

Example

 Array.create 4 "a"

Example

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

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[]

The input array.

Returns: 'T[]

The result array.

Example

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

 input |> Array.distinct

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[]

The input array.

Returns: 'T[]

The result array.

Example

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

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

Returns an empty array of the given type.

Returns: 'T[]

The empty array.

Example

 Array.empty // Evaluates to [| |]

Returns the only element of the array.

array : 'T[]

The input array.

Returns: 'T

The only element of the array.

Example

 let inputs = [| "banana" |]

 inputs |> Array.exactlyOne

Example

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

 inputs |> Array.exactlyOne

Example

 let inputs: int[] = [| |]

 inputs |> Array.exactlyOne

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 : seq<'T>

A sequence whose elements that also occur in the input array will cause those elements to be removed from the result.

array : 'T[]

An array whose elements that are not also in itemsToExclude will be returned.

Returns: 'T[]

An array that contains the distinct elements of array that do not appear in itemsToExclude.

Example

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

 original |> Array.except itemsToExclude

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

The predicate is applied to the elements of the input array. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: bool

True if any result from predicate is true.

Example

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

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

Example

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

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

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

The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns true then the overall result is true and no further elements are tested. Otherwise, if one collections is longer than the other then the ArgumentException exception is raised. Otherwise, false is returned.

predicate : 'T1 -> 'T2 -> bool

The function to test the input elements.

array1 : 'T1[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: bool

True if any result from predicate is true.

Example

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

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

Example

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

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

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

target : 'T[]

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.

Example

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

 Array.fill target 3 2 100

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[]

The input array.

Returns: 'T[]

An array containing the elements for which the given predicate returns true.

Example

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

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

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[]

The input array.

Returns: 'T

The first element for which predicate returns true.

Example

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

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

Example

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

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

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[]

The input array.

Returns: 'T

The last element for which predicate returns true.

Example

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

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

Example

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

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

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[]

The input array.

Returns: int

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

Example

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

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

Example

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

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[]

The input array.

Returns: int

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

Example

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

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

Example

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

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

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[]

The input array.

Returns: 'State

The final state.

Example

 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)

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[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: 'State

The final state.

Example

 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)

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[]

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.

Example

 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 })

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

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[]

The first input array.

array2 : 'T2[]

The second input array.

state : 'State

The initial state.

Returns: 'State

The final state.

Example

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 }
 )

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

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

The predicate is applied to the elements of the input collection. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: bool

True if all of the array elements satisfy the predicate.

Example

 let isEven a = a % 2 = 0

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

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

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

The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns false then the overall result is false and no further elements are tested. Otherwise, if one collection is longer than the other then the ArgumentException exception is raised. Otherwise, true is returned.

predicate : 'T1 -> 'T2 -> bool

The function to test the input elements.

array1 : 'T1[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: bool

True if all of the array elements satisfy the predicate.

Example

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

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

Example

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

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

Example

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

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

Gets an element from an array.

Normally the syntax array[index] is preferred.

array : 'T[]

The input array.

index : int

The input index.

Returns: 'T

The value of the array at the given index.

Example

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

 Array.get inputs 1

Example

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

 Array.get inputs 4

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[]

The input array.

Returns: ('Key * 'T[])[]

The result array.

Example

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

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

Returns the first element of the array.

array : 'T[]

The input array.

Returns: 'T

The first element of the array.

Example

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

 inputs |> Array.head

Example

 [| |] |> Array.head

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[]

The input array.

Returns: (int * 'T)[]

The array of indexed elements.

Example

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

 inputs |> Array.indexed

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[]

The created array.

Example

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

Example

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

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[]

The input array.

Returns: 'T[]

The result array.

Example

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

 inputs |> Array.insertAt 1 9

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

index : int

The index where the items should be inserted.

values : seq<'T>

The values to insert.

source : 'T[]

The input array.

Returns: 'T[]

The result array.

Example

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

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

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

array : 'T[]

The input array.

Returns: bool

True if the array is empty.

Example

 [| |] |> Array.isEmpty

Example

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

Gets an element from an array.

Normally the syntax array[index] is preferred.

index : int

The input index.

array : 'T[]

The input array.

Returns: 'T

The value of the array at the given index.

Example

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

 inputs |> Array.item 1

Example

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

 inputs |> Array.item 4

Applies the given function to each element of the array.

action : 'T -> unit

The function to apply.

array : 'T[]

The input array.

Example

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

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

 a
 b
 c

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[]

The first input array.

array2 : 'T2[]

The second input array.

Example

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

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

 a: 1
 b: 2
 c: 3

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[]

The input array.

Example

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

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

 0: a
 1: b
 2: c

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[]

The first input array.

array2 : 'T2[]

The second input array.

Example

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

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

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

Returns the last element of the array.

array : 'T[]

The input array.

Returns: 'T

The last element of the array.

Example

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

Example

 [| |] |> Array.last

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

The notation array.Length is preferred.

array : 'T[]

The input array.

Returns: int

The length of the array.

Example

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

 inputs |> Array.length

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[]

The input array.

Returns: 'U[]

The array of transformed elements.

Example

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

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

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[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: 'U[]

The array of transformed elements.

Example

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

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

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[]

The first input array.

array2 : 'T2[]

The second input array.

array3 : 'T3[]

The third input array.

Returns: 'U[]

The array of transformed elements.

Example

 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)

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[]

The input array.

Returns: 'Result[] * 'State

The array of transformed elements, and the final accumulated value.

Example

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)

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[]

The input array.

state : 'State

The initial state.

Returns: 'Result[] * 'State

The array of transformed elements, and the final accumulated value.

Example

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)

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[]

The input array.

Returns: 'U[]

The array of transformed elements.

Example

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

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

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[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: 'U[]

The array of transformed elements.

Example

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

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

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

Throws ArgumentException for empty arrays.

array : 'T[]

The input array.

Returns: 'T

The maximum element.

Example

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

 inputs |> Array.max

Example

 let inputs: int[]= [| |]

 inputs |> Array.max

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

Throws ArgumentException for empty arrays.

projection : 'T -> 'U

The function to transform the elements into a type supporting comparison.

array : 'T[]

The input array.

Returns: 'T

The maximum element.

Example

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

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

Example

 let inputs: string[]= [| |]

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

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

Throws ArgumentException for empty arrays

array : 'T[]

The input array.

Returns: 'T

The minimum element.

Example

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

 inputs |> Array.min

Example

 let inputs: int[]= [| |]

 inputs |> Array.min

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

Throws ArgumentException for empty arrays.

projection : 'T -> 'U

The function to transform the elements into a type supporting comparison.

array : 'T[]

The input array.

Returns: 'T

The minimum element.

Example

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

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

Example

 let inputs: string[]= [| |]

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

Builds an array from the given list.

list : 'T list

The input list.

Returns: 'T[]

The array of elements from the list.

Example

 let inputs = [ 1; 2; 5 ]

 inputs |> Array.ofList

Builds a new array from the given enumerable object.

source : seq<'T>

The input sequence.

Returns: 'T[]

The array of elements from the sequence.

Example

 let inputs = seq { 1; 2; 5 }

 inputs |> Array.ofSeq

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

array : 'T[]

The input array.

Returns: ('T * 'T)[]

The result array.

Example

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

 inputs |> Array.pairwise

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[]

The input array.

Returns: 'T[] * 'T[]

A pair of arrays. The first containing the elements the predicate evaluated to true, and the second containing those evaluated to false.

Example

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

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

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[]

The input array.

Returns: 'T[]

The output array.

Example

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

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

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[]

The input array.

Returns: 'U

The first result.

Example

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

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

Example

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

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

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[]

The input array.

Returns: 'T

The final result of the reductions.

Example

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

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

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-1 iN)).

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[]

The input array.

Returns: 'T

The final result of the reductions.

Example

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

 inputs |> Array.reduceBack (fun a b -> a + b * 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[]

The input array.

Returns: 'T[]

The result array.

Example

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

 inputs |> Array.removeAt 1

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[]

The input array.

Returns: 'T[]

The result array.

Example

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

 inputs |> Array.removeManyAt 1 2

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[]

The generated array.

Example

 Array.replicate 3 "a"

Returns a new array with the elements in reverse order.

array : 'T[]

The input array.

Returns: 'T[]

The reversed array.

Example

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

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[]

The input array.

Returns: 'State[]

The array of state values.

Example

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)

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[]

The input array.

state : 'State

The initial state.

Returns: 'State[]

The array of state values.

Example

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)

Sets an element of an array.

array : 'T[]

The input array.

index : int

The input index.

value : 'T

The input value.

Example

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

 Array.set inputs 1 "B"

Example

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

 Array.set inputs 4 "d"

Returns an array that contains one item only.

value : 'T

The input item.

Returns: 'T[]

The result array of one item.

Example

 Array.singleton 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[]

The input array.

Returns: 'T[]

A copy of the input array, after removing the first N elements.

Example

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

 inputs |> Array.skip 2

Example

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

 inputs |> Array.skip 5

Example

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

 inputs |> Array.skip -1

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[]

The input array.

Returns: 'T[]

The created sub array.

Example

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

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

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

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

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

 Array.sort input

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

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

projection : 'T -> 'Key

The function to transform array elements into the type that is compared.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

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

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

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.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

projection : 'T -> 'Key

The function to transform array elements into the type that is compared.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

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

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

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

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

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

 input |> Array.sortDescending

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[]

The input array.

Example

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

 Array.sortInPlace array

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.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

projection : 'T -> 'Key

The function to transform array elements into the type that is compared.

array : 'T[]

The input array.

Example

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

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

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[]

The input array.

Example

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

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

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

comparer : 'T -> 'T -> int

The function to compare pairs of array elements.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

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

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

index : int

The index at which the array is split.

array : 'T[]

The input array.

Returns: 'T[] * 'T[]

The two split arrays.

Example

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

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

Splits the input array into at most count chunks.

count : int

The maximum number of chunks.

array : 'T[]

The input array.

Returns: 'T[][]

The array split into chunks.

Example

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

 inputs |> Array.splitInto 3

Example

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

 inputs |> Array.splitInto -1

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

Slicing syntax is generally preferred, e.g.

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

 input.[2..4]

array : 'T[]

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[]

The created sub array.

Example

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

 Array.sub input 2 3

Returns the sum of the elements in the array.

array : ^T[]

The input array.

Returns: ^T

The resulting sum.

Example

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

 input |> Array.sum

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[]

The input array.

Returns: ^U

The resulting sum.

Example

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

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

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

array : 'T[]

The input array.

Returns: 'T[]

A new array containing the elements of the original except the first element.

Example

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

 inputs |> Array.tail

Returns the first N elements of the array.

Throws InvalidOperationException if the count exceeds the number of elements in the array. Array.truncate returns as many items as the array contains instead of throwing an exception.

count : int

The number of items to take.

array : 'T[]

The input array.

Returns: 'T[]

The result array.

Example

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

 inputs |> Array.take 2

Example

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

 inputs |> Array.take 6

Example

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

 inputs |> Array.take 0

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[]

The input array.

Returns: 'T[]

The result array.

Example

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

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

Builds a list from the given array.

array : 'T[]

The input array.

Returns: 'T list

The list of array elements.

Example

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

 inputs |> Array.toList

Views the given array as a sequence.

array : 'T[]

The input array.

Returns: seq<'T>

The sequence of array elements.

Example

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

 inputs |> Array.toSeq

Returns the transpose of the given sequence of arrays.

arrays : seq<'T[]>

The input sequence of arrays.

Returns: 'T[][]

The transposed array.

Example

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

 inputs |> Array.transpose

Returns at most N elements in a new array.

count : int

The maximum number of items to return.

array : 'T[]

The input array.

Returns: 'T[]

The result array.

Example

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

 inputs |> Array.truncate 2

Example

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

 inputs |> Array.truncate 6

Example