Returns a new array that contains all pairings of elements from the first and second arrays.
'T1 array
The first input array.
'T2 array
The second input array.
('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.
'T array
The first input array.
'T array
The second input array.
'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.
^T array
The input array.
^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 to3.0
[| |] |> Array.average
module Array from Microsoft.FSharp.Collections
val average: array: 'T array -> 'T (requires member (+) and member DivideByInt and member Zero)
ThrowsArgumentException
Returns the average of the elements generated by applying the function to each element of the array.
'T -> ^U
The function to transform the array elements before averaging.
'T array
The input array.
^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 to3.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
ThrowsArgumentException
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
'T array
The source array.
int
The starting index of the source array.
'T array
The target array.
int
The starting index of the target array.
int
The number of elements to copy.
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 evaluationtarget 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)
'T -> 'U option
The function to generate options from the elements.
'T array
The input array.
'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.
int
The maximum size of each chunk.
'T array
The input array.
'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
ThrowsArgumentException
For each element of the array, applies the given function. Concatenates all the results and return the combined array.
'T -> 'U array
The function to create sub-arrays from the input array elements.
'T array
The input array.
'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.
'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.
'T array
The first input array.
'T array
The second input array.
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 to0
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 to1
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 to1
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.
'T array seq
The input sequence of arrays.
'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.
'T
The value to locate in the input array.
'T array
The input array.
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.
'T array
The input array.
'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.
'T -> 'Key
A function transforming each item of the input array into a key to be compared against the others.
'T array
The input array.
('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.
int
The length of the array to create.
'T
The value for the elements.
'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.
'T array
The input array.
'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.
'T -> 'Key
A function transforming the array items into comparable keys.
'T array
The input array.
'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.
'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.
'T array
The input array.
'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 tobanana
let inputs = [| "pear"; "banana" |]
inputs |> Array.exactlyOne
val inputs: string array
module Array from Microsoft.FSharp.Collections
val exactlyOne: array: 'T array -> 'T
ThrowsArgumentException
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
ThrowsArgumentException
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.
'T seq
A sequence whose elements that also occur in the input array will cause those elements to be removed from the result.
'T array
An array whose elements that are not also in itemsToExclude will be returned.
'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.
'T -> bool
The function to test the input elements.
'T array
The input array.
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 totrue
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 tofalse
Tests if any pair of corresponding elements of the arrays satisfies the given predicate.
'T1 -> 'T2 -> bool
The function to test the input elements.
'T1 array
The first input array.
'T2 array
The second input array.
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 tofalse
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 totrue
Fills a range of elements of the array with the given value.
'T array
The target array.
int
The index of the first element to set.
int
The number of elements to set.
'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 evaluationtarget 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".
'T -> bool
The function to test the input elements.
'T array
The input array.
'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.
'T -> bool
The function to test the input elements.
'T array
The input array.
'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 to2
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
ThrowsKeyNotFoundException
Returns the last element for which the given function returns 'true'. Raise KeyNotFoundException if no such element exists.
'T -> bool
The function to test the input elements.
'T array
The input array.
'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 to4
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
ThrowsKeyNotFoundException
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.
'T -> bool
The function to test the input elements.
'T array
The input array.
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 to1
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
ThrowsKeyNotFoundException
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.
'T -> bool
The function to test the input elements.
'T array
The input array.
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 to3
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
ThrowsKeyNotFoundException
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
'State -> 'T -> 'State
The function to update the state given the input elements.
'State
The initial state.
'T array
The input array.
'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 to2
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.
'State -> 'T1 -> 'T2 -> 'State
The function to update the state given the input elements.
'State
The initial state.
'T1 array
The first input array.
'T2 array
The second input array.
'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 to1
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))
'T -> 'State -> 'State
The function to update the state given the input elements.
'T array
The input array.
'State
The initial state.
'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.
'T1 -> 'T2 -> 'State -> 'State
The function to update the state given the input elements.
'T1 array
The first input array.
'T2 array
The second input array.
'State
The initial state.
'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.
'T -> bool
The function to test the input elements.
'T array
The input array.
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.
'T1 -> 'T2 -> bool
The function to test the input elements.
'T1 array
The first input array.
'T2 array
The second input array.
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 totrue.
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 tofalse.
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
ThrowsArgumentException.
Gets an element from an array.
'T array
The input array.
int
The input index.
'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
ThrowsIndexOutOfRangeException
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.
'T -> 'Key
A function that transforms an element of the array into a comparable key.
'T array
The input array.
('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.
'T array
The input array.
'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 tobanana
[| |] |> Array.head
module Array from Microsoft.FSharp.Collections
val head: array: 'T array -> 'T
ThrowsArgumentException
Builds a new array whose elements are the corresponding elements of the input array paired with the integer index (from 0) of each element.
'T array
The input array.
(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.
int
The number of elements to initialize.
int -> 'T
The function to generate the initial values for each index.
'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
ThrowsArgumentException
Return a new array with a new item inserted before the given index.
int
The index where the item should be inserted.
'T
The value to insert.
'T array
The input array.
'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.
int
The index where the items should be inserted.
'T seq
The values to insert.
'T array
The input array.
'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.
'T array
The input array.
bool
True if the array is empty.
[| |] |> Array.isEmpty
module Array from Microsoft.FSharp.Collections
val isEmpty: array: 'T array -> bool
Evaluates totrue
[| "pear"; "banana" |] |> Array.isEmpty
module Array from Microsoft.FSharp.Collections
val isEmpty: array: 'T array -> bool
Evaluates tofalse
Gets an element from an array.
int
The input index.
'T array
The input array.
'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
ThrowsArgumentException
Applies the given function to each element of the array.
'T -> unit
The function to apply.
'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 tounit and prints
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.
'T1 -> 'T2 -> unit
The function to apply.
'T1 array
The first input array.
'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 tounit and prints
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.
int -> 'T -> unit
The function to apply to each index and element.
'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 tounit and prints
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.
int -> 'T1 -> 'T2 -> unit
The function to apply to each index and pair of elements.
'T1 array
The first input array.
'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 tounit and prints
Index 0: a - banana
Index 1: b - pear
Index 2: c - apple
Returns the last element of the array.
'T array
The input array.
'T
The last element of the array.
[| "pear"; "banana" |] |> Array.last
module Array from Microsoft.FSharp.Collections
val last: array: 'T array -> 'T
Evaluates tobanana
[| |] |> Array.last
module Array from Microsoft.FSharp.Collections
val last: array: 'T array -> 'T
ThrowsArgumentException
Returns the length of an array. You can also use property arr.Length.
'T array
The input array.
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 to3
Builds a new array whose elements are the results of applying the given function to each of the elements of the array.
'T -> 'U
The function to transform elements of the array.
'T array
The input array.
'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.
'T1 -> 'T2 -> 'U
The function to transform the pairs of the input elements.
'T1 array
The first input array.
'T2 array
The second input array.
'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.
'T1 -> 'T2 -> 'T3 -> 'U
The function to transform the pairs of the input elements.
'T1 array
The first input array.
'T2 array
The second input array.
'T3 array
The third input array.
'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.
'State -> 'T -> 'Result * 'State
The function to transform elements from the input array and accumulate the final value.
'State
The initial state.
'T array
The input array.
'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
EvaluatesnewCharges 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.
'T -> 'State -> 'Result * 'State
The function to transform elements from the input array and accumulate the final value.
'T array
The input array.
'State
The initial state.
'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
EvaluatesnewCharges 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.
int -> 'T -> 'U
The function to transform elements and their indices.
'T array
The input array.
'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.
int -> 'T1 -> 'T2 -> 'U
The function to transform pairs of input elements and their indices.
'T1 array
The first input array.
'T2 array
The second input array.
'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.
'T array
The input array.
'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 to12
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)
ThrowsSystem.ArgumentException.
Returns the greatest of all elements of the array, compared via Operators.max on the function result.
'T -> 'U
The function to transform the elements into a type supporting comparison.
'T array
The input array.
'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
ThrowsSystem.ArgumentException.
Returns the lowest of all elements of the array, compared via Operators.min.
'T array
The input array.
'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 to10
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)
ThrowsSystem.ArgumentException.
Returns the lowest of all elements of the array, compared via Operators.min on the function result.
'T -> 'U
The function to transform the elements into a type supporting comparison.
'T array
The input array.
'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
ThrowsSystem.ArgumentException.
Builds an array from the given list.
'T list
The input list.
'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.
'T seq
The input sequence.
'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.
'T array
The input array.
('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.
'T -> bool
The function to test the input elements.
'T array
The input array.
'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|]).
Returns an array with all elements permuted according to the specified permutation.
int -> int
The function that maps input indices to output indices.
'T array
The input array.
'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.
'T -> 'U option
The function to generate options from the elements.
'T array
The input array.
'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>
ThrowsKeyNotFoundException.
Returns a random element from the given array.
'T array
The input array.
'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 to3.
Returns a random element from the given array using the specified randomizer function.
unit -> float
The randomizer function, must return a float number from [0.0..1.0) range.
'T array
The input array.
'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 to3.
Returns a random element from the given array with the specified Random instance.
Random
The Random instance.
'T array
The input array.
'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 to3.
Returns an array of random elements from the given array, each element can be selected multiple times.
int
The number of elements to return.
'T array
The input array.
'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.
unit -> float
The randomizer function, must return a float number from [0.0..1.0) range.
int
The number of elements to return.
'T array
The input array.
'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
The Random instance.
int
The number of elements to return.
'T array
The input array.
'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.
int
The number of elements to return.
'T array
The input array.
'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.
unit -> float
The randomizer function, must return a float number from [0.0..1.0) range.
int
The number of elements to return.
'T array
The input array.
'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
The Random instance.
int
The number of elements to return.
'T array
The input array.
'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.
'T array
The input array.
'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.
unit -> float
The randomizer function, must return a float number from [0.0..1.0) range.
'T array
The input array.
'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.
'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 evaluationarray 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.
unit -> float
The randomizer function, must return a float number from [0.0..1.0) range.
'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 evaluationarray 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
The Random instance.
'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 evaluationarray can contain [| 0; 2; 4; 3; 1 |].
Return a new array shuffled in a random order with the specified Random instance.
Random
The Random instance.
'T array
The input array.
'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.
'T -> 'T -> 'T
The function to reduce a pair of elements to a single element.
'T array
The input array.
'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 to1342, by computing ((1 * 10 + 3) * 10 + 4) * 10 + 2
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)).
'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.
'T array
The input array.
'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 to2431, by computing 1 + (3 + (4 + 2 * 10) * 10) * 10
Return a new array with the item at a given index removed.
int
The index of the item to be removed.
'T array
The input array.
'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.
int
The index of the item to be removed.
int
The number of items to remove.
'T array
The input array.
'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.
int
The number of elements to replicate.
'T
The value to replicate
'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.
'T array
The input array.
'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.
'State -> 'T -> 'State
The function to update the state given the input elements.
'State
The initial state.
'T array
The input array.
'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.
'T -> 'State -> 'State
The function to update the state given the input elements.
'T array
The input array.
'State
The initial state.
'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.
'T array
The input array.
int
The input index.
'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 evaluationinputs 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
ThrowsIndexOutOfRangeException
Returns an array that contains one item only.
'T
The input item.
'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.
int
The number of elements to skip. If negative the full array will be returned as a copy.
'T array
The input array.
'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
ThrowsArgumentException.
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.
'T -> bool
A function that evaluates an element of the array to a boolean value.
'T array
The input array.
'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.
'T array
The input array.
'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.
'T -> 'Key
The function to transform array elements into the type that is compared.
'T array
The input array.
'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.
'T -> 'Key
The function to transform array elements into the type that is compared.
'T array
The input array.
'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.
'T array
The input array.
'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.
'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 evaluationarray 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.
'T -> 'Key
The function to transform array elements into the type that is compared.
'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 evaluationarray 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.
'T -> 'T -> int
The function to compare pairs of array elements.
'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 evaluationarray 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.
'T -> 'T -> int
The function to compare pairs of array elements.
'T array
The input array.
'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.
int
The index at which the array is split.
'T array
The input array.
'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
Evaluatesfront to [|8; 4; 3|] and back to [|1; 6; 1|].
Splits the input array into at most count chunks.
int
The maximum number of chunks.
'T array
The input array.
'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 toseq [| [|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
ThrowsArgumentException
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
'T array
The input array.
int
The index of the first element of the sub array.
int
The length of the sub array.
'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.
^T array
The input array.
^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 to11.
Returns the sum of the results generated by applying the function to each element of the array.
'T -> ^U
The function to transform the array elements into the type to be summed.
'T array
The input array.
^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 to7.
Returns a new array containing the elements of the original except the first element.
'T array
The input array.
'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.
int
The number of items to take.
'T array
The input array.
'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
ThrowsInvalidOperationException.
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.
'T -> bool
A function that evaluates to false when no more items should be returned.
'T array
The input array.
'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.
'T array
The input array.
'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.
'T array
The input array.
'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 toseq { 1; 2; 5 }.
Returns the transpose of the given sequence of arrays.
'T array seq
The input sequence of arrays.
'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.
int
The maximum number of items to return.
'T array
The input array.
'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.
'T array
The input array.
'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 toSome 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 toNone
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 toNone
Returns the first element for which the given function returns True. Return None if no such element exists.
'T -> bool
The function to test the input elements.
'T array
The input array.
'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 toSome 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 toNone
Returns the last element for which the given function returns True. Return None if no such element exists.
'T -> bool
The function to test the input elements.
'T array
The input array.
'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 toSome 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 toNone
Returns the index of the first element in the array that satisfies the given predicate.
'T -> bool
The function to test the input elements.
'T array
The input array.
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 toSome 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 toNone
Returns the index of the last element in the array that satisfies the given predicate.
'T -> bool
The function to test the input elements.
'T array
The input array.
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 toSome 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 toNone
Returns the first element of the array, or None if the array is empty.
'T array
The input array.
'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 toSome "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 toNone
Tries to find the nth element in the array. Returns None if index is negative or the input array does not contain enough elements.
int
The index of element to retrieve.
'T array
The input array.
'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 toSome "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 toNone.
Returns the last element of the array. Return None if no such element exists.
'T array
The input array.
'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 toSome "banana"
[| |] |> Array.tryLast
module Array from Microsoft.FSharp.Collections
val tryLast: array: 'T array -> 'T option
Evaluates toNone
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.
'T -> 'U option
The function to transform the array elements into options.
'T array
The input array.
'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 toSome "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 toNone.
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.
'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
The initial state value.
'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.
('T1 * 'T2) array
The input array.
'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
Evaluatesnumbers to [|1; 2|] and names to [|"one"; "two"|].
Splits an array of triples into three arrays.
('T1 * 'T2 * 'T3) array
The input array.
'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
Evaluatesnumbers 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.
int
The index of the item to be replaced.
'T
The new value.
'T array
The input array.
'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".
'T -> bool
The function to test the input elements.
'T array
The input array.
'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.
int
The number of elements in each window.
'T array
The input array.
'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>.
int
The length of the array to create.
'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.
'T1 array
The first input array.
'T2 array
The second input array.
('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.
'T1 array
The first input array.
'T2 array
The second input array.
'T3 array
The third input array.
('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")|].
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4