Seq.allPairs source1 source2
Full Usage:
Seq.allPairs source1 source2
Parameters:
source1
:
'T1 seq
-
The first sequence.
source2
:
'T2 seq
-
The second sequence.
Returns:
('T1 * 'T2) seq
The result sequence.
Type parameters:
'T1, 'T2
|
Returns a new sequence that contains all pairings of elements from the first and second sequences.
Enumeration is O(n*m), where n and m are the lengths of the sequences.
-
source1
:
'T1 seq
-
The first sequence.
-
source2
:
'T2 seq
-
The second sequence.
-
Returns:
('T1 * 'T2) seq
-
The result sequence.
Example
([1; 2], [3; 4]) ||> Seq.allPairs
module Seq
from Microsoft.FSharp.Collections
val allPairs: source1: 'T1 seq -> source2: 'T2 seq -> ('T1 * 'T2) seq
Evaluates to a sequence yielding the same results as
seq { (1, 3); (1, 4); (2, 3); (2, 4) }
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
|
Seq.append source1 source2
Full Usage:
Seq.append source1 source2
Parameters:
source1
:
'T seq
-
The first sequence.
source2
:
'T seq
-
The second sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Wraps the two given enumerations as a single concatenated
enumeration.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed
concurrently. Sequence construction is O(1). Enumeration is O(n+m), where n and m are the lengths of the sequences.
-
source1
:
'T seq
-
The first sequence.
-
source2
:
'T seq
-
The second sequence.
-
Returns:
'T seq
-
The result sequence.
Example
module Seq
from Microsoft.FSharp.Collections
val append: source1: 'T seq -> source2: 'T seq -> 'T seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 3; 4 }
|
Seq.average source
Full Usage:
Seq.average source
Parameters:
source
:
^T seq
-
The input sequence.
Returns:
^T
The average.
Modifiers:
inline
Type parameters:
^T (requires (static member op_Addition : ^T * ^T -> ^T) and (static member DivideByInt : ^T * Microsoft.FSharp.Core.int -> ^T) and (static member get_Zero : -> ^T))
|
Returns the average of the elements in the sequence.
The elements are averaged using the + operator, DivideByInt method and Zero property
associated with the element type. This is an O(n) operation, where n is the length of the sequence.
-
source
:
^T seq
-
The input sequence.
-
Returns:
^T
-
The average.
Example
[1.0; 2.0; 3.0] |> Seq.average
module Seq
from Microsoft.FSharp.Collections
val average: source: 'T seq -> 'T (requires member (+) and member DivideByInt and member Zero)
Evaluates to 2.0
Example
module Seq
from Microsoft.FSharp.Collections
val average: source: 'T seq -> 'T (requires member (+) and member DivideByInt and member Zero)
Throws ArgumentException
|
Seq.averageBy projection source
Full Usage:
Seq.averageBy projection source
Parameters:
projection
:
'T -> ^U
-
A function applied to transform each element of the sequence.
source
:
'T seq
-
The input sequence.
Returns:
^U
The average.
Modifiers:
inline
Type parameters:
'T, ^U (requires (static member op_Addition : ^U * ^U -> ^U) and (static member DivideByInt : ^U * Microsoft.FSharp.Core.int -> ^U) and (static member get_Zero : -> ^U))
|
Returns the average of the results generated by applying the function to each element
of the sequence.
The elements are averaged using the + operator, DivideByInt method and Zero property
associated with the generated type. This is an O(n) operation, where n is the length of the sequence.
-
projection
:
'T -> ^U
-
A function applied to transform each element of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
^U
-
The average.
Example
type Foo = { Bar: float }
let input = seq { {Bar = 2.0}; {Bar = 4.0} }
input |> Seq.averageBy (fun foo -> foo.Bar)
type Foo =
{ Bar: float }
Multiple items
val float: value: 'T -> float (requires member op_Explicit)
--------------------
type float = System.Double
--------------------
type float<'Measure> =
float
val input: Foo seq
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
module Seq
from Microsoft.FSharp.Collections
val averageBy: projection: ('T -> 'U) -> source: 'T seq -> 'U (requires member (+) and member DivideByInt and member Zero)
val foo: Foo
Foo.Bar: float
Evaluates to 3.0
Example
type Foo = { Bar: float }
Seq.empty |> Seq.averageBy (fun (foo: Foo) -> foo.Bar)
type Foo =
{ Bar: float }
Multiple items
val float: value: 'T -> float (requires member op_Explicit)
--------------------
type float = System.Double
--------------------
type float<'Measure> =
float
module Seq
from Microsoft.FSharp.Collections
val empty<'T> : 'T seq
val averageBy: projection: ('T -> 'U) -> source: 'T seq -> 'U (requires member (+) and member DivideByInt and member Zero)
val foo: Foo
Foo.Bar: float
Throws ArgumentException
|
Seq.cache source
Full Usage:
Seq.cache source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Returns a sequence that corresponds to a cached version of the input sequence.
The result sequence will have the same elements as the input sequence. The result
can be enumerated multiple times. The input sequence will be enumerated at most
once and only as far as is necessary. Caching a sequence is typically useful when repeatedly
evaluating items in the original sequence is computationally expensive or if
iterating the sequence causes side-effects that the user does not want to be
repeated multiple times.
Enumeration of the result sequence is thread safe in the sense that multiple independent IEnumerator
values may be used simultaneously from different threads (accesses to
the internal lookaside table are thread safe). Each individual IEnumerator
is not typically thread safe and should not be accessed concurrently.
Once enumeration of the input sequence has started,
it's enumerator will be kept live by this object until the enumeration has completed.
At that point, the enumerator will be disposed.
The enumerator may be disposed and underlying cache storage released by
converting the returned sequence object to type IDisposable, and calling the Dispose method
on this object. The sequence object may then be re-enumerated and a fresh enumerator will
be used.
Caching requires O(k) space for k accessed elements.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
let fibSeq =(0, 1) |> Seq.unfold (fun (a,b) -> Some(a + b, (b, a + b)))
let fibSeq3 = fibSeq |> Seq.take 3 |> Seq.cache
fibSeq3
val fibSeq: int seq
module Seq
from Microsoft.FSharp.Collections
val unfold:
generator: ('State -> ('T * 'State) option) ->
state: 'State ->
'T seq
val a: int
val b: int
union case Option.Some: Value: 'T -> Option<'T>
val fibSeq3: int seq
val take: count: int -> source: 'T seq -> 'T seq
val cache: source: 'T seq -> 'T seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 3 },
and it will not do the calculation again when called.
|
Seq.cast source
Full Usage:
Seq.cast source
Parameters:
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Wraps a loosely-typed System.Collections sequence as a typed sequence.
The use of this function usually requires a type annotation.
An incorrect type annotation may result in runtime type
errors.
Individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
source
:
IEnumerable
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
[box 1; box 2; box 3] |> Seq.cast<int>
val box: value: 'T -> objnull
module Seq
from Microsoft.FSharp.Collections
val cast: source: System.Collections.IEnumerable -> 'T seq
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
int
Evaluates to a sequence yielding the same results as seq { 1; 2; 3 }, explicitly typed as seq<int>.
|
Seq.choose chooser source
Full Usage:
Seq.choose chooser source
Parameters:
chooser
:
'T -> 'U option
-
A function to transform items of type T into options of type U.
source
:
'T seq
-
The input sequence of type T.
Returns:
'U seq
The result sequence.
Type parameters:
'T, 'U
|
Applies the given function to each element of the sequence. Returns
a sequence comprised of the results "x" for each element where
the function returns Some(x).
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not
be accessed concurrently. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
chooser
:
'T -> 'U option
-
A function to transform items of type T into options of type U.
-
source
:
'T seq
-
The input sequence of type T.
-
Returns:
'U seq
-
The result sequence.
Example
[Some 1; None; Some 2] |> Seq.choose id
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
module Seq
from Microsoft.FSharp.Collections
val choose: chooser: ('T -> 'U option) -> source: 'T seq -> 'U seq
val id: x: 'T -> 'T
Evaluates to a sequence yielding the same results as seq { 1; 2 }
Example
[1; 2; 3] |> Seq.choose (fun n -> if n % 2 = 0 then Some n else None)
module Seq
from Microsoft.FSharp.Collections
val choose: chooser: ('T -> 'U option) -> source: 'T seq -> 'U seq
val n: int
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
Evaluates to a sequence yielding the same results as seq { 2 }
|
Seq.chunkBySize chunkSize source
Full Usage:
Seq.chunkBySize chunkSize source
Parameters:
chunkSize
:
int
-
The maximum size of each chunk.
source
:
'T seq
-
The input sequence.
Returns:
'T array seq
The sequence divided into chunks.
Type parameters:
'T
|
Divides the input sequence into chunks of size at most chunkSize.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
chunkSize
:
int
-
The maximum size of each chunk.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T array seq
-
The sequence divided into chunks.
Example
[1; 2; 3] |> Seq.chunkBySize 2
module Seq
from Microsoft.FSharp.Collections
val chunkBySize: chunkSize: int -> source: 'T seq -> 'T array seq
Evaluates to a sequence yielding the same results as seq { [|1; 2|]; [|3|] }
Example
[1; 2; 3] |> Seq.chunkBySize -2
module Seq
from Microsoft.FSharp.Collections
val chunkBySize: chunkSize: int -> source: 'T seq -> 'T array seq
Throws ArgumentException
|
Seq.collect mapping source
Full Usage:
Seq.collect mapping source
Parameters:
mapping
:
'T -> 'Collection
-
A function to transform elements of the input sequence into the sequences
that will then be concatenated.
source
:
'T seq
-
The input sequence.
Returns:
'U seq
The result sequence.
Type parameters:
'T, 'Collection, 'U (requires :> 'U Microsoft.FSharp.Collections.seq)
|
Applies the given function to each element of the sequence and concatenates all the
results.
Remember sequence is lazy, effects are delayed until it is enumerated. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
mapping
:
'T -> 'Collection
-
A function to transform elements of the input sequence into the sequences
that will then be concatenated.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'U seq
-
The result sequence.
Example
type Foo = { Bar: int seq }
let input = seq { {Bar = [1; 2]}; {Bar = [3; 4]} }
input |> Seq.collect (fun foo -> foo.Bar)
type Foo =
{ Bar: int seq }
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
int
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
val input: Foo seq
module Seq
from Microsoft.FSharp.Collections
val collect: mapping: ('T -> #seq<'U>) -> source: 'T seq -> 'U seq
val foo: Foo
Foo.Bar: int seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 3; 4 }
Example
let input = [[1; 2]; [3; 4]]
input |> Seq.collect id
val input: int list list
module Seq
from Microsoft.FSharp.Collections
val collect: mapping: ('T -> #seq<'U>) -> source: 'T seq -> 'U seq
val id: x: 'T -> 'T
Evaluates to a sequence yielding the same results as seq { 1; 2; 3; 4 }
|
Seq.compareWith comparer source1 source2
Full Usage:
Seq.compareWith comparer source1 source2
Parameters:
comparer
:
'T -> 'T -> int
-
A function that takes an element from each sequence and returns an int.
If it evaluates to a non-zero value iteration is stopped and that value is returned.
source1
:
'T seq
-
The first input sequence.
source2
:
'T seq
-
The second input sequence.
Returns:
int
Returns the first non-zero result from the comparison function. If the end of a sequence
is reached it returns a -1 if the first sequence is shorter and a 1 if the second sequence
is shorter.
Type parameters:
'T
|
Compares two sequences using the given comparison function, element by element.
This is an O(min(n,m)) operation, where n and m are the lengths of the sequences.
-
comparer
:
'T -> 'T -> int
-
A function that takes an element from each sequence and returns an int.
If it evaluates to a non-zero value iteration is stopped and that value is returned.
-
source1
:
'T seq
-
The first input sequence.
-
source2
:
'T seq
-
The second input sequence.
-
Returns:
int
-
Returns the first non-zero result from the comparison function. If the end of a sequence
is reached it returns a -1 if the first sequence is shorter and a 1 if the second sequence
is shorter.
Example
let closerToNextDozen a b =
(a % 12).CompareTo(b % 12)
let input1 = [1; 10]
let input2 = [1; 10]
(input1, input2) ||> Seq.compareWith closerToNextDozen
val closerToNextDozen: a: int -> b: int -> int
val a: int
val b: int
val input1: int list
val input2: int list
module Seq
from Microsoft.FSharp.Collections
val compareWith:
comparer: ('T -> 'T -> int) ->
source1: 'T seq ->
source2: 'T seq ->
int
Evaluates to 0
Example
let closerToNextDozen a b =
(a % 12).CompareTo(b % 12)
let input1 = [1; 5]
let input2 = [1; 8]
(input1, input2) ||> Seq.compareWith closerToNextDozen
val closerToNextDozen: a: int -> b: int -> int
val a: int
val b: int
val input1: int list
val input2: int list
module Seq
from Microsoft.FSharp.Collections
val compareWith:
comparer: ('T -> 'T -> int) ->
source1: 'T seq ->
source2: 'T seq ->
int
Evaluates to -1
Example
let closerToNextDozen a b =
(a % 12).CompareTo(b % 12)
let input1 = [1; 11]
let input2 = [1; 13]
(input1, input2) ||> Seq.compareWith closerToNextDozen
val closerToNextDozen: a: int -> b: int -> int
val a: int
val b: int
val input1: int list
val input2: int list
module Seq
from Microsoft.FSharp.Collections
val compareWith:
comparer: ('T -> 'T -> int) ->
source1: 'T seq ->
source2: 'T seq ->
int
Evaluates to 1
Example
let closerToNextDozen a b =
(a % 12).CompareTo(b % 12)
let input1 = [1; 2]
let input2 = [1]
(input1, input2) ||> Seq.compareWith closerToNextDozen
val closerToNextDozen: a: int -> b: int -> int
val a: int
val b: int
val input1: int list
val input2: int list
module Seq
from Microsoft.FSharp.Collections
val compareWith:
comparer: ('T -> 'T -> int) ->
source1: 'T seq ->
source2: 'T seq ->
int
Evaluates to 1
Example
let closerToNextDozen a b =
(a % 12).CompareTo(b % 12)
let input1 = [1]
let input2 = [1; 2]
(input1, input2) ||> Seq.compareWith closerToNextDozen
val closerToNextDozen: a: int -> b: int -> int
val a: int
val b: int
val input1: int list
val input2: int list
module Seq
from Microsoft.FSharp.Collections
val compareWith:
comparer: ('T -> 'T -> int) ->
source1: 'T seq ->
source2: 'T seq ->
int
Evaluates to -1
|
Seq.concat sources
Full Usage:
Seq.concat sources
Parameters:
sources
:
'Collection seq
-
The input enumeration-of-enumerations.
Returns:
'T seq
The result sequence.
Type parameters:
'Collection, 'T (requires :> 'T Microsoft.FSharp.Collections.seq)
|
Combines the given enumeration-of-enumerations as a single concatenated
enumeration.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Sequence construction is O(1). Enumeration is O(n), where n is the total number of elements.
-
sources
:
'Collection seq
-
The input enumeration-of-enumerations.
-
Returns:
'T seq
-
The result sequence.
Example
let inputs = [[1; 2]; [3]; [4; 5]]
inputs |> Seq.concat
val inputs: int list list
module Seq
from Microsoft.FSharp.Collections
val concat: sources: #seq<'T> seq -> 'T seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 3; 4; 5 }
|
Seq.contains value source
Full Usage:
Seq.contains value source
Parameters:
value
:
'T
-
The value to locate in the input sequence.
source
:
'T seq
-
The input sequence.
Returns:
bool
True if the input sequence contains the specified element; false otherwise.
Modifiers:
inline
Type parameters:
'T (requires equality)
|
Tests if the sequence contains the specified element.
This is an O(n) operation, where n is the length of the sequence.
-
value
:
'T
-
The value to locate in the input sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
bool
-
True if the input sequence contains the specified element; false otherwise.
Example
[1; 2] |> Seq.contains 2 // evaluates to true
[1; 2] |> Seq.contains 5 // evaluates to false
module Seq
from Microsoft.FSharp.Collections
val contains: value: 'T -> source: 'T seq -> bool (requires equality)
|
Seq.countBy projection source
Full Usage:
Seq.countBy projection source
Parameters:
projection
:
'T -> 'Key
-
A function transforming each item of the input sequence into a key to be
compared against the others.
source
:
'T seq
-
The input sequence.
Returns:
('Key * int) seq
The result sequence.
Type parameters:
'T, 'Key (requires equality)
|
Applies a key-generating function to each element of a sequence and returns a sequence yielding unique
keys and their number of occurrences in the original sequence.
Note that this function returns a sequence that digests the whole initial sequence as soon as
that sequence is iterated. As a result this function should not be used with
large or infinite sequences. The function makes no assumption on the ordering of the original
sequence. This is an O(n) operation, where n is the length of the sequence.
-
projection
:
'T -> 'Key
-
A function transforming each item of the input sequence into a key to be
compared against the others.
-
source
:
'T seq
-
The input sequence.
-
Returns:
('Key * int) seq
-
The result sequence.
Example
type Foo = { Bar: string }
let inputs = [{Bar = "a"}; {Bar = "b"}; {Bar = "a"}]
inputs |> Seq.countBy (fun foo -> foo.Bar)
type Foo =
{ Bar: string }
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
val inputs: Foo list
module Seq
from Microsoft.FSharp.Collections
val countBy: projection: ('T -> 'Key) -> source: 'T seq -> ('Key * int) seq (requires equality)
val foo: Foo
Foo.Bar: string
Evaluates to a sequence yielding the same results as seq { ("a", 2); ("b", 1) }
|
Seq.delay generator
Full Usage:
Seq.delay generator
Parameters:
generator
:
unit -> 'T seq
-
The generating function for the sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Returns a sequence that is built from the given delayed specification of a
sequence.
The input function is evaluated each time an IEnumerator for the sequence
is requested. Sequence construction is O(1). Enumeration cost depends on the generated sequence.
-
generator
:
unit -> 'T seq
-
The generating function for the sequence.
-
Returns:
'T seq
-
The result sequence.
Example
Seq.delay (fun () -> Seq.ofList [1; 2; 3])
module Seq
from Microsoft.FSharp.Collections
val delay: generator: (unit -> 'T seq) -> 'T seq
val ofList: source: 'T list -> 'T seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 3 }, executing
the generator function every time is consumed.
|
Seq.distinct source
Full Usage:
Seq.distinct source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T (requires equality)
|
Returns a sequence that contains no duplicate entries according to generic hash and
equality comparisons on the entries.
If an element occurs multiple times in the sequence then the later occurrences are discarded.
This operation requires O(k) space where k is the number of distinct elements seen.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
[1; 1; 2; 3] |> Seq.distinct
module Seq
from Microsoft.FSharp.Collections
val distinct: source: 'T seq -> 'T seq (requires equality)
Evaluates to a sequence yielding the same results as seq { 1; 2; 3 }
|
Seq.distinctBy projection source
Full Usage:
Seq.distinctBy projection source
Parameters:
projection
:
'T -> 'Key
-
A function transforming the sequence items into comparable keys.
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T, 'Key (requires equality)
|
Returns a sequence 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 sequence then the later occurrences are discarded.
This operation requires O(k) space where k is the number of distinct keys seen.
-
projection
:
'T -> 'Key
-
A function transforming the sequence items into comparable keys.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
let inputs = [{Bar = 1 };{Bar = 1}; {Bar = 2}; {Bar = 3}]
inputs |> Seq.distinctBy (fun foo -> foo.Bar)
val inputs: 'a list
module Seq
from Microsoft.FSharp.Collections
val distinctBy: projection: ('T -> 'Key) -> source: 'T seq -> 'T seq (requires equality)
val foo: obj
Evaluates to a sequence yielding the same results as seq { { Bar = 1 }; { Bar = 2 }; { Bar = 3 } }
|
Seq.empty
Full Usage:
Seq.empty
Returns:
'T seq
An empty sequence.
Type parameters:
'T
|
Creates an empty sequence.
This is an O(1) operation.
-
Returns:
'T seq
-
An empty sequence.
Example
Seq.empty // Evaluates to seq { }
module Seq
from Microsoft.FSharp.Collections
val empty<'T> : 'T seq
|
Seq.exactlyOne source
Full Usage:
Seq.exactlyOne source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T
The only element of the sequence.
Type parameters:
'T
|
Returns the only element of the sequence.
This is an O(1) operation.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The only element of the sequence.
Example
let inputs = ["banana"]
inputs |> Seq.exactlyOne
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val exactlyOne: source: 'T seq -> 'T
Evaluates to banana
Example
let inputs = ["pear"; "banana"]
inputs |> Seq.exactlyOne
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val exactlyOne: source: 'T seq -> 'T
Throws ArgumentException
Example
module Seq
from Microsoft.FSharp.Collections
val exactlyOne: source: 'T seq -> 'T
Throws ArgumentException
|
Seq.except itemsToExclude source
Full Usage:
Seq.except itemsToExclude source
Parameters:
itemsToExclude
:
'T seq
-
A sequence whose elements that also occur in the second sequence will cause those elements to be
removed from the returned sequence.
source
:
'T seq
-
A sequence whose elements that are not also in first will be returned.
Returns:
'T seq
A sequence that contains the set difference of the elements of two sequences.
Type parameters:
'T (requires equality)
|
Returns a new sequence with the distinct elements of the second sequence which do not appear in the first sequence,
using generic hash and equality comparisons to compare values.
Note that this function returns a sequence that digests the whole of the first input sequence as soon as
the result sequence is iterated. As a result this function should not be used with
large or infinite sequences in the first parameter. The function makes no assumption on the ordering of the first input
sequence. This is an O(n+m) operation using hash-based exclusion.
-
itemsToExclude
:
'T seq
-
A sequence whose elements that also occur in the second sequence will cause those elements to be
removed from the returned sequence.
-
source
:
'T seq
-
A sequence whose elements that are not also in first will be returned.
-
Returns:
'T seq
-
A sequence that contains the set difference of the elements of two sequences.
Example
let original = [1; 2; 3; 4; 5]
let itemsToExclude = [1; 3; 5]
original |> Seq.except itemsToExclude
val original: int list
val itemsToExclude: int list
module Seq
from Microsoft.FSharp.Collections
val except: itemsToExclude: 'T seq -> source: 'T seq -> 'T seq (requires equality)
Evaluates to a sequence yielding the same results as seq { 2; 4 }
|
Seq.exists predicate source
Full Usage:
Seq.exists predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test each item of the input sequence.
source
:
'T seq
-
The input sequence.
Returns:
bool
True if any result from the predicate is true; false otherwise.
Type parameters:
'T
|
Tests if any element of the sequence satisfies the given predicate.
The predicate is applied to the elements of the input sequence. If any application
returns true then the overall result is true and no further elements are tested.
Otherwise, false is returned. This is an O(n) operation in the worst case, where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test each item of the input sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
bool
-
True if any result from the predicate is true; false otherwise.
Example
let input = [1; 2; 3; 4; 5]
input |> Seq.exists (fun elm -> elm % 4 = 0)
val input: int list
module Seq
from Microsoft.FSharp.Collections
val exists: predicate: ('T -> bool) -> source: 'T seq -> bool
val elm: int
Evaluates to true
Example
let input = [1; 2; 3; 4; 5]
input |> Seq.exists (fun elm -> elm % 6 = 0)
val input: int list
module Seq
from Microsoft.FSharp.Collections
val exists: predicate: ('T -> bool) -> source: 'T seq -> bool
val elm: int
Evaluates to false
|
Seq.exists2 predicate source1 source2
Full Usage:
Seq.exists2 predicate source1 source2
Parameters:
predicate
:
'T1 -> 'T2 -> bool
-
A function to test each pair of items from the input sequences.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Returns:
bool
True if any result from the predicate is true; false otherwise.
Type parameters:
'T1, 'T2
|
Tests if any pair of corresponding elements of the input sequences satisfies the given predicate.
The predicate is applied to matching elements in the two sequences up to the lesser of the
two lengths of the collections. If any application returns true then the overall result is
true and no further elements are tested. Otherwise, false is returned. If one sequence is shorter than
the other then the remaining elements of the longer sequence are ignored. This is an O(n) operation in the worst case, where n is the length of the sequences.
-
predicate
:
'T1 -> 'T2 -> bool
-
A function to test each pair of items from the input sequences.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
Returns:
bool
-
True if any result from the predicate is true; false otherwise.
Example
let inputs1 = [1; 2]
let inputs2 = [1; 2; 0]
(inputs1, inputs2) ||> Seq.exists2 (fun a b -> a > b)
val inputs1: int list
val inputs2: int list
module Seq
from Microsoft.FSharp.Collections
val exists2:
predicate: ('T1 -> 'T2 -> bool) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
bool
val a: int
val b: int
Evaluates to false
Example
let inputs1 = [1; 4]
let inputs2 = [1; 3; 5]
(inputs1, inputs2) ||> Seq.exists2 (fun a b -> a > b)
val inputs1: int list
val inputs2: int list
module Seq
from Microsoft.FSharp.Collections
val exists2:
predicate: ('T1 -> 'T2 -> bool) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
bool
val a: int
val b: int
Evaluates to true
|
Seq.filter predicate source
Full Usage:
Seq.filter predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test whether each item in the input sequence should be included in the output.
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Returns a new collection containing only the elements of the collection
for which the given predicate returns "true". This is a synonym for Seq.where.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
Remember sequence is lazy, effects are delayed until it is enumerated. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test whether each item in the input sequence should be included in the output.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
let inputs = [1; 2; 3; 4]
inputs |> Seq.filter (fun elm -> elm % 2 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val filter: predicate: ('T -> bool) -> source: 'T seq -> 'T seq
val elm: int
Evaluates to a sequence yielding the same results as seq { 2; 4 }
|
Seq.find predicate source
Full Usage:
Seq.find predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test whether an item in the sequence should be returned.
source
:
'T seq
-
The input sequence.
Returns:
'T
The first element for which the predicate returns True.
Type parameters:
'T
|
Returns the first element for which the given function returns True.
This is an O(n) operation in the worst case, where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test whether an item in the sequence should be returned.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The first element for which the predicate returns True.
Example
let inputs = [1; 2; 3]
inputs |> Seq.find (fun elm -> elm % 2 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val find: predicate: ('T -> bool) -> source: 'T seq -> 'T
val elm: int
Evaluates to 2
Example
let inputs = [1; 2; 3]
inputs |> Seq.find (fun elm -> elm % 6 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val find: predicate: ('T -> bool) -> source: 'T seq -> 'T
val elm: int
Throws KeyNotFoundException
|
Seq.findBack predicate source
Full Usage:
Seq.findBack predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test whether an item in the sequence should be returned.
source
:
'T seq
-
The input sequence.
Returns:
'T
The last element for which the predicate returns True.
Type parameters:
'T
|
Returns the last element for which the given function returns True.
This function digests the whole initial sequence as soon as it is called. As a
result this function should not be used with large or infinite sequences. This is an O(n) operation in the worst case, where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test whether an item in the sequence should be returned.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The last element for which the predicate returns True.
Example
let inputs = [2; 3; 4]
inputs |> Seq.findBack (fun elm -> elm % 2 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val findBack: predicate: ('T -> bool) -> source: 'T seq -> 'T
val elm: int
Evaluates to 4
Example
let inputs = [2; 3; 4]
inputs |> Seq.findBack (fun elm -> elm % 6 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val findBack: predicate: ('T -> bool) -> source: 'T seq -> 'T
val elm: int
Throws KeyNotFoundException
|
Seq.findIndex predicate source
Full Usage:
Seq.findIndex predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test whether the index of a particular element should be returned.
source
:
'T seq
-
The input sequence.
Returns:
int
The index of the first element for which the predicate returns True.
Type parameters:
'T
|
Returns the index of the first element for which the given function returns True.
This is an O(n) operation in the worst case, where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test whether the index of a particular element should be returned.
-
source
:
'T seq
-
The input sequence.
-
Returns:
int
-
The index of the first element for which the predicate returns True.
Example
let inputs = [1; 2; 3; 4; 5]
inputs |> Seq.findIndex (fun elm -> elm % 2 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val findIndex: predicate: ('T -> bool) -> source: 'T seq -> int
val elm: int
Evaluates to 1
Example
let inputs = [1; 2; 3; 4; 5]
inputs |> Seq.findIndex (fun elm -> elm % 6 = 0)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val findIndex: predicate: ('T -> bool) -> source: 'T seq -> int
val elm: int
Throws KeyNotFoundException
|
Seq.findIndexBack predicate source
Full Usage:
Seq.findIndexBack predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test whether the index of a particular element should be returned.
source
:
'T seq
-
The input sequence.
Returns:
int
The index of the last element for which the predicate returns True.
Type parameters:
'T
|
Returns the index of the last element for which the given function returns True.
This function digests the whole initial sequence as soon as it is called. As a
result this function should not be used with large or infinite sequences. This is an O(n) operation in the worst case, where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test whether the index of a particular element should be returned.
-
source
:
'T seq
-
The input sequence.
-
Returns:
int
-
The index of the last element for which the predicate returns True.
Example
let input = [1; 2; 3; 4; 5]
input |> Seq.findIndex (fun elm -> elm % 2 = 0)
val input: int list
module Seq
from Microsoft.FSharp.Collections
val findIndex: predicate: ('T -> bool) -> source: 'T seq -> int
val elm: int
Evaluates to 3
Example
let input = [1; 2; 3; 4; 5]
input |> Seq.findIndex (fun elm -> elm % 6 = 0)
val input: int list
module Seq
from Microsoft.FSharp.Collections
val findIndex: predicate: ('T -> bool) -> source: 'T seq -> int
val elm: int
Throws KeyNotFoundException
|
Seq.fold folder state source
Full Usage:
Seq.fold folder state source
Parameters:
folder
:
'State -> 'T -> 'State
-
A function that updates the state with each element from the sequence.
state
:
'State
-
The initial state.
source
:
'T seq
-
The input sequence.
Returns:
'State
The state object after the folding function is applied to each element of the sequence.
Type parameters:
'T, 'State
|
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
This is an O(n) operation, where n is the length of the sequence.
-
folder
:
'State -> 'T -> 'State
-
A function that updates the state with each element from the sequence.
-
state
:
'State
-
The initial state.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'State
-
The state object after the folding function is applied to each element of the sequence.
Example
type Charge =
| In of int
| Out of int
let inputs = [In 1; Out 2; In 3]
(0, inputs) ||> Seq.fold (fun acc charge ->
match charge with
| In i -> acc + i
| Out o -> acc - o)
type Charge =
| In of int
| Out of int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
int
val inputs: Charge list
union case Charge.In: int -> Charge
union case Charge.Out: int -> Charge
module Seq
from Microsoft.FSharp.Collections
val fold<'T,'State> :
folder: ('State -> 'T -> 'State) ->
state: 'State ->
source: 'T seq ->
'State
val acc: int
val charge: Charge
val i: int
val o: int
Evaluates to 2
|
Seq.fold2 folder state source1 source2
Full Usage:
Seq.fold2 folder state source1 source2
Parameters:
folder
:
'State -> 'T1 -> 'T2 -> 'State
-
The function to update the state given the input elements.
state
:
'State
-
The initial state.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Returns:
'State
The final state value.
Type parameters:
'T1, 'T2, 'State
|
Applies a function to corresponding elements of two collections, threading an accumulator argument
through the computation.
The two sequences need not have equal lengths:
when one sequence is exhausted any remaining elements in the other sequence are ignored.
If the input function is f and the elements are i0...iN and j0...jN
then computes f (... (f s i0 j0)...) iN jN. This is an O(n) operation, where n is the length of the sequences.
-
folder
:
'State -> 'T1 -> 'T2 -> 'State
-
The function to update the state given the input elements.
-
state
:
'State
-
The initial state.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
Returns:
'State
-
The final state value.
Example
type CoinToss = Head | Tails
let data1 = [Tails; Head; Tails]
let data2 = [Tails; Head; Head]
(0, data1, data2) |||> Seq.fold2 (fun acc a b ->
match (a, b) with
| Head, Head -> acc + 1
| Tails, Tails -> acc + 1
| _ -> acc - 1)
type CoinToss =
| Head
| Tails
val data1: CoinToss list
union case CoinToss.Tails: CoinToss
union case CoinToss.Head: CoinToss
val data2: CoinToss list
module Seq
from Microsoft.FSharp.Collections
val fold2<'T1,'T2,'State> :
folder: ('State -> 'T1 -> 'T2 -> 'State) ->
state: 'State ->
source1: 'T1 seq ->
source2: 'T2 seq ->
'State
val acc: int
val a: CoinToss
val b: CoinToss
Evaluates to 1
|
Seq.foldBack folder source state
Full Usage:
Seq.foldBack folder source state
Parameters:
folder
:
'T -> 'State -> 'State
-
The function to update the state given the input elements.
source
:
'T seq
-
The input sequence.
state
:
'State
-
The initial state.
Returns:
'State
The state object after the folding function is applied to each element of the sequence.
Type parameters:
'T, 'State
|
Applies a function to each element of the collection, 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)...)
This function consumes the whole input sequence before returning the result. This is an O(n) operation, where n is the length of the sequence.
-
folder
:
'T -> 'State -> 'State
-
The function to update the state given the input elements.
-
source
:
'T seq
-
The input sequence.
-
state
:
'State
-
The initial state.
-
Returns:
'State
-
The state object after the folding function is applied to each element of the sequence.
Example
type Count =
{ Positive: int
Negative: int
Text: string }
let sequence = [1; 0; -1; -2; 3]
let initialState = {Positive = 0; Negative = 0; Text = ""}
(sequence, initialState) ||> Seq.foldBack (fun a acc ->
let text = acc.Text + " " + string a
if a >= 0 then
{ acc with
Positive = acc.Positive + 1
Text = text }
else
{ acc with
Negative = acc.Negative + 1
Text = text })
type Count =
{
Positive: int
Negative: int
Text: string
}
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
int
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
val sequence: int list
val initialState: Count
module Seq
from Microsoft.FSharp.Collections
val foldBack:
folder: ('T -> 'State -> 'State) ->
source: 'T seq ->
state: 'State ->
'State
val a: int
val acc: Count
val text: string
Count.Text: string
Count.Positive: int
Count.Negative: int
Evaluates to
{ Positive = 2
Negative = 3
Text = " 3 -2 -1 0 1" }
|
Seq.foldBack2 folder source1 source2 state
Full Usage:
Seq.foldBack2 folder source1 source2 state
Parameters:
folder
:
'T1 -> 'T2 -> 'State -> 'State
-
The function to update the state given the input elements.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
state
:
'State
-
The initial state.
Returns:
'State
The final state value.
Type parameters:
'T1, 'T2, 'State
|
Applies a function to corresponding elements of two collections, starting from the end of the shorter collection,
threading an accumulator argument through the computation. The two sequences need not have equal lengths.
If the input function is f and the elements are i0...iN and j0...jM, N < M
then computes f i0 j0 (... (f iN jN s)...).
This function consumes the whole of both inputs sequences before returning the result. As a
result this function should not be used with large or infinite sequences. This is an O(n) operation, where n is the length of the sequences.
-
folder
:
'T1 -> 'T2 -> 'State -> 'State
-
The function to update the state given the input elements.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
state
:
'State
-
The initial state.
-
Returns:
'State
-
The final state value.
Example
type Count =
{ Positive: int
Negative: int
Text: string }
let inputs1 = [-1; -2; -3]
let inputs2 = [3; 2; 1; 0]
let initialState = {Positive = 0; Negative = 0; Text = ""}
(inputs1, inputs2, initialState) |||> Seq.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 }
)
type Count =
{
Positive: int
Negative: int
Text: string
}
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
int
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
val inputs1: int list
val inputs2: int list
val initialState: Count
module Seq
from Microsoft.FSharp.Collections
val foldBack2:
folder: ('T1 -> 'T2 -> 'State -> 'State) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
state: 'State ->
'State
val a: int
val b: int
val acc: Count
val text: string
Count.Text: string
Count.Positive: int
Count.Negative: int
Evaluates to
{ Positive = 2
Negative = 1
Text = " (-3,1) (-2,2) (-1,3)" }
|
Seq.forall predicate source
Full Usage:
Seq.forall predicate source
Parameters:
predicate
:
'T -> bool
-
A function to test an element of the input sequence.
source
:
'T seq
-
The input sequence.
Returns:
bool
True if every element of the sequence satisfies the predicate; false otherwise.
Type parameters:
'T
|
Tests if all elements of the sequence satisfy the given predicate.
The predicate is applied to the elements of the input sequence. If any application
returns false then the overall result is false and no further elements are tested.
Otherwise, true is returned. This is an O(n) operation in the worst case, where n is the length of the sequence.
-
predicate
:
'T -> bool
-
A function to test an element of the input sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
bool
-
True if every element of the sequence satisfies the predicate; false otherwise.
Example
let isEven a = a % 2 = 0
[2; 42] |> Seq.forall isEven // evaluates to true
[1; 2] |> Seq.forall isEven // evaluates to false
val isEven: a: int -> bool
val a: int
module Seq
from Microsoft.FSharp.Collections
val forall: predicate: ('T -> bool) -> source: 'T seq -> bool
|
Seq.forall2 predicate source1 source2
Full Usage:
Seq.forall2 predicate source1 source2
Parameters:
predicate
:
'T1 -> 'T2 -> bool
-
A function to test pairs of elements from the input sequences.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Returns:
bool
True if all pairs satisfy the predicate; false otherwise.
Type parameters:
'T1, 'T2
|
Tests the all pairs of elements drawn from the two sequences satisfy the
given predicate. If one sequence is shorter than
the other then the remaining elements of the longer sequence are ignored.
This is an O(n) operation in the worst case, where n is the length of the sequences.
-
predicate
:
'T1 -> 'T2 -> bool
-
A function to test pairs of elements from the input sequences.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
Returns:
bool
-
True if all pairs satisfy the predicate; false otherwise.
Example
let inputs1 = [1; 2; 3; 4; 5; 6]
let inputs2 = [1; 2; 3; 4; 5]
(inputs1, inputs2) ||> Seq.forall2 (=)
val inputs1: int list
val inputs2: int list
module Seq
from Microsoft.FSharp.Collections
val forall2:
predicate: ('T1 -> 'T2 -> bool) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
bool
Evaluates to true.
Example
let items1 = [2017; 1; 1]
let items2 = [2019; 19; 8]
(items1, items2) ||> Seq.forall2 (=)
val items1: int list
val items2: int list
module Seq
from Microsoft.FSharp.Collections
val forall2:
predicate: ('T1 -> 'T2 -> bool) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
bool
Evaluates to false.
|
Seq.groupBy projection source
Full Usage:
Seq.groupBy projection source
Parameters:
projection
:
'T -> 'Key
-
A function that transforms an element of the sequence into a comparable key.
source
:
'T seq
-
The input sequence.
Returns:
('Key * 'T seq) seq
The result sequence.
Type parameters:
'T, 'Key (requires equality)
|
Applies a key-generating function to each element of a sequence and yields a sequence of
unique keys. Each unique key contains a sequence of all elements that match
to this key.
This function returns a sequence that digests the whole initial sequence as soon as
that sequence is iterated. As a result this function should not be used with
large or infinite sequences. The function makes no assumption on the ordering of the original
sequence. This is an O(n) operation, where n is the length of the sequence.
-
projection
:
'T -> 'Key
-
A function that transforms an element of the sequence into a comparable key.
-
source
:
'T seq
-
The input sequence.
-
Returns:
('Key * 'T seq) seq
-
The result sequence.
Example
let inputs = [1; 2; 3; 4; 5]
inputs |> Seq.groupBy (fun n -> n % 2)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val groupBy: projection: ('T -> 'Key) -> source: 'T seq -> ('Key * 'T seq) seq (requires equality)
val n: int
Evaluates to a sequence yielding the same results as seq { (1, seq { 1; 3; 5 }); (0, seq { 2; 4 }) }
|
Seq.head source
Full Usage:
Seq.head source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T
The first element of the sequence.
Type parameters:
'T
|
Returns the first element of the sequence.
This is an O(1) operation.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The first element of the sequence.
Example
let inputs = ["banana"; "pear"]
inputs |> Seq.head
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val head: source: 'T seq -> 'T
Evaluates to banana
Example
module Seq
from Microsoft.FSharp.Collections
val head: source: 'T seq -> 'T
Throws ArgumentException
|
Seq.indexed source
Full Usage:
Seq.indexed source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
(int * 'T) seq
The result sequence.
Type parameters:
'T
|
Builds a new collection whose elements are the corresponding elements of the input collection
paired with the integer index (from 0) of each element.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
(int * 'T) seq
-
The result sequence.
Example
["a"; "b"; "c"] |> Seq.indexed
module Seq
from Microsoft.FSharp.Collections
val indexed: source: 'T seq -> (int * 'T) seq
Evaluates to a sequence yielding the same results as seq { (0, "a"); (1, "b"); (2, "c") }
|
Seq.init count initializer
Full Usage:
Seq.init count initializer
Parameters:
count
:
int
-
The maximum number of items to generate for the sequence.
initializer
:
int -> 'T
-
A function that generates an item in the sequence from a given index.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Generates a new sequence which, when iterated, will return successive
elements by calling the given function, up to the given count. The results of calling the function
will not be saved, that is the function will be reapplied as necessary to
regenerate the elements. The function is passed the index of the item being
generated. To cache the results, see Seq.Cache.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
Construction of the sequence object is an O(1) operation. Each enumeration is an O(n) operation, where n is the count,
invoking the initializer function once per element.
-
count
:
int
-
The maximum number of items to generate for the sequence.
-
initializer
:
int -> 'T
-
A function that generates an item in the sequence from a given index.
-
Returns:
'T seq
-
The result sequence.
Example
Seq.init 4 (fun v -> v + 5)
module Seq
from Microsoft.FSharp.Collections
val init: count: int -> initializer: (int -> 'T) -> 'T seq
val v: int
Evaluates to a sequence yielding the same results as seq { 5; 6; 7; 8 }
Example
Seq.init -5 (fun v -> v + 5)
module Seq
from Microsoft.FSharp.Collections
val init: count: int -> initializer: (int -> 'T) -> 'T seq
val v: int
Throws ArgumentException
|
Seq.initInfinite initializer
Full Usage:
Seq.initInfinite initializer
Parameters:
initializer
:
int -> 'T
-
A function that generates an item in the sequence from a given index.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Generates a new sequence which, when iterated, will return successive
elements by calling the given function. The results of calling the function
will not be saved, that is the function will be reapplied as necessary to
regenerate the elements. The function is passed the index of the item being
generated.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
Iteration can continue up to Int32.MaxValue. This is an O(1) operation.
-
initializer
:
int -> 'T
-
A function that generates an item in the sequence from a given index.
-
Returns:
'T seq
-
The result sequence.
Example
(+) 5 |> Seq.initInfinite
module Seq
from Microsoft.FSharp.Collections
val initInfinite: initializer: (int -> 'T) -> 'T seq
Evaluates to a sequence yielding the same results as seq { 5; 6; 7; 8; ... }
|
Seq.insertAt index value source
Full Usage:
Seq.insertAt index value source
Parameters:
index
:
int
-
The index where the item should be inserted.
value
:
'T
-
The value to insert.
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Return a new sequence with a new item inserted before the given index.
This is an O(n) operation, where n is the index.
-
index
:
int
-
The index where the item should be inserted.
-
value
:
'T
-
The value to insert.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
seq { 0; 1; 2 } |> Seq.insertAt 1 9
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
module Seq
from Microsoft.FSharp.Collections
val insertAt: index: int -> value: 'T -> source: 'T seq -> 'T seq
Evaluates to a sequence yielding the same results as seq { 0; 9; 1; 2 }.
|
Seq.insertManyAt index values source
Full Usage:
Seq.insertManyAt index values source
Parameters:
index
:
int
-
The index where the items should be inserted.
values
:
'T seq
-
The values to insert.
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Return a new sequence with new items inserted before the given index.
This is an O(n) operation, where n is the index.
-
index
:
int
-
The index where the items should be inserted.
-
values
:
'T seq
-
The values to insert.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
seq { 0; 1; 2 } |> Seq.insertManyAt 1 [8; 9]
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
module Seq
from Microsoft.FSharp.Collections
val insertManyAt: index: int -> values: 'T seq -> source: 'T seq -> 'T seq
Evaluates to a sequence yielding the same results as seq { 0; 8; 9; 1; 2 }.
|
Seq.isEmpty source
Full Usage:
Seq.isEmpty source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
bool
True if the sequence is empty; false otherwise.
Type parameters:
'T
|
Returns true if the sequence contains no elements, false otherwise.
This is an O(1) operation.
-
source
:
'T seq
-
The input sequence.
-
Returns:
bool
-
True if the sequence is empty; false otherwise.
Example
module Seq
from Microsoft.FSharp.Collections
val isEmpty: source: 'T seq -> bool
Evaluates to true
Example
["pear"; "banana"] |> Seq.isEmpty
module Seq
from Microsoft.FSharp.Collections
val isEmpty: source: 'T seq -> bool
Evaluates to false
|
Seq.item index source
Full Usage:
Seq.item index source
Parameters:
index
:
int
-
The index of the element to retrieve.
source
:
'T seq
-
The input sequence.
Returns:
'T
The element at the specified index of the sequence.
Type parameters:
'T
|
Computes the element at the specified index in the collection.
This is an O(n) operation, where n is the index.
-
index
:
int
-
The index of the element to retrieve.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The element at the specified index of the sequence.
Example
let inputs = ["a"; "b"; "c"]
inputs |> Seq.item 1
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val item: index: int -> source: 'T seq -> 'T
Evaluates to "b"
Example
let inputs = ["a"; "b"; "c"]
inputs |> Seq.item 4
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val item: index: int -> source: 'T seq -> 'T
Throws ArgumentException
|
Seq.iter action source
Full Usage:
Seq.iter action source
Parameters:
action
:
'T -> unit
-
A function to apply to each element of the sequence.
source
:
'T seq
-
The input sequence.
Type parameters:
'T
|
Applies the given function to each element of the collection.
This is an O(n) operation, where n is the length of the sequence.
-
action
:
'T -> unit
-
A function to apply to each element of the sequence.
-
source
:
'T seq
-
The input sequence.
Example
["a"; "b"; "c"] |> Seq.iter (printfn "%s")
module Seq
from Microsoft.FSharp.Collections
val iter: action: ('T -> unit) -> source: 'T seq -> unit
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
Evaluates to unit and prints
in the console.
|
Seq.iter2 action source1 source2
Full Usage:
Seq.iter2 action source1 source2
Parameters:
action
:
'T1 -> 'T2 -> unit
-
A function to apply to each pair of elements from the input sequences.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Type parameters:
'T1, 'T2
|
Applies the given function to two collections simultaneously. If one sequence is shorter than
the other then the remaining elements of the longer sequence are ignored.
This is an O(n) operation, where n is the length of the sequences.
-
action
:
'T1 -> 'T2 -> unit
-
A function to apply to each pair of elements from the input sequences.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
Example
let inputs1 = ["a"; "b"; "c"]
let inputs2 = [1; 2; 3]
(inputs1, inputs2) ||> Seq.iter2 (printfn "%s: %i")
val inputs1: string list
val inputs2: int list
module Seq
from Microsoft.FSharp.Collections
val iter2:
action: ('T1 -> 'T2 -> unit) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
unit
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
Evaluates to unit and prints
in the console.
|
Seq.iteri action source
Full Usage:
Seq.iteri action source
Parameters:
action
:
int -> 'T -> unit
-
A function to apply to each element of the sequence that can also access the current index.
source
:
'T seq
-
The input sequence.
Type parameters:
'T
|
Applies the given function to each element of the collection. The integer passed to the
function indicates the index of element.
This is an O(n) operation, where n is the length of the sequence.
-
action
:
int -> 'T -> unit
-
A function to apply to each element of the sequence that can also access the current index.
-
source
:
'T seq
-
The input sequence.
Example
let inputs = ["a"; "b"; "c"]
inputs |> Seq.iteri (fun i v -> printn $"{i}: {v}")
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val iteri: action: (int -> 'T -> unit) -> source: 'T seq -> unit
val i: int
val v: string
Evaluates to unit and prints
in the console.
|
Seq.iteri2 action source1 source2
Full Usage:
Seq.iteri2 action source1 source2
Parameters:
action
:
int -> 'T1 -> 'T2 -> unit
-
A function to apply to each pair of elements from the input sequences along with their index.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Type parameters:
'T1, 'T2
|
Applies the given function to two collections simultaneously. If one sequence is shorter than
the other then the remaining elements of the longer sequence are ignored. The integer passed to the
function indicates the index of element.
This is an O(n) operation, where n is the length of the sequences.
-
action
:
int -> 'T1 -> 'T2 -> unit
-
A function to apply to each pair of elements from the input sequences along with their index.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
Example
let inputs1 = ["a"; "b"; "c"]
let inputs2 = ["banana"; "pear"; "apple"]
(inputs1, inputs2) ||> Seq.iteri2 (fun i s1 s2 -> printfn "Index {i}: {s1} - {s2}")
val inputs1: string list
val inputs2: string list
module Seq
from Microsoft.FSharp.Collections
val iteri2:
action: (int -> 'T1 -> 'T2 -> unit) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
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
|
Seq.last source
Full Usage:
Seq.last source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T
The last element of the sequence.
Type parameters:
'T
|
Returns the last element of the sequence.
This is an O(n) operation, where n is the length of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The last element of the sequence.
Example
["pear"; "banana"] |> Seq.last
module Seq
from Microsoft.FSharp.Collections
val last: source: 'T seq -> 'T
Evaluates to banana
Example
module Seq
from Microsoft.FSharp.Collections
val last: source: 'T seq -> 'T
Throws ArgumentException
|
Seq.length source
Full Usage:
Seq.length source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
int
The length of the sequence.
Type parameters:
'T
|
Returns the length of the sequence
This is an O(n) operation, where n is the length of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
int
-
The length of the sequence.
Example
let inputs = ["a"; "b"; "c"]
inputs |> Seq.length
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val length: source: 'T seq -> int
Evaluates to 3
|
Seq.map mapping source
Full Usage:
Seq.map mapping source
Parameters:
mapping
:
'T -> 'U
-
A function to transform items from the input sequence.
source
:
'T seq
-
The input sequence.
Returns:
'U seq
The result sequence.
Type parameters:
'T, 'U
|
Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection. The given function will be applied
as elements are demanded using the MoveNext method on enumerators retrieved from the
object.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
mapping
:
'T -> 'U
-
A function to transform items from the input sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'U seq
-
The result sequence.
Example
let inputs = ["a"; "bbb"; "cc"]
inputs |> Seq.map (fun x -> x.Length)
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val map: mapping: ('T -> 'U) -> source: 'T seq -> 'U seq
val x: string
property System.String.Length: int with get
Evaluates to a sequence yielding the same results as seq { 1; 3; 2 }
|
Seq.map2 mapping source1 source2
Full Usage:
Seq.map2 mapping source1 source2
Parameters:
mapping
:
'T1 -> 'T2 -> 'U
-
A function to transform pairs of items from the input sequences.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Returns:
'U seq
The result sequence.
Type parameters:
'T1, 'T2, 'U
|
Builds a new collection whose elements are the results of applying the given function
to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than
the other then the remaining elements of the longer sequence are ignored.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequences.
-
mapping
:
'T1 -> 'T2 -> 'U
-
A function to transform pairs of items from the input sequences.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
Returns:
'U seq
-
The result sequence.
Example
let inputs1 = ["a"; "bad"; "good"]
let inputs2 = [0; 2; 1]
(inputs1, inputs2) ||> Seq.map2 (fun x y -> x.[y])
val inputs1: string list
val inputs2: int list
module Seq
from Microsoft.FSharp.Collections
val map2:
mapping: ('T1 -> 'T2 -> 'U) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
'U seq
val x: string
val y: int
Evaluates to a sequence yielding the same results as seq { 'a'; 'd'; 'o' }
|
Seq.map3 mapping source1 source2 source3
Full Usage:
Seq.map3 mapping source1 source2 source3
Parameters:
mapping
:
'T1 -> 'T2 -> 'T3 -> 'U
-
The function to transform triples of elements from the input sequences.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
source3
:
'T3 seq
-
The third input sequence.
Returns:
'U seq
The result sequence.
Type parameters:
'T1, 'T2, 'T3, 'U
|
Builds a new collection whose elements are the results of applying the given function
to the corresponding triples of elements from the three sequences. If one input sequence if shorter than
the others then the remaining elements of the longer sequences are ignored.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequences.
-
mapping
:
'T1 -> 'T2 -> 'T3 -> 'U
-
The function to transform triples of elements from the input sequences.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
source3
:
'T3 seq
-
The third input sequence.
-
Returns:
'U seq
-
The result sequence.
Example
let inputs1 = [ "a"; "t"; "ti" ]
let inputs2 = [ "l"; "h"; "m" ]
let inputs3 = [ "l"; "e"; "e" ]
(inputs1, inputs2, inputs3) |||> Seq.map3 (fun x y z -> x + y + z)
val inputs1: string list
val inputs2: string list
val inputs3: string list
module Seq
from Microsoft.FSharp.Collections
val map3:
mapping: ('T1 -> 'T2 -> 'T3 -> 'U) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
source3: 'T3 seq ->
'U seq
val x: string
val y: string
val z: string
Evaluates to a sequence yielding the same results as seq { "all"; "the"; "time" }
|
Seq.mapFold mapping state source
Full Usage:
Seq.mapFold mapping state source
Parameters:
mapping
:
'State -> 'T -> 'Result * 'State
-
The function to transform elements from the input collection and accumulate the final value.
state
:
'State
-
The initial state.
source
:
'T seq
-
The input collection.
Returns:
'Result seq * 'State
The collection of transformed elements, and the final accumulated value.
Type parameters:
'T, 'State, 'Result
|
Combines map and fold. Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection. The function is also used to accumulate a final value.
This function digests the whole initial sequence as soon as it is called. As a result this function should
not be used with large or infinite sequences. This is an O(n) operation, where n is the length of the sequence.
-
mapping
:
'State -> 'T -> 'Result * 'State
-
The function to transform elements from the input collection and accumulate the final value.
-
state
:
'State
-
The initial state.
-
source
:
'T seq
-
The input collection.
-
Returns:
'Result seq * 'State
-
The collection of transformed elements, and the final accumulated value.
Example
Accumulate the charges, and double them as well
type Charge =
| In of int
| Out of int
let inputs = seq { In 1; Out 2; In 3 }
let newCharges, balance =
(0, inputs) ||> Seq.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
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
module Seq
from Microsoft.FSharp.Collections
val mapFold<'T,'State,'Result> :
mapping: ('State -> 'T -> 'Result * 'State) ->
state: 'State ->
source: 'T seq ->
'Result seq * 'State
Evaluates newCharges to seq { In 2; Out 4; In 6 } and balance to 2.
|
Seq.mapFoldBack mapping source state
Full Usage:
Seq.mapFoldBack mapping source state
Parameters:
mapping
:
'T -> 'State -> 'Result * 'State
-
The function to transform elements from the input collection and accumulate the final value.
source
:
'T seq
-
The input collection.
state
:
'State
-
The initial state.
Returns:
'Result seq * 'State
The collection of transformed elements, and the final accumulated value.
Type parameters:
'T, 'State, 'Result
|
Combines map and foldBack. Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection. The function is also used to accumulate a final value.
This function digests the whole initial sequence as soon as it is called. As a result this function should
not be used with large or infinite sequences. This is an O(n) operation, where n is the length of the sequence.
-
mapping
:
'T -> 'State -> 'Result * 'State
-
The function to transform elements from the input collection and accumulate the final value.
-
source
:
'T seq
-
The input collection.
-
state
:
'State
-
The initial state.
-
Returns:
'Result seq * 'State
-
The collection of transformed elements, and the final accumulated value.
Example
Accumulate the charges from back to front, and double them as well
type Charge =
| In of int
| Out of int
let inputs = seq { In 1; Out 2; In 3 }
let newCharges, balance =
(inputs, 0) ||> Seq.mapFoldBack (fun charge acc ->
match charge with
| In i -> In (i*2), acc + i
| Out o -> Out (o*2), acc - o)
type Charge =
| In of int
| Out of int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> =
int
val inputs: Charge seq
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
union case Charge.In: int -> Charge
union case Charge.Out: int -> Charge
val newCharges: Charge seq
val balance: int
module Seq
from Microsoft.FSharp.Collections
val mapFoldBack:
mapping: ('T -> 'State -> 'Result * 'State) ->
source: 'T seq ->
state: 'State ->
'Result seq * 'State
val charge: Charge
val acc: int
val i: int
val o: int
Evaluates newCharges to seq { In 2; Out 4; In 6 } and balance to 2.
|
Seq.mapi mapping source
Full Usage:
Seq.mapi mapping source
Parameters:
mapping
:
int -> 'T -> 'U
-
A function to transform items from the input sequence that also supplies the current index.
source
:
'T seq
-
The input sequence.
Returns:
'U seq
The result sequence.
Type parameters:
'T, 'U
|
Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection. The integer index passed to the
function indicates the index (from 0) of element being transformed.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
mapping
:
int -> 'T -> 'U
-
A function to transform items from the input sequence that also supplies the current index.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'U seq
-
The result sequence.
Example
let inputs = [ 10; 10; 10 ]
inputs |> Seq.mapi (fun i x -> i + x)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val mapi: mapping: (int -> 'T -> 'U) -> source: 'T seq -> 'U seq
val i: int
val x: int
Evaluates to a sequence yielding the same results as seq { 10; 11; 12 }
|
Seq.mapi2 mapping source1 source2
Full Usage:
Seq.mapi2 mapping source1 source2
Parameters:
mapping
:
int -> 'T1 -> 'T2 -> 'U
-
A function to transform pairs of items from the input sequences that also supplies the current index.
source1
:
'T1 seq
-
The first input sequence.
source2
:
'T2 seq
-
The second input sequence.
Returns:
'U seq
The result sequence.
Type parameters:
'T1, 'T2, 'U
|
Builds a new collection whose elements are the results of applying the given function
to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than
the other then the remaining elements of the longer sequence are ignored. The integer index passed to the
function indicates the index (from 0) of element being transformed.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequences.
-
mapping
:
int -> 'T1 -> 'T2 -> 'U
-
A function to transform pairs of items from the input sequences that also supplies the current index.
-
source1
:
'T1 seq
-
The first input sequence.
-
source2
:
'T2 seq
-
The second input sequence.
-
Returns:
'U seq
-
The result sequence.
Example
let inputs1 = ["a"; "bad"; "good"]
let inputs2 = [0; 2; 1]
(inputs1, inputs2) ||> Seq.mapi2 (fun i x y -> i, x[y])
val inputs1: string list
val inputs2: int list
module Seq
from Microsoft.FSharp.Collections
val mapi2:
mapping: (int -> 'T1 -> 'T2 -> 'U) ->
source1: 'T1 seq ->
source2: 'T2 seq ->
'U seq
val i: int
val x: string
val y: int
Evaluates to a sequence yielding the same results as seq { (0, 'a'); (1, 'd'); (2, 'o') }
|
Seq.max source
Full Usage:
Seq.max source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T
The largest element of the sequence.
Modifiers:
inline
Type parameters:
'T (requires comparison)
|
Returns the greatest of all elements of the sequence, compared via Operators.max
This is an O(n) operation, where n is the length of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The largest element of the sequence.
Example
let inputs = [ 10; 12; 11 ]
inputs |> Seq.max
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val max: source: 'T seq -> 'T (requires comparison)
Evaluates to 12
Example
let inputs = [ ]
inputs |> Seq.max
val inputs: 'a list
module Seq
from Microsoft.FSharp.Collections
val max: source: 'T seq -> 'T (requires comparison)
Throws System.ArgumentException.
|
Seq.maxBy projection source
Full Usage:
Seq.maxBy projection source
Parameters:
projection
:
'T -> 'U
-
A function to transform items from the input sequence into comparable keys.
source
:
'T seq
-
The input sequence.
Returns:
'T
The largest element of the sequence.
Modifiers:
inline
Type parameters:
'T, 'U (requires comparison)
|
Returns the greatest of all elements of the sequence, compared via Operators.max on the function result.
Returns the first maximal element of the sequence if there are multiple equal maximum elements.
This is an O(n) operation, where n is the length of the sequence.
-
projection
:
'T -> 'U
-
A function to transform items from the input sequence into comparable keys.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The largest element of the sequence.
Example
let inputs = ["aaa"; "b"; "cccc"]
inputs |> Seq.maxBy (fun s -> s.Length)
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val maxBy: projection: ('T -> 'U) -> source: 'T seq -> 'T (requires comparison)
val s: string
property System.String.Length: int with get
Evaluates to "cccc"
Example
let inputs = [ ]
inputs |> Seq.maxBy (fun s -> s.Length)
val inputs: 'a list
module Seq
from Microsoft.FSharp.Collections
val maxBy: projection: ('T -> 'U) -> source: 'T seq -> 'T (requires comparison)
val s: obj
Throws System.ArgumentException.
|
Seq.min source
Full Usage:
Seq.min source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
'T
The smallest element of the sequence.
Modifiers:
inline
Type parameters:
'T (requires comparison)
|
Returns the lowest of all elements of the sequence, compared via Operators.min.
This is an O(n) operation, where n is the length of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The smallest element of the sequence.
Example
let inputs = [10; 12; 11]
inputs |> Seq.min
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val min: source: 'T seq -> 'T (requires comparison)
Evaluates to 10
Example
let inputs = []
inputs |> Seq.min
val inputs: 'a list
module Seq
from Microsoft.FSharp.Collections
val min: source: 'T seq -> 'T (requires comparison)
Throws System.ArgumentException.
|
Seq.minBy projection source
Full Usage:
Seq.minBy projection source
Parameters:
projection
:
'T -> 'U
-
A function to transform items from the input sequence into comparable keys.
source
:
'T seq
-
The input sequence.
Returns:
'T
The smallest element of the sequence.
Modifiers:
inline
Type parameters:
'T, 'U (requires comparison)
|
Returns the lowest of all elements of the sequence, compared via Operators.min on the function result.
Returns the first minimal element of the sequence if there are multiple equal minimal elements.
This is an O(n) operation, where n is the length of the sequence.
-
projection
:
'T -> 'U
-
A function to transform items from the input sequence into comparable keys.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T
-
The smallest element of the sequence.
Example
let inputs = [ "aaa"; "b"; "cccc" ]
inputs |> Seq.minBy (fun s -> s.Length)
val inputs: string list
module Seq
from Microsoft.FSharp.Collections
val minBy: projection: ('T -> 'U) -> source: 'T seq -> 'T (requires comparison)
val s: string
property System.String.Length: int with get
Evaluates to "b"
Example
let inputs = []
inputs |> Seq.minBy (fun (s: string) -> s.Length)
val inputs: 'a list
module Seq
from Microsoft.FSharp.Collections
val minBy: projection: ('T -> 'U) -> source: 'T seq -> 'T (requires comparison)
val s: string
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
property System.String.Length: int with get
Throws System.ArgumentException.
|
Seq.ofArray source
Full Usage:
Seq.ofArray source
Parameters:
source
:
'T array
-
The input array.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Views the given array as a sequence.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the array.
-
source
:
'T array
-
The input array.
-
Returns:
'T seq
-
The result sequence.
Example
let inputs = [| 1; 2; 5 |]
inputs |> Seq.ofArray
val inputs: int array
module Seq
from Microsoft.FSharp.Collections
val ofArray: source: 'T array -> 'T seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 5 }.
|
Seq.ofList source
Full Usage:
Seq.ofList source
Parameters:
source
:
'T list
-
The input list.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Views the given list as a sequence.
This is an O(1) operation.
-
source
:
'T list
-
The input list.
-
Returns:
'T seq
-
The result sequence.
Example
let inputs = [ 1; 2; 5 ]
inputs |> Seq.ofList
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val ofList: source: 'T list -> 'T seq
Evaluates to a sequence yielding the same results as seq { 1; 2; 5 }.
|
Seq.pairwise source
Full Usage:
Seq.pairwise source
Parameters:
source
:
'T seq
-
The input sequence.
Returns:
('T * 'T) seq
The result sequence.
Type parameters:
'T
|
Returns a sequence of each element in the input sequence paired with its predecessor, with the
exception of the first element which is only returned as the predecessor of the second element.
The predecessor comes first in the returned pairs.
Sequence construction is O(1). Enumeration is O(n), where n is the length of the sequence.
-
source
:
'T seq
-
The input sequence.
-
Returns:
('T * 'T) seq
-
The result sequence.
Example
let inputs = seq { 1; 2; 3; 4 }
inputs |> Seq.pairwise
val inputs: int seq
Multiple items
val seq: sequence: 'T seq -> 'T seq
--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
module Seq
from Microsoft.FSharp.Collections
val pairwise: source: 'T seq -> ('T * 'T) seq
Evaluates to a sequence yielding the same results as seq { (1, 2); (2, 3); (3, 4) }.
|
Seq.permute indexMap source
Full Usage:
Seq.permute indexMap source
Parameters:
indexMap
:
int -> int
-
The function that maps input indices to output indices.
source
:
'T seq
-
The input sequence.
Returns:
'T seq
The result sequence.
Type parameters:
'T
|
Returns a sequence with all elements permuted according to the
specified permutation.
This function consumes the whole input sequence before yielding the first element of the result sequence. This is an O(n) operation, where n is the length of the sequence.
-
indexMap
:
int -> int
-
The function that maps input indices to output indices.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'T seq
-
The result sequence.
Example
let inputs = [1; 2; 3; 4]
inputs |> Seq.permute (fun x -> (x + 1) % 4)
val inputs: int list
module Seq
from Microsoft.FSharp.Collections
val permute: indexMap: (int -> int) -> source: 'T seq -> 'T seq
val x: int
Evaluates to a sequence yielding the same results as seq { 4; 1; 2; 3 }.
|
Seq.pick chooser source
Full Usage:
Seq.pick chooser source
Parameters:
chooser
:
'T -> 'U option
-
A function to transform each item of the input sequence into an option of the output type.
source
:
'T seq
-
The input sequence.
Returns:
'U
The selected element.
Type parameters:
'T, 'U
|
Applies the given function to successive elements, returning the first
x where the function returns "Some(x)".
This is an O(n) operation in the worst case, where n is the length of the sequence.
-
chooser
:
'T -> 'U option
-
A function to transform each item of the input sequence into an option of the output type.
-
source
:
'T seq
-
The input sequence.
-
Returns:
'U
-
The select [Page truncated to keep GeezerVison snappy.] |
|