+
+ |
+
+ |
+
+
+
+
+
+ 
+ 
+
+
+ 
+ 
+
+
+ 
+ 
+
+
+ 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.
+
+
+
+
+
+
+ ([| 1; 2 |], [| 3; 4 |]) ||> Array.allPairs
+
+module Array
+
+from Microsoft.FSharp.Collections
+val allPairs: array1: 'T1 array -> array2: 'T2 array -> ('T1 * 'T2) array
+
+
+ Evaluates to
+ [| (1, 3); (1, 4); (2, 3); (2, 4) |]
+
+
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array that contains the elements of the first array followed by the elements of the second array.
+
+
+
+ -
+
+ array1
+
+ :
+
'T[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The resulting array.
+
+
+
+
+
+
+ Array.append [| 1; 2 |] [| 3; 4 |]
+
+module Array
+
+from Microsoft.FSharp.Collections
+val append: array1: 'T array -> array2: 'T array -> 'T array
+
+
+ Evaluates to [| 1; 2; 3; 4 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the average of the elements in the array.
+
+
+
+ -
+
+ array
+
+ :
+
^T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
^T
+
+ -
+
+ The average of the elements in the array.
+
+
+
+
+
+
+ [| 1.0; 2.0; 6.0 |] |> Array.average
+
+module Array
+
+from Microsoft.FSharp.Collections
+val average: array: 'T array -> 'T (requires member (+) and member DivideByInt and member Zero)
+
+
+ Evaluates to 3.0
+
+
+
+ [| |] |> Array.average
+
+module Array
+
+from Microsoft.FSharp.Collections
+val average: array: 'T array -> 'T (requires member (+) and member DivideByInt and member Zero)
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the average of the elements generated by applying the function to each element of the array.
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> ^U
+
+ -
+
+ The function to transform the array elements before averaging.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
^U
+
+ -
+
+ The computed average.
+
+
+
+
+
+
+ type Foo = { Bar: float }
+
+ let input = [| {Bar = 2.0}; {Bar = 4.0} |]
+
+ input |> Array.averageBy (fun foo -> foo.Bar)
+
+type Foo =
+ { Bar: float }
+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
+
+
+ Evaluates to 3.0
+
+
+
+ type Foo = { Bar: float }
+
+ let input : Foo[] = [| |]
+
+ input |> Array.averageBy (fun foo -> foo.Bar)
+
+type Foo =
+ { Bar: float }
+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
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Reads a range of elements from the first array and write them into the second.
+
+
+ let source = [| 12; 13; 14 |]
+ let target = [| 0; 1; 2; 3; 4; 5 |]
+ target[3..4] <- source[1..2]
+
+val source: int array
+val target: int array
+
+
+
+
+ -
+
+ 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.
+
+
+
+
+
+ |
+
+ ArgumentNullException
+
+ |
+
+ Thrown when either of the input arrays is null.
+ |
+
+
+ |
+
+ ArgumentException
+
+ |
+
+ Thrown when any of sourceIndex, targetIndex or count are negative,
+ or when there aren't enough elements in source or target.
+ |
+
+
+
+
+ let source = [| 12; 13; 14 |]
+ let target = [| 0; 1; 2; 3; 4; 5 |]
+
+ Array.blit source 1 target 3 2
+
+val source: int array
+val target: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val blit: source: 'T array -> sourceIndex: int -> target: 'T array -> targetIndex: int -> count: int -> unit
+
+
+ After evaluation target contains [| 0; 1; 2; 13; 14; 5 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to each element of the array. Returns
+ the array comprised of the results x for each element where
+ the function returns Some(x)
+
+
+
+ -
+
+ chooser
+
+ :
+
'T -> 'U option
+
+ -
+
+ The function to generate options from the elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The array of results.
+
+
+
+
+
+
+ let input = [| Some 1; None; Some 2 |]
+
+ input |> Array.choose id
+
+val input: int option array
+union case Option.Some: Value: 'T -> Option<'T>
+union case Option.None: Option<'T>
+module Array
+
+from Microsoft.FSharp.Collections
+val choose: chooser: ('T -> 'U option) -> array: 'T array -> 'U array
+val id: x: 'T -> 'T
+
+
+ Evaluates to [| 1; 2 |]
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.choose (fun n -> if n % 2 = 0 then Some n else None)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val choose: chooser: ('T -> 'U option) -> array: 'T array -> 'U array
+val n: int
+union case Option.Some: Value: 'T -> Option<'T>
+union case Option.None: Option<'T>
+
+
+ Evaluates to [| 2 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Divides the input array into chunks of size at most chunkSize.
+
+
+
+ -
+
+ chunkSize
+
+ :
+
int
+
+ -
+
+ The maximum size of each chunk.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[][]
+
+ -
+
+ The array divided into chunks.
+
+
+
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.chunkBySize 2
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val chunkBySize: chunkSize: int -> array: 'T array -> 'T array array
+
+
+ Evaluates to [| [|1; 2|]; [|3|] |]
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.chunkBySize -2
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val chunkBySize: chunkSize: int -> array: 'T array -> 'T array array
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ For each element of the array, applies the given function. Concatenates all the results and return the combined array.
+
+
+
+ -
+
+ mapping
+
+ :
+
'T -> 'U[]
+
+ -
+
+ The function to create sub-arrays from the input array elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The concatenation of the sub-arrays.
+
+
+
+
+
+
+ type Foo = { Bar: int[] }
+
+ let input = [| {Bar = [| 1; 2 |]}; {Bar = [| 3; 4 |]} |]
+
+ input |> Array.collect (fun foo -> foo.Bar)
+
+type Foo =
+ { Bar: int array }
+Foo.Bar: int array
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+val input: Foo array
+module Array
+
+from Microsoft.FSharp.Collections
+val collect: mapping: ('T -> 'U array) -> array: 'T array -> 'U array
+val foo: Foo
+
+
+ Evaluates to [| 1; 2; 3; 4 |]
+
+
+
+ let input = [[1; 2]; [3; 4]]
+
+ input |> Array.collect id
+
+val input: int list list
+module Array
+
+from Microsoft.FSharp.Collections
+val collect: mapping: ('T -> 'U array) -> array: 'T array -> 'U array
+val id: x: 'T -> 'T
+
+
+ Evaluates to [| 1; 2; 3; 4 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compares two arrays using the given comparison function, element by element.
+
+
+
+ -
+
+ comparer
+
+ :
+
'T -> 'T -> int
+
+ -
+
+ A function that takes an element from each array and returns an int.
+ If it evaluates to a non-zero value iteration is stopped and that value is returned.
+
+
+ -
+
+ array1
+
+ :
+
'T[]
+
+ -
+
+ 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.
+
+
+
+
+
+
+ let closerToNextDozen a b =
+ (a % 12).CompareTo(b % 12)
+
+ let input1 = [| 1; 10 |]
+ let input2 = [| 1; 10 |]
+
+ (input1, input2) ||> Array.compareWith closerToNextDozen
+
+val closerToNextDozen: a: int -> b: int -> int
+val a: int
+val b: int
+val input1: int array
+val input2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int
+
+
+ Evaluates to 0
+
+
+
+ let closerToNextDozen a b =
+ (a % 12).CompareTo(b % 12)
+
+ let input1 = [| 1; 5 |]
+ let input2 = [| 1; 8 |]
+
+ (input1, input2) ||> Array.compareWith closerToNextDozen
+
+val closerToNextDozen: a: int -> b: int -> int
+val a: int
+val b: int
+val input1: int array
+val input2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int
+
+
+ Evaluates to -1
+
+
+
+ let closerToNextDozen a b =
+ (a % 12).CompareTo(b % 12)
+
+ let input1 = [| 1; 11 |]
+ let input2 = [| 1; 13 |]
+
+ (input1, input2) ||> Array.compareWith closerToNextDozen
+
+val closerToNextDozen: a: int -> b: int -> int
+val a: int
+val b: int
+val input1: int array
+val input2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int
+
+
+ Evaluates to 1
+
+
+
+ let closerToNextDozen a b =
+ (a % 12).CompareTo(b % 12)
+
+ let input1 = [| 1; 2 |]
+ let input2 = [| 1 |]
+
+ (input1, input2) ||> Array.compareWith closerToNextDozen
+
+val closerToNextDozen: a: int -> b: int -> int
+val a: int
+val b: int
+val input1: int array
+val input2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int
+
+
+ Evaluates to 1
+
+
+
+ let closerToNextDozen a b =
+ (a % 12).CompareTo(b % 12)
+
+ let input1 = [| 1 |]
+ let input2 = [| 1; 2 |]
+
+ (input1, input2) ||> Array.compareWith closerToNextDozen
+
+val closerToNextDozen: a: int -> b: int -> int
+val a: int
+val b: int
+val input1: int array
+val input2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val compareWith: comparer: ('T -> 'T -> int) -> array1: 'T array -> array2: 'T array -> int
+
+
+ Evaluates to -1
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array that contains the elements of each of the given sequence of arrays.
+
+
+
+ -
+
+ arrays
+
+ :
+
'T[] seq
+
+ -
+
+ The input sequence of arrays.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The concatenation of the sequence of input arrays.
+
+
+
+
+
+
+ let inputs = [ [| 1; 2 |]; [| 3 |]; [| 4; 5 |] ]
+
+ inputs |> Array.concat
+
+val inputs: int array list
+module Array
+
+from Microsoft.FSharp.Collections
+val concat: arrays: 'T array seq -> 'T array
+
+
+ Evaluates to [| 1; 2; 3; 4; 5 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tests if the array contains the specified element.
+
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The value to locate in the input array.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+ -
+
+ True if the input array contains the specified element; false otherwise.
+
+
+
+
+
+
+ [| 1; 2 |] |> Array.contains 2 // evaluates to true
+ [| 1; 2 |] |> Array.contains 5 // evaluates to false
+
+module Array
+
+from Microsoft.FSharp.Collections
+val contains: value: 'T -> array: 'T array -> bool (requires equality)
+
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array that contains the elements of the given array.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ A copy of the input array.
+
+
+
+
+
+
+ let source = [| 12; 13; 14 |]
+
+ Array.copy source
+
+val source: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val copy: array: 'T array -> 'T array
+
+
+ Evaluates to a new array containing[| 12; 13; 14 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies a key-generating function to each element of an array and returns an array yielding unique
+ keys and their number of occurrences in the original array.
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'Key
+
+ -
+
+ A function transforming each item of the input array into a key to be
+ compared against the others.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
('Key * int)[]
+
+ -
+
+ 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 }
+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
+
+
+ Evaluates to [| ("a", 2); ("b", 1) |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Creates an array whose elements are all initially the given value.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The length of the array to create.
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The value for the elements.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The created array.
+
+
+
+
+
+
+ Array.create 4 "a"
+
+module Array
+
+from Microsoft.FSharp.Collections
+val create: count: int -> value: 'T -> 'T array
+
+
+ Evaluates to a new array containing[| "a"; "a"; "a"; "a" |].
+
+
+
+
+ let cell = ref "a"
+ let array = Array.create 2 cell
+ cell.Value <- "b"
+
+val cell: string ref
+Multiple items
val ref: value: 'T -> 'T ref
--------------------
type 'T ref = Ref<'T>
+Multiple items
val array: string ref array
--------------------
type 'T array = 'T array
+module Array
+
+from Microsoft.FSharp.Collections
+val create: count: int -> value: 'T -> 'T array
+property Ref.Value: string with get, set
+
+
+ Before evaluation of the last line, array contains[| { contents = "a"}; { contents = "a"} |].
+ After evaluation of the last line array contains[| { contents = "b"}; { contents = "b"} |].
+ Note each entry in the array is the same mutable cell object.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array that contains no duplicate entries according to generic hash and
+ equality comparisons on the entries.
+ If an element occurs multiple times in the array then the later occurrences are discarded.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let input = [| 1; 1; 2; 3 |]
+
+ input |> Array.distinct
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val distinct: array: 'T array -> 'T array (requires equality)
+
+
+ Evaluates to [| 1; 2; 3 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array that contains no duplicate entries according to the
+ generic hash and equality comparisons on the keys returned by the given key-generating function.
+ If an element occurs multiple times in the array then the later occurrences are discarded.
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'Key
+
+ -
+
+ A function transforming the array items into comparable keys.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ 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 } |]
+
+
+ |
+
+
+
+
+
+
+
+
+ Array.empty
+
+
+
+
+
+
+ Full Usage:
+ Array.empty
+
+
+
+ Returns:
+ 'T[]
+
+ The empty array.
+
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an empty array of the given type.
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The empty array.
+
+
+
+
+
+ Array.empty // Evaluates to [| |]
+
+module Array
+
+from Microsoft.FSharp.Collections
+val empty<'T> : 'T array
+
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the only element of the array.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The only element of the array.
+
+
+
+
+
+
+ let inputs = [| "banana" |]
+
+ inputs |> Array.exactlyOne
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val exactlyOne: array: 'T array -> 'T
+
+
+ Evaluates to banana
+
+
+
+ let inputs = [| "pear"; "banana" |]
+
+ inputs |> Array.exactlyOne
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val exactlyOne: array: 'T array -> 'T
+
+
+ Throws ArgumentException
+
+
+
+ let inputs: int[] = [| |]
+
+ 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
+module Array
+
+from Microsoft.FSharp.Collections
+val exactlyOne: array: 'T array -> 'T
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns a new list with the distinct elements of the input array which do not appear in the itemsToExclude sequence,
+ using generic hash and equality comparisons to compare values.
+
+
+
+ -
+
+ itemsToExclude
+
+ :
+
'T seq
+
+ -
+
+ A sequence whose elements that also occur in the input array will cause those elements to be
+ removed from the result.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ 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.
+
+
+
+
+
+
+ let original = [| 1; 2; 3; 4; 5 |]
+ let itemsToExclude = [| 1; 3; 5 |]
+
+ original |> Array.except itemsToExclude
+
+val original: int array
+val itemsToExclude: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val except: itemsToExclude: 'T seq -> array: 'T array -> 'T array (requires equality)
+
+
+ Evaluates to [| 2; 4 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tests if any element of the array satisfies the given predicate.
+
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+ -
+
+ True if any result from predicate is true.
+
+
+
+
+
+
+ let input = [| 1; 2; 3; 4; 5 |]
+
+ input |> Array.exists (fun elm -> elm % 4 = 0)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val exists: predicate: ('T -> bool) -> array: 'T array -> bool
+val elm: int
+
+
+ Evaluates to true
+
+
+
+ let input = [| 1; 2; 3; 4; 5 |]
+
+ input |> Array.exists (fun elm -> elm % 6 = 0)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val exists: predicate: ('T -> bool) -> array: 'T array -> bool
+val elm: int
+
+
+ Evaluates to false
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tests if any pair of corresponding elements of the arrays satisfies the given predicate.
+
+
+
+
+ -
+
+ predicate
+
+ :
+
'T1 -> 'T2 -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+ -
+
+ True if any result from predicate is true.
+
+
+
+
+
+
+ let inputs1 = [| 1; 2 |]
+ let inputs2 = [| 1; 2; 0 |]
+
+ (inputs1, inputs2) ||> Array.exists2 (fun a b -> a > b)
+
+val inputs1: int array
+val inputs2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val exists2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool
+val a: int
+val b: int
+
+
+ Evaluates to false
+
+
+
+ let inputs1 = [| 1; 4 |]
+ let inputs2 = [| 1; 3; 5 |]
+
+ (inputs1, inputs2) ||> Array.exists2 (fun a b -> a > b)
+
+val inputs1: int array
+val inputs2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val exists2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool
+val a: int
+val b: int
+
+
+ Evaluates to true
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Fills a range of elements of the array with the given value.
+
+
+
+ -
+
+ target
+
+ :
+
'T[]
+
+ -
+
+ The target array.
+
+
+ -
+
+ targetIndex
+
+ :
+
int
+
+ -
+
+ The index of the first element to set.
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The number of elements to set.
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The value to set.
+
+
+
+
+
+
+ let target = [| 0; 1; 2; 3; 4; 5 |]
+
+ Array.fill target 3 2 100
+
+val target: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val fill: target: 'T array -> targetIndex: int -> count: int -> value: 'T -> unit
+
+
+ After evaluation target contains [| 0; 1; 2; 100; 100; 5 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns a new collection containing only the elements of the collection
+ for which the given predicate returns "true".
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ An array containing the elements for which the given predicate returns true.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4 |]
+
+ inputs |> Array.filter (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val filter: predicate: ('T -> bool) -> array: 'T array -> 'T array
+val elm: int
+
+
+ Evaluates to [| 2; 4 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the first element for which the given function returns 'true'.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The first element for which predicate returns true.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3 |]
+
+ inputs |> Array.find (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val find: predicate: ('T -> bool) -> array: 'T array -> 'T
+val elm: int
+
+
+ Evaluates to 2
+
+
+
+ let inputs = [| 1; 2; 3 |]
+
+ inputs |> Array.find (fun elm -> elm % 6 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val find: predicate: ('T -> bool) -> array: 'T array -> 'T
+val elm: int
+
+
+ Throws KeyNotFoundException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the last element for which the given function returns 'true'.
+ Raise KeyNotFoundException if no such element exists.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The last element for which predicate returns true.
+
+
+
+
+
+
+ let inputs = [| 2; 3; 4 |]
+
+ inputs |> Array.findBack (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val findBack: predicate: ('T -> bool) -> array: 'T array -> 'T
+val elm: int
+
+
+ Evaluates to 4
+
+
+
+ let inputs = [| 2; 3; 4 |]
+
+ inputs |> Array.findBack (fun elm -> elm % 6 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val findBack: predicate: ('T -> bool) -> array: 'T array -> 'T
+val elm: int
+
+
+ Throws KeyNotFoundException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the index of the first element in the array
+ that satisfies the given predicate. Raise KeyNotFoundException if
+ none of the elements satisfy the predicate.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+ -
+
+ The index of the first element in the array that satisfies the given predicate.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.findIndex (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val findIndex: predicate: ('T -> bool) -> array: 'T array -> int
+val elm: int
+
+
+ Evaluates to 1
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+ inputs |> Array.findIndex (fun elm -> elm % 6 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val findIndex: predicate: ('T -> bool) -> array: 'T array -> int
+val elm: int
+
+
+ Throws KeyNotFoundException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the index of the last element in the array
+ that satisfies the given predicate. Raise KeyNotFoundException if
+ none of the elements satisfy the predicate.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+ -
+
+ The index of the last element in the array that satisfies the given predicate.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.findIndex (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val findIndex: predicate: ('T -> bool) -> array: 'T array -> int
+val elm: int
+
+
+ Evaluates to 3
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.findIndex (fun elm -> elm % 6 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val findIndex: predicate: ('T -> bool) -> array: 'T array -> int
+val elm: int
+
+
+ Throws KeyNotFoundException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies a function to each element of the collection, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then computes
+ f (... (f s i0)...) iN
+
+
+
+ -
+
+ folder
+
+ :
+
'State -> 'T -> 'State
+
+ -
+
+ The function to update the state given the input elements.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'State
+
+ -
+
+ The final state.
+
+
+
+
+
+
+ type Charge =
+ | In of int
+ | Out of int
+
+ let inputs = [| In 1; Out 2; In 3 |]
+
+ (0, inputs) ||> Array.fold (fun acc charge ->
+ match charge with
+ | In i -> acc + i
+ | Out o -> acc - o)
+
+type Charge =
+ | In of int
+ | Out of int
+union case Charge.In: int -> Charge
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+union case Charge.Out: int -> Charge
+val inputs: Charge array
+module Array
+
+from Microsoft.FSharp.Collections
+val fold<'T,'State> : folder: ('State -> 'T -> 'State) -> state: 'State -> array: 'T array -> 'State
+val acc: int
+val charge: Charge
+val i: int
+val o: int
+
+
+ Evaluates to 2
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies a function to pairs of elements drawn from the two collections,
+ left-to-right, threading an accumulator argument
+ through the computation. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ folder
+
+ :
+
'State -> 'T1 -> 'T2 -> 'State
+
+ -
+
+ The function to update the state given the input elements.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'State
+
+ -
+
+ The final state.
+
+
+
+
+
+
+ type CoinToss = Head | Tails
+
+ let data1 = [| Tails; Head; Tails |]
+ let data2 = [| Tails; Head; Head |]
+
+ (0, data1, data2) |||> Array.fold2 (fun acc a b ->
+ match (a, b) with
+ | Head, Head -> acc + 1
+ | Tails, Tails -> acc + 1
+ | _ -> acc - 1)
+
+type CoinToss =
+ | Head
+ | Tails
+union case CoinToss.Head: CoinToss
+union case CoinToss.Tails: CoinToss
+val data1: CoinToss array
+val data2: CoinToss array
+module Array
+
+from Microsoft.FSharp.Collections
+val fold2<'T1,'T2,'State> : folder: ('State -> 'T1 -> 'T2 -> 'State) -> state: 'State -> array1: 'T1 array -> array2: 'T2 array -> 'State
+val acc: int
+val a: CoinToss
+val b: CoinToss
+
+
+ Evaluates to 1
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies a function to each element of the array, starting from the end, threading an accumulator argument
+ through the computation. If the input function is f and the elements are i0...iN then computes
+ f i0 (...(f iN s))
+
+
+
+ -
+
+ folder
+
+ :
+
'T -> 'State -> 'State
+
+ -
+
+ The function to update the state given the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+
+
+ -
+
+ Returns:
+
+
'State
+
+ -
+
+ The state object after the folding function is applied to each element of the array.
+
+
+
+
+
+
+ type Count =
+ { Positive: int
+ Negative: int
+ Text: string }
+
+ let sequence = [| 1; 0; -1; -2; 3 |]
+ let initialState = {Positive = 0; Negative = 0; Text = "" }
+
+ (sequence, initialState) ||> Array.foldBack (fun a acc ->
+ let text = acc.Text + " " + string a
+ if a >= 0 then
+ { acc with
+ Positive = acc.Positive + 1
+ Text = text }
+ else
+ { acc with
+ Negative = acc.Negative + 1
+ Text = text })
+
+type Count =
+ {
+ Positive: int
+ Negative: int
+ Text: string
+ }
+Count.Positive: int
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+Count.Negative: int
+Count.Text: string
+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
+
+
+ Evaluates to
+ { 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.
+
+
+
+
+
+
+ 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) " }
+
+
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tests if all elements of the array satisfy the given predicate.
+
+
+
+
+ -
+
+ 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.
+
+
+
+
+
+
+ let isEven a = a % 2 = 0
+
+ [2; 42] |> Array.forall isEven // evaluates to true
+
+ [1; 2] |> Array.forall isEven // evaluates to false
+
+val isEven: a: int -> bool
+val a: int
+module Array
+
+from Microsoft.FSharp.Collections
+val forall: predicate: ('T -> bool) -> array: 'T array -> bool
+
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tests if all corresponding elements of the array satisfy the given predicate pairwise.
+
+
+
+
+ -
+
+ predicate
+
+ :
+
'T1 -> 'T2 -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+ -
+
+ True if all of the array elements satisfy the predicate.
+
+
+
+
+
+
+ let inputs1 = [| 1; 2; 3 |]
+ let inputs2 = [| 1; 2; 3 |]
+
+ (inputs1, inputs2) ||> Array.forall2 (=)
+
+val inputs1: int array
+val inputs2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val forall2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool
+
+
+ Evaluates to true.
+
+
+
+
+ let items1 = [| 2017; 1; 1 |]
+ let items2 = [| 2019; 19; 8 |]
+
+ (items1, items2) ||> Array.forall2 (=)
+
+val items1: int array
+val items2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val forall2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool
+
+
+ Evaluates to false.
+
+
+
+
+ let items1 = [| 1; 2; 3 |]
+ let items2 = [| 1; 2 |]
+
+ (items1, items2) ||> Array.forall2 (=)
+
+val items1: int array
+val items2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val forall2: predicate: ('T1 -> 'T2 -> bool) -> array1: 'T1 array -> array2: 'T2 array -> bool
+
+
+ Throws ArgumentException.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets an element from an array.
+
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The input index.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The value of the array at the given index.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ Array.get inputs 1
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val get: array: 'T array -> index: int -> 'T
+
+
+ Evaluates to "b"
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ Array.get inputs 4
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val get: array: 'T array -> index: int -> 'T
+
+
+ Throws IndexOutOfRangeException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies a key-generating function to each element of an array and yields an array of
+ unique keys. Each unique key contains an array of all elements that match
+ to this key.
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'Key
+
+ -
+
+ A function that transforms an element of the array into a comparable key.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
('Key * 'T[])[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.groupBy (fun n -> n % 2)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val groupBy: projection: ('T -> 'Key) -> array: 'T array -> ('Key * 'T array) array (requires equality)
+val n: int
+
+
+ Evaluates to [| (1, [| 1; 3; 5 |]); (0, [| 2; 4 |]) |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the first element of the array.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The first element of the array.
+
+
+
+
+
+
+ let inputs = [| "banana"; "pear" |]
+
+ inputs |> Array.head
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val head: array: 'T array -> 'T
+
+
+ Evaluates to banana
+
+
+
+ [| |] |> Array.head
+
+module Array
+
+from Microsoft.FSharp.Collections
+val head: array: 'T array -> 'T
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array whose elements are the corresponding elements of the input array
+ paired with the integer index (from 0) of each element.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
(int * 'T)[]
+
+ -
+
+ The array of indexed elements.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.indexed
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val indexed: array: 'T array -> (int * 'T) array
+
+
+ Evaluates to [| (0, "a"); (1, "b"); (2, "c") |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Creates an array given the dimension and a generator function to compute the elements.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The number of elements to initialize.
+
+
+ -
+
+ initializer
+
+ :
+
int -> 'T
+
+ -
+
+ The function to generate the initial values for each index.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The created array.
+
+
+
+
+
+
+ Array.init 4 (fun v -> v + 5)
+
+module Array
+
+from Microsoft.FSharp.Collections
+val init: count: int -> initializer: (int -> 'T) -> 'T array
+val v: int
+
+
+ Evaluates to [| 5; 6; 7; 8 |]
+
+
+
+ Array.init -5 (fun v -> v + 5)
+
+module Array
+
+from Microsoft.FSharp.Collections
+val init: count: int -> initializer: (int -> 'T) -> 'T array
+val v: int
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a new array with a new item inserted before the given index.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index where the item should be inserted.
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The value to insert.
+
+
+ -
+
+ source
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 0; 1; 2 |]
+
+ inputs |> Array.insertAt 1 9
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val insertAt: index: int -> value: 'T -> source: 'T array -> 'T array
+
+
+ Evaluates to [| 0; 9; 1; 2 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a new array with new items inserted before the given index.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index where the items should be inserted.
+
+
+ -
+
+ values
+
+ :
+
'T seq
+
+ -
+
+ The values to insert.
+
+
+ -
+
+ source
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 0; 1; 2 |]
+
+ inputs |> Array.insertManyAt 1 [8; 9]
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val insertManyAt: index: int -> values: 'T seq -> source: 'T array -> 'T array
+
+
+ Evaluates to [| 0; 8; 9; 1; 2 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns true if the given array is empty, otherwise false.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
bool
+
+ -
+
+ True if the array is empty.
+
+
+
+
+
+
+ [| |] |> Array.isEmpty
+
+module Array
+
+from Microsoft.FSharp.Collections
+val isEmpty: array: 'T array -> bool
+
+
+ Evaluates to true
+
+
+
+ [| "pear"; "banana" |] |> Array.isEmpty
+
+module Array
+
+from Microsoft.FSharp.Collections
+val isEmpty: array: 'T array -> bool
+
+
+ Evaluates to false
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Gets an element from an array.
+
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The input index.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The value of the array at the given index.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.item 1
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val item: index: int -> array: 'T array -> 'T
+
+
+ Evaluates to "b"
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.item 4
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val item: index: int -> array: 'T array -> 'T
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to each element of the array.
+
+
+
+ -
+
+ action
+
+ :
+
'T -> unit
+
+ -
+
+ The function to apply.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.iter (printfn "%s")
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val iter: action: ('T -> unit) -> array: 'T array -> unit
+val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
+
+ Evaluates to unit and prints
+ a
+ b
+ c
+
+
+
+ in the console.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to pair of elements drawn from matching indices in two arrays. The
+ two arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ action
+
+ :
+
'T1 -> 'T2 -> unit
+
+ -
+
+ The function to apply.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+
+
+ let inputs1 = [| "a"; "b"; "c" |]
+ let inputs2 = [| 1; 2; 3 |]
+
+ (inputs1, inputs2) ||> Array.iter2 (printfn "%s: %i")
+
+val inputs1: string array
+val inputs2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val iter2: action: ('T1 -> 'T2 -> unit) -> array1: 'T1 array -> array2: 'T2 array -> unit
+val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
+
+ Evaluates to unit and prints
+ a: 1
+ b: 2
+ c: 3
+
+
+
+ in the console.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to each element of the array. The integer passed to the
+ function indicates the index of element.
+
+
+
+ -
+
+ action
+
+ :
+
int -> 'T -> unit
+
+ -
+
+ The function to apply to each index and element.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.iteri (fun i v -> printfn "{i}: {v}")
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val iteri: action: (int -> 'T -> unit) -> array: 'T array -> unit
+val i: int
+val v: string
+val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
+
+ Evaluates to unit and prints
+ 0: a
+ 1: b
+ 2: c
+
+
+
+ in the console.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to pair of elements drawn from matching indices in two arrays,
+ also passing the index of the elements. The two arrays must have the same lengths,
+ otherwise an ArgumentException is raised.
+
+
+
+ -
+
+ action
+
+ :
+
int -> 'T1 -> 'T2 -> unit
+
+ -
+
+ The function to apply to each index and pair of elements.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+
+
+ let inputs1 = [| "a"; "b"; "c" |]
+ let inputs2 = [| "banana"; "pear"; "apple" |]
+
+ (inputs1, inputs2) ||> Array.iteri2 (fun i s1 s2 -> printfn "Index {i}: {s1} - {s2}")
+
+val inputs1: string array
+val inputs2: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val iteri2: action: (int -> 'T1 -> 'T2 -> unit) -> array1: 'T1 array -> array2: 'T2 array -> unit
+val i: int
+val s1: string
+val s2: string
+val printfn: format: Printf.TextWriterFormat<'T> -> 'T
+
+
+ Evaluates to unit and prints
+ Index 0: a - banana
+ Index 1: b - pear
+ Index 2: c - apple
+
+
+
+ in the console.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the last element of the array.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The last element of the array.
+
+
+
+
+
+
+ [| "pear"; "banana" |] |> Array.last
+
+module Array
+
+from Microsoft.FSharp.Collections
+val last: array: 'T array -> 'T
+
+
+ Evaluates to banana
+
+
+
+ [| |] |> Array.last
+
+module Array
+
+from Microsoft.FSharp.Collections
+val last: array: 'T array -> 'T
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the length of an array. You can also use property arr.Length.
+
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
int
+
+ -
+
+ The length of the array.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.length
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val length: array: 'T array -> int
+
+
+ Evaluates to 3
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array whose elements are the results of applying the given function
+ to each of the elements of the array.
+
+
+
+ -
+
+ mapping
+
+ :
+
'T -> 'U
+
+ -
+
+ The function to transform elements of the array.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The array of transformed elements.
+
+
+
+
+
+
+ let inputs = [| "a"; "bbb"; "cc" |]
+
+ inputs |> Array.map (fun x -> x.Length)
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val map: mapping: ('T -> 'U) -> array: 'T array -> 'U array
+val x: string
+property System.String.Length: int with get
+
+
+ Evaluates to [| 1; 3; 2 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise. The two input
+ arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ mapping
+
+ :
+
'T1 -> 'T2 -> 'U
+
+ -
+
+ The function to transform the pairs of the input elements.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The array of transformed elements.
+
+
+
+
+
+
+ let inputs1 = [| "a"; "bad"; "good" |]
+ let inputs2 = [| 0; 2; 1 |]
+
+ (inputs1, inputs2) ||> Array.map2 (fun x y -> x[y])
+
+val inputs1: string array
+val inputs2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val map2: mapping: ('T1 -> 'T2 -> 'U) -> array1: 'T1 array -> array2: 'T2 array -> 'U array
+val x: string
+val y: int
+
+
+ Evaluates to [| 'a'; 'd'; 'o' |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new collection whose elements are the results of applying the given function
+ to the corresponding triples from the three collections. The three input
+ arrays must have the same length, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ mapping
+
+ :
+
'T1 -> 'T2 -> 'T3 -> 'U
+
+ -
+
+ The function to transform the pairs of the input elements.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+ -
+
+ array3
+
+ :
+
'T3[]
+
+ -
+
+ The third input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The array of transformed elements.
+
+
+
+
+
+
+ let inputs1 = [| "a"; "t"; "ti" |]
+ let inputs2 = [| "l"; "h"; "m" |]
+ let inputs3 = [| "l"; "e"; "e" |]
+
+ (inputs1, inputs2, inputs3) |||> Array.map3 (fun x y z -> x + y + z)
+
+val inputs1: string array
+val inputs2: string array
+val inputs3: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val map3: mapping: ('T1 -> 'T2 -> 'T3 -> 'U) -> array1: 'T1 array -> array2: 'T2 array -> array3: 'T3 array -> 'U array
+val x: string
+val y: string
+val z: string
+
+
+ Evaluates to [| "all"; "the"; "time" |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Combines map and fold. Builds a new array whose elements are the results of applying the given function
+ to each of the elements of the input array. The function is also used to accumulate a final value.
+
+
+
+ -
+
+ mapping
+
+ :
+
'State -> 'T -> 'Result * 'State
+
+ -
+
+ The function to transform elements from the input array and accumulate the final value.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'Result[] * 'State
+
+ -
+
+ The array of transformed elements, and the final accumulated value.
+
+
+
+
+
+
+ Accumulate the charges, and double them as well
+ type Charge =
+ | In of int
+ | Out of int
+
+ let inputs = [| In 1; Out 2; In 3 |]
+
+ let newCharges, balance =
+ (0, inputs) ||> Array.mapFold (fun acc charge ->
+ match charge with
+ | In i -> In (i*2), acc + i
+ | Out o -> Out (o*2), acc - o)
+
+Multiple items
val double: value: 'T -> double (requires member op_Explicit)
--------------------
type double = System.Double
--------------------
type double<'Measure> = float<'Measure>
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+module Array
+
+from Microsoft.FSharp.Collections
+val mapFold<'T,'State,'Result> : mapping: ('State -> 'T -> 'Result * 'State) -> state: 'State -> array: 'T array -> 'Result array * 'State
+
+
+ Evaluates newCharges to [|In 2; Out 4; In 6|] and balance to 2.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Combines map and foldBack. Builds a new array whose elements are the results of applying the given function
+ to each of the elements of the input array. The function is also used to accumulate a final value.
+
+
+
+ -
+
+ mapping
+
+ :
+
'T -> 'State -> 'Result * 'State
+
+ -
+
+ The function to transform elements from the input array and accumulate the final value.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+
+
+ -
+
+ Returns:
+
+
'Result[] * '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
+union case Charge.In: int -> Charge
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+union case Charge.Out: int -> Charge
+val inputs: Charge array
+val newCharges: Charge array
+val balance: int
+module Array
+
+from Microsoft.FSharp.Collections
+val mapFoldBack: mapping: ('T -> 'State -> 'Result * 'State) -> array: 'T array -> state: 'State -> 'Result array * 'State
+val charge: Charge
+val acc: int
+val i: int
+val o: int
+
+
+ Evaluates newCharges to [|In 2; Out 4; In 6|] and balance to 2.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array whose elements are the results of applying the given function
+ to each of the elements of the array. The integer index passed to the
+ function indicates the index of element being transformed, starting at zero.
+
+
+
+ -
+
+ mapping
+
+ :
+
int -> 'T -> 'U
+
+ -
+
+ The function to transform elements and their indices.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The array of transformed elements.
+
+
+
+
+
+
+ let inputs = [| 10; 10; 10 |]
+
+ inputs |> Array.mapi (fun i x -> i + x)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val mapi: mapping: (int -> 'T -> 'U) -> array: 'T array -> 'U array
+val i: int
+val x: int
+
+
+ Evaluates to [| 10; 11; 12 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new collection whose elements are the results of applying the given function
+ to the corresponding elements of the two collections pairwise, also passing the index of
+ the elements. The two input arrays must have the same lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ mapping
+
+ :
+
int -> 'T1 -> 'T2 -> 'U
+
+ -
+
+ The function to transform pairs of input elements and their indices.
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U[]
+
+ -
+
+ The array of transformed elements.
+
+
+
+
+
+
+ let inputs1 = [| "a"; "bad"; "good" |]
+ let inputs2 = [| 0; 2; 1 |]
+
+ (inputs1, inputs2) ||> Array.mapi2 (fun i x y -> i, x[y])
+
+val inputs1: string array
+val inputs2: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val mapi2: mapping: (int -> 'T1 -> 'T2 -> 'U) -> array1: 'T1 array -> array2: 'T2 array -> 'U array
+val i: int
+val x: string
+val y: int
+
+
+ Evaluates to [|(0, 'a'); (1, 'd'); (2, 'o')|]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the greatest of all elements of the array, compared via Operators.max on the function result.
+
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The maximum element.
+
+
+
+
+
+
+ let inputs = [| 10; 12; 11 |]
+
+ inputs |> Array.max
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val max: array: 'T array -> 'T (requires comparison)
+
+
+ Evaluates to 12
+
+
+
+ let inputs: int[]= [| |]
+
+ 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
+module Array
+
+from Microsoft.FSharp.Collections
+val max: array: 'T array -> 'T (requires comparison)
+
+
+ Throws System.ArgumentException.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the greatest of all elements of the array, compared via Operators.max on the function result.
+
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'U
+
+ -
+
+ The function to transform the elements into a type supporting comparison.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The maximum element.
+
+
+
+
+
+
+ let inputs = [| "aaa"; "b"; "cccc" |]
+
+ inputs |> Array.maxBy (fun s -> s.Length)
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val maxBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ Evaluates to "cccc"
+
+
+
+ let inputs: string[]= [| |]
+
+ inputs |> Array.maxBy (fun s -> s.Length)
+
+val inputs: string array
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+module Array
+
+from Microsoft.FSharp.Collections
+val maxBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ Throws System.ArgumentException.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the lowest of all elements of the array, compared via Operators.min.
+
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The minimum element.
+
+
+
+
+
+
+ let inputs = [| 10; 12; 11 |]
+
+ inputs |> Array.min
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val min: array: 'T array -> 'T (requires comparison)
+
+
+ Evaluates to 10
+
+
+
+ let inputs: int[]= [| |]
+
+ 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
+module Array
+
+from Microsoft.FSharp.Collections
+val min: array: 'T array -> 'T (requires comparison)
+
+
+ Throws System.ArgumentException.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the lowest of all elements of the array, compared via Operators.min on the function result.
+
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'U
+
+ -
+
+ The function to transform the elements into a type supporting comparison.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T
+
+ -
+
+ The minimum element.
+
+
+
+
+
+
+ let inputs = [| "aaa"; "b"; "cccc" |]
+
+ inputs |> Array.minBy (fun s -> s.Length)
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val minBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ Evaluates to "b"
+
+
+
+ let inputs: string[]= [| |]
+
+ inputs |> Array.minBy (fun s -> s.Length)
+
+val inputs: string array
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+module Array
+
+from Microsoft.FSharp.Collections
+val minBy: projection: ('T -> 'U) -> array: 'T array -> 'T (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ Throws System.ArgumentException.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds an array from the given list.
+
+
+
+ -
+
+ list
+
+ :
+
'T list
+
+ -
+
+ The input list.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The array of elements from the list.
+
+
+
+
+
+ let inputs = [ 1; 2; 5 ]
+
+ inputs |> Array.ofList
+
+val inputs: int list
+module Array
+
+from Microsoft.FSharp.Collections
+val ofList: list: 'T list -> 'T array
+
+
+ Evaluates to [| 1; 2; 5 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array from the given enumerable object.
+
+
+
+ -
+
+ source
+
+ :
+
'T seq
+
+ -
+
+ The input sequence.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ 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 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.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4 |]
+
+ inputs |> Array.pairwise
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val pairwise: array: 'T array -> ('T * 'T) array
+
+
+ Evaluates to [|(1, 2); (2, 3); (3, 4)|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Splits the collection into two collections, containing the
+ elements for which the given predicate returns "true" and "false"
+ respectively.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ 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.
+
+
+
+
+
+
+ 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.
+
+
+
+ -
+
+ indexMap
+
+ :
+
int -> int
+
+ -
+
+ The function that maps input indices to output indices.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The output array.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4 |]
+
+ inputs |> Array.permute (fun x -> (x + 1) % 4)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val permute: indexMap: (int -> int) -> array: 'T array -> 'T array
+val x: int
+
+
+ Evaluates to [|4; 1; 2; 3|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to successive elements, returning the first
+ result where the function returns Some(x) for some x. If the function
+ never returns Some(x) then KeyNotFoundException is raised.
+
+
+
+ -
+
+ chooser
+
+ :
+
'T -> 'U option
+
+ -
+
+ The function to generate options from the elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U
+
+ -
+
+ The first result.
+
+
+
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.pick (fun n -> if n % 2 = 0 then Some (string n) else None)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val pick: chooser: ('T -> 'U option) -> array: 'T array -> 'U
+val n: int
+union case Option.Some: Value: 'T -> Option<'T>
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+union case Option.None: Option<'T>
+
+
+ Evaluates to "2".
+
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.pick (fun n -> if n > 3 = 0 then Some (string n) else None)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val pick: chooser: ('T -> 'U option) -> array: 'T array -> 'U
+val n: int
+union case Option.Some: Value: 'T -> Option<'T>
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+union case Option.None: Option<'T>
+
+
+ Throws KeyNotFoundException.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+ let inputs = [| 1; 3; 4; 2 |]
+
+ inputs |> Array.reduce (fun a b -> a * 10 + b)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val reduce: reduction: ('T -> 'T -> 'T) -> array: 'T array -> 'T
+val a: int
+val b: int
+
+
+ Evaluates to 1342, by computing ((1 * 10 + 3) * 10 + 4) * 10 + 2
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+ let inputs = [| 1; 3; 4; 2 |]
+
+ inputs |> Array.reduceBack (fun a b -> a + b * 10)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val reduceBack: reduction: ('T -> 'T -> 'T) -> array: 'T array -> 'T
+val a: int
+val b: int
+
+
+ Evaluates to 2431, by computing 1 + (3 + (4 + 2 * 10) * 10) * 10
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a new array with the item at a given index removed.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index of the item to be removed.
+
+
+ -
+
+ source
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 0; 1; 2 |]
+
+ inputs |> Array.removeAt 1
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val removeAt: index: int -> source: 'T array -> 'T array
+
+
+ Evaluates to [| 0; 2 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a new array with the number of items starting at a given index removed.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index of the item to be removed.
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The number of items to remove.
+
+
+ -
+
+ source
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 0; 1; 2; 3 |]
+
+ inputs |> Array.removeManyAt 1 2
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val removeManyAt: index: int -> count: int -> source: 'T array -> 'T array
+
+
+ Evaluates to [| 0; 3 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Creates an array by replicating the given initial value.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The number of elements to replicate.
+
+
+ -
+
+ initial
+
+ :
+
'T
+
+ -
+
+ The value to replicate
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The generated array.
+
+
+
+
+
+
+ Array.replicate 3 "a"
+
+module Array
+
+from Microsoft.FSharp.Collections
+val replicate: count: int -> initial: 'T -> 'T array
+
+
+ Evaluates to [| "a"; "a"; "a" |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns a new array with the elements in reverse order.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The reversed array.
+
+
+
+
+
+
+ Array.rev [| 0; 1; 2 |]
+
+module Array
+
+from Microsoft.FSharp.Collections
+val rev: array: 'T array -> 'T array
+
+
+ Evaluates to [| 2; 1; 0 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Like fold, but return the intermediary and final results.
+
+
+
+ -
+
+ folder
+
+ :
+
'State -> 'T -> 'State
+
+ -
+
+ The function to update the state given the input elements.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'State[]
+
+ -
+
+ 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
+union case Charge.In: int -> Charge
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+union case Charge.Out: int -> Charge
+val inputs: Charge array
+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 intial
+ state, 1 the next state, -1 the next state, and 2 the final state.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Like foldBack, but return both the intermediary and final results.
+
+
+
+ -
+
+ folder
+
+ :
+
'T -> 'State -> 'State
+
+ -
+
+ The function to update the state given the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state.
+
+
+
+
+ -
+
+ Returns:
+
+
'State[]
+
+ -
+
+ 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
+union case Charge.In: int -> Charge
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+union case Charge.Out: int -> Charge
+val inputs: Charge array
+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 intial
+ state, 3 the next state, 1 the next state, and 2 the final state.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sets an element of an array.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The input index.
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The input value.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ Array.set inputs 1 "B"
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val set: array: 'T array -> index: int -> value: 'T -> unit
+
+
+ After evaluation inputs contains [| "a"; "B"; "c" |]
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ Array.set inputs 4 "d"
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val set: array: 'T array -> index: int -> value: 'T -> unit
+
+
+ Throws IndexOutOfRangeException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array that contains one item only.
+
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The input item.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array of one item.
+
+
+
+
+
+ Array.singleton 7
+
+module Array
+
+from Microsoft.FSharp.Collections
+val singleton: value: 'T -> 'T array
+
+
+ Evaluates to [| 7 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array that contains the elements of the given array, excluding the first N elements.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The number of elements to skip. If negative the full array will be returned as a copy.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ A copy of the input array, after removing the first N elements.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.skip 2
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val skip: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| "c"; "d" |]
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.skip 5
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val skip: count: int -> array: 'T array -> 'T array
+
+
+ Throws ArgumentException.
+
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.skip -1
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val skip: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| "a"; "b"; "c"; "d" |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Bypasses elements in an array while the given predicate returns True, and then returns
+ the remaining elements in a new array.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ A function that evaluates an element of the array to a boolean value.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The created sub array.
+
+
+
+
+
+
+ let inputs = [| "a"; "bbb"; "cc"; "d" |]
+
+ inputs |> Array.skipWhile (fun x -> x.Length < 3)
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val skipWhile: predicate: ('T -> bool) -> array: 'T array -> 'T array
+val x: string
+property System.String.Length: int with get
+
+
+ Evaluates to [|"bbb"; "cc"; "d"|]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare.
+
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The sorted array.
+
+
+
+
+
+
+ let input = [| 8; 4; 3; 1; 6; 1 |]
+
+ Array.sort input
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val sort: array: 'T array -> 'T array (requires comparison)
+
+
+ Evaluates to [| 1; 1; 3; 4; 6; 8 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array, using the given projection for the keys and returning a new array.
+ Elements are compared using Operators.compare.
+
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'Key
+
+ -
+
+ The function to transform array elements into the type that is compared.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The sorted array.
+
+
+
+
+
+
+ let input = [| "a"; "bbb"; "cccc"; "dd" |]
+
+ input |> Array.sortBy (fun s -> s.Length)
+
+val input: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortBy: projection: ('T -> 'Key) -> array: 'T array -> 'T array (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ Evaluates to [|"a"; "dd"; "bbb"; "cccc"|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array, in descending order, using the given projection for the keys and returning a new array.
+ Elements are compared using Operators.compare.
+
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'Key
+
+ -
+
+ The function to transform array elements into the type that is compared.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The sorted array.
+
+
+
+
+
+ let input = [| "a"; "bbb"; "cccc"; "dd" |]
+
+ input |> Array.sortByDescending (fun s -> s.Length)
+
+val input: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortByDescending: projection: ('T -> 'Key) -> array: 'T array -> 'T array (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ Evaluates to [|"cccc"; "bbb"; "dd"; "a"|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array, in descending order, returning a new array. Elements are compared using Operators.compare.
+
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The sorted array.
+
+
+
+
+
+ let input = [| 8; 4; 3; 1; 6; 1 |]
+
+ input |> Array.sortDescending
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortDescending: array: 'T array -> 'T array (requires comparison)
+
+
+ Evaluates to [| 8; 6; 4; 3; 1; 1 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array by mutating the array in-place, using the given comparison function.
+ Elements are compared using Operators.compare.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+
+
+ let array = [| 8; 4; 3; 1; 6; 1 |]
+
+ Array.sortInPlace array
+
+Multiple items
val array: int array
--------------------
type 'T array = 'T array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortInPlace: array: 'T array -> unit (requires comparison)
+
+
+ After evaluation array contains [| 1; 1; 3; 4; 6; 8 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array by mutating the array in-place, using the given projection for the keys.
+ Elements are compared using Operators.compare.
+
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> 'Key
+
+ -
+
+ The function to transform array elements into the type that is compared.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+
+
+ let array = [| "a"; "bbb"; "cccc"; "dd" |]
+
+ array |> Array.sortInPlaceBy (fun s -> s.Length)
+
+Multiple items
val array: string array
--------------------
type 'T array = 'T array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortInPlaceBy: projection: ('T -> 'Key) -> array: 'T array -> unit (requires comparison)
+val s: string
+property System.String.Length: int with get
+
+
+ After evaluation array contains [|"a"; "dd"; "bbb"; "cccc"|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order.
+
+
+
+ -
+
+ comparer
+
+ :
+
'T -> 'T -> int
+
+ -
+
+ The function to compare pairs of array elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+
+
+ The following sorts entries using a comparison function that compares string lengths then index numbers:
+ let compareEntries (n1: int, s1: string) (n2: int, s2: string) =
+ let c = compare s1.Length s2.Length
+ if c <> 0 then c else
+ compare n1 n2
+
+ let array = [| (0,"aa"); (1,"bbb"); (2,"cc"); (3,"dd") |]
+
+ array |> Array.sortInPlaceWith compareEntries
+
+val compareEntries: n1: int * s1: string -> n2: int * s2: string -> int
+val n1: int
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+val s1: string
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+val n2: int
+val s2: string
+val c: int
+val compare: e1: 'T -> e2: 'T -> int (requires comparison)
+property System.String.Length: int with get
+Multiple items
val array: (int * string) array
--------------------
type 'T array = 'T array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortInPlaceWith: comparer: ('T -> 'T -> int) -> array: 'T array -> unit
+
+
+ After evaluation array contains [|(0, "aa"); (2, "cc"); (3, "dd"); (1, "bbb")|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sorts the elements of an array, using the given comparison function as the order, returning a new array.
+
+
+
+
+ -
+
+ comparer
+
+ :
+
'T -> 'T -> int
+
+ -
+
+ The function to compare pairs of array elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The sorted array.
+
+
+
+
+
+
+ Sort an array of pairs using a comparison function that compares string lengths then index numbers:
+ let compareEntries (n1: int, s1: string) (n2: int, s2: string) =
+ let c = compare s1.Length s2.Length
+ if c <> 0 then c else
+ compare n1 n2
+
+ let input = [| (0,"aa"); (1,"bbb"); (2,"cc"); (3,"dd") |]
+
+ input |> Array.sortWith compareEntries
+
+val compareEntries: n1: int * s1: string -> n2: int * s2: string -> int
+val n1: int
+Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
+ int
+val s1: string
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+val n2: int
+val s2: string
+val c: int
+val compare: e1: 'T -> e2: 'T -> int (requires comparison)
+property System.String.Length: int with get
+val input: (int * string) array
+module Array
+
+from Microsoft.FSharp.Collections
+val sortWith: comparer: ('T -> 'T -> int) -> array: 'T array -> 'T array
+
+
+ Evaluates to [|(0, "aa"); (2, "cc"); (3, "dd"); (1, "bbb")|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Splits an array into two arrays, at the given index.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index at which the array is split.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[] * 'T[]
+
+ -
+
+ The two split arrays.
+
+
+
+
+
+
+ let input = [| 8; 4; 3; 1; 6; 1 |]
+
+ let front, back = input |> Array.splitAt 3
+
+val input: int array
+val front: int array
+val back: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val splitAt: index: int -> array: 'T array -> 'T array * 'T array
+
+
+ Evaluates front to [|8; 4; 3|] and back to [|1; 6; 1|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Splits the input array into at most count chunks.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The maximum number of chunks.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[][]
+
+ -
+
+ The array split into chunks.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.splitInto 3
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val splitInto: count: int -> array: 'T array -> 'T array array
+
+
+ Evaluates to seq [| [|1; 2|]; [|3; 4|]; [|5|] |]
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.splitInto -1
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val splitInto: count: int -> array: 'T array -> 'T array array
+
+
+ Throws ArgumentException
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a new array that contains the given subrange specified by
+ starting index and length.
+
+
+ let input = [| 0; 1; 2; 3; 4; 5 |]
+
+ input.[2..4]
+
+val input: int array
+
+
+
+
+ -
+
+ 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.
+
+
+
+
+
+
+ let input = [| 0; 1; 2; 3; 4; 5 |]
+
+ Array.sub input 2 3
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val sub: array: 'T array -> startIndex: int -> count: int -> 'T array
+
+
+ Evaluates to [| 2; 3; 4 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the sum of the elements in the array.
+
+
+
+ -
+
+ array
+
+ :
+
^T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
^T
+
+ -
+
+ The resulting sum.
+
+
+
+
+
+
+ let input = [| 1; 5; 3; 2 |]
+
+ input |> Array.sum
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val sum: array: 'T array -> 'T (requires member (+) and member Zero)
+
+
+ Evaluates to 11.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the sum of the results generated by applying the function to each element of the array.
+
+
+
+ -
+
+ projection
+
+ :
+
'T -> ^U
+
+ -
+
+ The function to transform the array elements into the type to be summed.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
^U
+
+ -
+
+ The resulting sum.
+
+
+
+
+
+
+ let input = [| "aa"; "bbb"; "cc" |]
+
+ input |> Array.sumBy (fun s -> s.Length)
+
+val input: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val sumBy: projection: ('T -> 'U) -> array: 'T array -> 'U (requires member (+) and member Zero)
+val s: string
+property System.String.Length: int with get
+
+
+ Evaluates to 7.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns a new array containing the elements of the original except the first element.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ A new array containing the elements of the original except the first element.
+
+
+
+
+
+
+ let inputs = [| "a"; "bb"; "ccc" |]
+
+ inputs |> Array.tail
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val tail: array: 'T array -> 'T array
+
+
+ Evaluates to [| "bb"; "ccc" |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the first N elements of the array.
+
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The number of items to take.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.take 2
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val take: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| "a"; "b" |]
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.take 6
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val take: count: int -> array: 'T array -> 'T array
+
+
+ Throws InvalidOperationException.
+
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.take 0
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val take: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array that contains all elements of the original array while the
+ given predicate returns True, and then returns no further elements.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ A function that evaluates to false when no more items should be returned.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| "a"; "bb"; "ccc"; "d" |]
+
+ inputs |> Array.takeWhile (fun x -> x.Length < 3)
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val takeWhile: predicate: ('T -> bool) -> array: 'T array -> 'T array
+val x: string
+property System.String.Length: int with get
+
+
+ Evaluates to [| "a"; "bb" |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Builds a list from the given array.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T list
+
+ -
+
+ The list of array elements.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 5 |]
+
+ inputs |> Array.toList
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val toList: array: 'T array -> 'T list
+
+
+ Evaluates to [ 1; 2; 5 ].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Views the given array as a sequence.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T seq
+
+ -
+
+ The sequence of array elements.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 5 |]
+
+ inputs |> Array.toSeq
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val toSeq: array: 'T array -> 'T seq
+
+
+ Evaluates to seq { 1; 2; 5 }.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the transpose of the given sequence of arrays.
+
+
+
+ -
+
+ arrays
+
+ :
+
'T[] seq
+
+ -
+
+ The input sequence of arrays.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[][]
+
+ -
+
+ The transposed array.
+
+
+
+
+
+
+ let inputs =
+ [| [| 10; 20; 30 |]
+ [| 11; 21; 31 |] |]
+
+ inputs |> Array.transpose
+
+val inputs: int array array
+module Array
+
+from Microsoft.FSharp.Collections
+val transpose: arrays: 'T array seq -> 'T array array
+
+
+ Evaluates to [|[|10; 11|]; [|20; 21|]; [|30; 31|]|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns at most N elements in a new array.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The maximum number of items to return.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.truncate 2
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val truncate: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| "a"; "b" |]
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.truncate 6
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val truncate: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| "a"; "b"; "c"; "d" |]
+
+
+
+ let inputs = [| "a"; "b"; "c"; "d" |]
+
+ inputs |> Array.truncate 0
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val truncate: count: int -> array: 'T array -> 'T array
+
+
+ Evaluates to [| |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the only element of the array or None if array is empty or contains more than one element.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T option
+
+ -
+
+ The only element of the array or None.
+
+
+
+
+
+
+ let inputs = [| "banana" |]
+
+ inputs |> Array.tryExactlyOne
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryExactlyOne: array: 'T array -> 'T option
+
+
+ Evaluates to Some banana
+
+
+
+ let inputs = [| "pear"; "banana" |]
+
+ inputs |> Array.tryExactlyOne
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryExactlyOne: array: 'T array -> 'T option
+
+
+ Evaluates to None
+
+
+
+ let inputs: int[] = [| |]
+
+ 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
+module Array
+
+from Microsoft.FSharp.Collections
+val tryExactlyOne: array: 'T array -> 'T option
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the first element for which the given function returns True.
+ Return None if no such element exists.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T option
+
+ -
+
+ The first element that satisfies the predicate, or None.
+
+
+
+
+
+
+ Try to find the first even number:
+ let inputs = [| 1; 2; 3 |]
+
+ inputs |> Array.tryFind (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFind: predicate: ('T -> bool) -> array: 'T array -> 'T option
+val elm: int
+
+
+ Evaluates to Some 2
+
+
+
+ Try to find the first even number:
+ let inputs = [| 1; 5; 3 |]
+
+ inputs |> Array.tryFind (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFind: predicate: ('T -> bool) -> array: 'T array -> 'T option
+val elm: int
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the last element for which the given function returns True.
+ Return None if no such element exists.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T option
+
+ -
+
+ The last element that satisfies the predicate, or None.
+
+
+
+
+
+
+ Try to find the first even number from the back:
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.tryFindBack (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFindBack: predicate: ('T -> bool) -> array: 'T array -> 'T option
+val elm: int
+
+
+ Evaluates to Some 4
+
+
+
+ Try to find the first even number from the back:
+ let inputs = [| 1; 5; 3 |]
+
+ inputs |> Array.tryFindBack (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFindBack: predicate: ('T -> bool) -> array: 'T array -> 'T option
+val elm: int
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the index of the first element in the array
+ that satisfies the given predicate.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
int option
+
+ -
+
+ The index of the first element that satisfies the predicate, or None.
+
+
+
+
+
+
+ Try to find the index of the first even number:
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.tryFindIndex (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFindIndex: predicate: ('T -> bool) -> array: 'T array -> int option
+val elm: int
+
+
+ Evaluates to Some 1
+
+
+
+ Try to find the index of the first even number:
+ let inputs = [| 1; 3; 5; 7 |]
+
+ inputs |> Array.tryFindIndex (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFindIndex: predicate: ('T -> bool) -> array: 'T array -> int option
+val elm: int
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the index of the last element in the array
+ that satisfies the given predicate.
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
int option
+
+ -
+
+ The index of the last element that satisfies the predicate, or None.
+
+
+
+
+
+
+ Try to find the index of the first even number from the back:
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.tryFindIndexBack (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFindIndexBack: predicate: ('T -> bool) -> array: 'T array -> int option
+val elm: int
+
+
+ Evaluates to Some 3
+
+
+
+ Try to find the index of the first even number from the back:
+ let inputs = [| 1; 3; 5; 7 |]
+
+ inputs |> Array.tryFindIndexBack (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryFindIndexBack: predicate: ('T -> bool) -> array: 'T array -> int option
+val elm: int
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the first element of the array, or
+ None if the array is empty.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T option
+
+ -
+
+ The first element of the array or None.
+
+
+
+
+
+
+ let inputs = [| "banana"; "pear" |]
+
+ inputs |> Array.tryHead
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryHead: array: 'T array -> 'T option
+
+
+ Evaluates to Some "banana"
+
+
+
+ let inputs : int[] = [| |]
+
+ 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
+module Array
+
+from Microsoft.FSharp.Collections
+val tryHead: array: 'T array -> 'T option
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tries to find the nth element in the array.
+ Returns None if index is negative or the input array does not contain enough elements.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index of element to retrieve.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T option
+
+ -
+
+ The nth element of the array or None.
+
+
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.tryItem 1
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryItem: index: int -> array: 'T array -> 'T option
+
+
+ Evaluates to Some "b".
+
+
+
+
+ let inputs = [| "a"; "b"; "c" |]
+
+ inputs |> Array.tryItem 4
+
+val inputs: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryItem: index: int -> array: 'T array -> 'T option
+
+
+ Evaluates to None.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the last element of the array.
+ Return None if no such element exists.
+
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T option
+
+ -
+
+ The last element of the array or None.
+
+
+
+
+
+
+ [| "pear"; "banana" |] |> Array.tryLast
+
+module Array
+
+from Microsoft.FSharp.Collections
+val tryLast: array: 'T array -> 'T option
+
+
+ Evaluates to Some "banana"
+
+
+
+ [| |] |> Array.tryLast
+
+module Array
+
+from Microsoft.FSharp.Collections
+val tryLast: array: 'T array -> 'T option
+
+
+ Evaluates to None
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Applies the given function to successive elements, returning the first
+ result where the function returns Some(x) for some x. If the function
+ never returns Some(x) then None is returned.
+
+
+
+ -
+
+ chooser
+
+ :
+
'T -> 'U option
+
+ -
+
+ The function to transform the array elements into options.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'U option
+
+ -
+
+ The first transformed element that is Some(x).
+
+
+
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.tryPick (fun n -> if n % 2 = 0 then Some (string n) else None)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryPick: chooser: ('T -> 'U option) -> array: 'T array -> 'U option
+val n: int
+union case Option.Some: Value: 'T -> Option<'T>
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+union case Option.None: Option<'T>
+
+
+ Evaluates to Some "2".
+
+
+
+
+ let input = [| 1; 2; 3 |]
+
+ input |> Array.tryPick (fun n -> if n > 3 = 0 then Some (string n) else None)
+
+val input: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val tryPick: chooser: ('T -> 'U option) -> array: 'T array -> 'U option
+val n: int
+union case Option.Some: Value: 'T -> Option<'T>
+Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
+union case Option.None: Option<'T>
+
+
+ Evaluates to None.
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array that contains the elements generated by the given computation.
+ The generator is repeatedly called to build the list until it returns `None`.
+ The given initial state argument is passed to the element generator.
+
+
+
+ -
+
+ generator
+
+ :
+
'State -> ('T * 'State) option
+
+ -
+
+ A function that takes in the current state and returns an option tuple of the next
+ element of the array and the next state value.
+
+
+ -
+
+ state
+
+ :
+
'State
+
+ -
+
+ The initial state value.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+ 1 |> Array.unfold (fun state -> if state > 100 then None else Some (state, state * 2))
+
+module Array
+
+from Microsoft.FSharp.Collections
+val unfold<'T,'State> : generator: ('State -> ('T * 'State) option) -> state: 'State -> 'T array
+val state: int
+union case Option.None: Option<'T>
+union case Option.Some: Value: 'T -> Option<'T>
+
+
+ Evaluates to [| 1; 2; 4; 8; 16; 32; 64 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Splits an array of pairs into two arrays.
+
+
+
+ -
+
+ array
+
+ :
+
('T1 * 'T2)[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T1[] * 'T2[]
+
+ -
+
+ The two arrays.
+
+
+
+
+
+
+ let inputs = [| (1, "one"); (2, "two") |]
+
+ let numbers, names = inputs |> Array.unzip
+
+val inputs: (int * string) array
+val numbers: int array
+val names: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val unzip: array: ('T1 * 'T2) array -> 'T1 array * 'T2 array
+
+
+ Evaluates numbers to [|1; 2|] and names to [|"one"; "two"|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Splits an array of triples into three arrays.
+
+
+
+ -
+
+ array
+
+ :
+
('T1 * 'T2 * 'T3)[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T1[] * 'T2[] * 'T3[]
+
+ -
+
+ The tuple of three arrays.
+
+
+
+
+
+
+ let inputs = [| (1, "one", "I"); (2, "two", "II") |]
+
+ let numbers, names, roman = inputs |> Array.unzip3
+
+val inputs: (int * string * string) array
+val numbers: int array
+val names: string array
+val roman: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val unzip3: array: ('T1 * 'T2 * 'T3) array -> 'T1 array * 'T2 array * 'T3 array
+
+
+ Evaluates numbers to [|1; 2|], names to [|"one"; "two"|] and roman to [|"I"; "II"|].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Return a new array with the item at a given index set to the new value.
+
+
+
+ -
+
+ index
+
+ :
+
int
+
+ -
+
+ The index of the item to be replaced.
+
+
+ -
+
+ value
+
+ :
+
'T
+
+ -
+
+ The new value.
+
+
+ -
+
+ source
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 0; 1; 2 |]
+
+ inputs |> Array.updateAt 1 9
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val updateAt: index: int -> value: 'T -> source: 'T array -> 'T array
+
+
+ Evaluates to [| 0; 9; 2 |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns a new array containing only the elements of the array
+ for which the given predicate returns "true".
+
+
+
+
+ -
+
+ predicate
+
+ :
+
'T -> bool
+
+ -
+
+ The function to test the input elements.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ An array containing the elements for which the given predicate returns true.
+
+
+
+
+
+
+ Select only the even numbers:
+ let inputs = [| 1; 2; 3; 4 |]
+
+ inputs |> Array.where (fun elm -> elm % 2 = 0)
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val where: predicate: ('T -> bool) -> array: 'T array -> 'T array
+val elm: int
+
+
+ Evaluates to [| 2; 4 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array of sliding windows containing elements drawn from the input
+ array. Each window is returned as a fresh array.
+
+
+
+ -
+
+ windowSize
+
+ :
+
int
+
+ -
+
+ The number of elements in each window.
+
+
+ -
+
+ array
+
+ :
+
'T[]
+
+ -
+
+ The input array.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[][]
+
+ -
+
+ The result array.
+
+
+
+
+
+
+ let inputs = [| 1; 2; 3; 4; 5 |]
+
+ inputs |> Array.windowed 3
+
+val inputs: int array
+module Array
+
+from Microsoft.FSharp.Collections
+val windowed: windowSize: int -> array: 'T array -> 'T array array
+
+
+ Evaluates to [|[|1; 2; 3|]; [|2; 3; 4|]; [|3; 4; 5|]|]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Creates an array where the entries are initially the default value Unchecked.defaultof<'T>.
+
+
+
+ -
+
+ count
+
+ :
+
int
+
+ -
+
+ The length of the array to create.
+
+
+
+
+ -
+
+ Returns:
+
+
'T[]
+
+ -
+
+ The created array.
+
+
+
+
+
+
+ let arr : int[] = 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
+module Array
+
+from Microsoft.FSharp.Collections
+val zeroCreate: count: int -> 'T array
+
+
+ Evaluates to [| 0; 0; 0; 0 |]
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+
+
+ -
+
+ Returns:
+
+
('T1 * 'T2)[]
+
+ -
+
+ The array of tupled elements.
+
+
+
+
+
+
+ let numbers = [|1; 2|]
+ let names = [|"one"; "two"|]
+
+ Array.zip numbers names
+
+val numbers: int array
+val names: string array
+module Array
+
+from Microsoft.FSharp.Collections
+val zip: array1: 'T1 array -> array2: 'T2 array -> ('T1 * 'T2) array
+
+
+ Evaluates to [| (1, "one"); (2, "two") |].
+
+
+
+ |
+
+
+ |
+
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is
+ raised.
+
+
+
+ -
+
+ array1
+
+ :
+
'T1[]
+
+ -
+
+ The first input array.
+
+
+ -
+
+ array2
+
+ :
+
'T2[]
+
+ -
+
+ The second input array.
+
+
+ -
+
+ array3
+
+ :
+
'T3[]
+
+ -
+
+ The third input array.
+
+
+
+
+ -
+
+ Returns:
+
+
('T1 * 'T2 * 'T3)[]
+
+ -
+
+ 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")|].
+
+
+
+ |
+
+
+