alignAllOrdered collections comparer
Signature: collections:ReadOnlyCollection<'?495473> [] > comparer:IComparer<'?495473> > '?495473 [] * (int64 * int64) [] list
Type parameters: '?495473

Calls either alignAllOrderedMany or alignAllOrderedFew depending on the number
of sequences to be aligned. Performance measurements suggest that 150 is the limit
when the implementation using binomial heap is faster.

alignAllOrderedFew seqs comparer
Signature: seqs:ReadOnlyCollection<'T> [] > comparer:IComparer<'T> > 'T [] * (int64 * int64) [] list
Type parameters: 'T

Align N ordered sequences of keys (using the specified comparer)
This is the same as alignOrdered but for larger number of key sequences.
Throws ComparisonFailedException when the comparer fails.
(This performs union on the specified sequences)

alignAllOrderedMany seqs comparer
Signature: seqs:ReadOnlyCollection<'T> [] > comparer:IComparer<'T> > 'T [] * (int64 * int64) [] list
Type parameters: 'T

Align N ordered sequences of keys (using the specified comparer)
This is the same as alignOrdered but for larger number of key sequences.
Throws ComparisonFailedException when the comparer fails.
(This performs union on the specified sequences)

alignAllUnordered seqs
Signature: seqs:ReadOnlyCollection<'T> [] > 'T [] * (int64 * int64) [] list
Type parameters: 'T

Align N unordered sequences of keys (performs union of the keys)

alignOrdered (...)
Signature: seq1:ReadOnlyCollection<'T> > seq2:ReadOnlyCollection<'T> > comparer:IComparer<'T> > intersectionOnly:bool > 'T [] * (int64 * int64) [] list
Type parameters: 'T

Align two ordered sequences of keys (using the specified comparer)
The resulting relocations are returned as twoelement list for symmetry with other functions
Throws ComparisonFailedException when the comparer fails.
When intersectionOnly = true , the function only adds keys & relocations
for keys that appear in both sequences (otherwise, it performs union)

alignUnordered s1 s2 intersectionOnly
Signature: s1:ReadOnlyCollection<'?495479> > s2:ReadOnlyCollection<'?495479> > intersectionOnly:bool > '?495479 [] * (int64 * int64) [] list
Type parameters: '?495479

Align two unordered sequences of keys. Calls either
alignUnorderedUnion or alignUnorderedIntersection , based
on the intersectionOnly parameter.

alignUnorderedIntersection seq1 seq2
Signature: seq1:ReadOnlyCollection<'T> > seq2:ReadOnlyCollection<'T> > 'T [] * (int64 * int64) [] list
Type parameters: 'T

Align two unordered sequences of keys (performs intersection of the keys)
The resulting relocations are returned as twoelement list for symmetry with other functions

alignUnorderedUnion seq1 seq2
Signature: seq1:ReadOnlyCollection<'T> > seq2:ReadOnlyCollection<'T> > 'T [] * (int64 * int64) [] list
Type parameters: 'T

Align two unordered sequences of keys (performs union of the keys)
The resulting relocations are returned as twoelement list for symmetry with other functions

choosel f input
Signature: f:(int64 > '?495423 > '?495424 option) > input:seq<'?495423> > seq<'?495424>
Type parameters: '?495423, '?495424

Same as Seq.choose but passes 64 bit index (l stands for long) to the function

chunkedWhile f input
Signature: f:('?495451 > '?495451 > bool) > input:seq<'?495451> > seq<'?495451 []>
Type parameters: '?495451

Generate nonverlapping chunks from the input sequence. A chunk is started
at the beginning and then immediately after the end of the previous chunk.
To find the end of the chunk, the function calls the provided argument f
with the first and the last elements of the chunk as arguments. A chunk
ends when f returns false .

chunkedWithBounds size boundary input
Signature: size:int > boundary:Boundary > input:seq<'?495455> > seq<DataSegment<'?495455 []>>
Type parameters: '?495455

Similar to Seq.windowedWithBounds , but generates nonoverlapping chunks
rather than floating windows. See that function for detailed documentation.
The function may iterate over the sequence repeatedly.

chunkRangesWhile f input
Signature: f:('?495461 > '?495461 > bool) > input:seq<'?495461> > seq<int64 * int64>
Type parameters: '?495461

Generate nonverlapping chunks from the input sequence. A chunk is started
at the beginning and then immediately after the end of the previous chunk.
To find the end of the chunk, the function calls the provided argument f
with the first and the last elements of the chunk as arguments. A chunk
ends when f returns false .
The function returns the chunks as pairs of their indices.

chunkRangesWithBounds (...)
Signature: size:int64 > boundary:Boundary > length:int64 > seq<DataSegmentKind * int64 * int64>

Generates addresses of windows in a collection of size 'length'. For example, consider
a collection with 7 elements (and indices 0 .. 6) and the requirement to create windows
of length 3:
0 1 2 3 4 5 6
When the AtEnding flag is set for boundary :
c c c
c c c
d
The two chunks marked as 'c' are returned always. The incomplete chunk at the end is
returned unless the Skip flag is set for boundary . When the AtBeginning flag is
set, the incomplete chunk is (when not Skip ) returned at the beginning:
d
c c c
c c c
The chunks are specified by inclusive indices, so, e.g. the first chunk in
the second example above is returned as a pair (0, 0).

getEnumerator s
Signature: s:seq<'?495445> > IEnumerator<'?495445>
Type parameters: '?495445

Calls the GetEnumerator method. Simple function to guide type inference.

headOrNone input
Signature: input:seq<'?495441> > '?495441 option
Type parameters: '?495441

If the input is non empty, returns Some(head) where head is
the first value. Otherwise, returns None .

isSorted data comparer
Signature: data:seq<'T> > comparer:IComparer<'T> > bool
Type parameters: 'T

Returns true if the specified sequence is sorted.

lastAndLength input
Signature: input:seq<'?495419> > '?495419 * int
Type parameters: '?495419

Returns the last element and the length of a sequence
(using just a single iteration over the sequence)

lastFew count input
Signature: count:int > input:seq<'?495443> > seq<'?495443>
Type parameters: '?495443

Returns the specified number of elements from the end of the sequence
Note that this needs to store the specified number of elements in memory
and it needs to iterate over the entire sequence.

mapl f input
Signature: f:(int64 > '?495426 > '?495427) > input:seq<'?495426> > seq<'?495427>
Type parameters: '?495426, '?495427

Same as Seq.map but passes 64 bit index (l stands for long) to the function

range lo hi
Signature: lo:^T > hi:^T > IEnumerable<^T>
Type parameters: ^T

A helper function that generates a sequence for the specified range of
int or int64 values. This is notably faster than using lo .. hi .

rangeStep lo step hi
Signature: lo:^T > step:^T > hi:^T > IEnumerable<^T>
Type parameters: ^T

A helper function that generates a sequence for the specified range of
int or int64 values. This is notably faster than using lo .. step .. hi .

skipAtMost count input
Signature: count:int > input:seq<'?495429> > seq<'?495429>
Type parameters: '?495429

Skip at most the specified number of elements. This is like
Seq.skip , but it does not throw when the sequence is shorter.

startAndEnd startCount endCount input
Signature: startCount:int > endCount:int > input:seq<'?495447> > seq<Choice<'?495447,unit,'?495447>>
Type parameters: '?495447

Given a sequence, returns startCount number of elements at the beginning
of the sequence (wrapped in Choice1Of3 ) followed by one Choice2Of2() value
and then followed by endCount number of elements at the end of the sequence
wrapped in Choice3Of3 . If the input is shorter than startCount + endCount ,
then all values are returned and wrapped in Choice1Of3 .

structuralEquals s1 s2
Signature: s1:seq<'T> > s2:seq<'T> > bool
Type parameters: 'T

Comapre two sequences using the Equals method. Returns true
when all their elements are equal and they have the same size.

structuralHash s
Signature: s:seq<'T> > int
Type parameters: 'T

Calculate hash code of a sequence, based on the values

tryFirstAndLast input
Signature: input:seq<'?495465> > ('?495465 * '?495465) option
Type parameters: '?495465

Returns the first and the last element from a sequence or 'None' if the sequence is empty

uniqueBy f input
Signature: f:('?495416 > '?495417) > input:seq<'?495416> > '?495417
Type parameters: '?495416, '?495417

If the projection returns the same value for all elements, then it
returns the value. Otherwise it throws an exception.

unreduce f start
Signature: f:('?495421 > '?495421) > start:'?495421 > seq<'?495421>
Type parameters: '?495421

Generate infinite sequence using the specified function.
The initial state is returned as the first element.

windowedWhile f input
Signature: f:('T > 'T > bool) > input:seq<'T> > seq<'T []>
Type parameters: 'T

Generate floating windows from the input sequence. New floating window is
started for each element. To find the end of the window, the function calls
the provided argument f with the first and the last elements of the window
as arguments. A window ends when f returns false .

windowedWithBounds size boundary input
Signature: size:int > boundary:Boundary > input:seq<'T> > seq<DataSegment<'T []>>
Type parameters: 'T

A version of Seq.windowed that allows specifying more complex boundary
behaviour. The boundary argument can specify one of the following options:
Boundary.Skip  only full windows are returned (like Seq.windowed )
Boundary.AtBeginning  incomplete windows (smaller than the required
size) are returned at the beginning.
Boundary.AtEnding  incomplete windows are returned at the end.
The result is a sequence of DataSegnebt<T> values, which makes it
easy to distinguish between complete and incomplete windows.

windowRangesWhile f input
Signature: f:('T > 'T > bool) > input:seq<'T> > seq<int64 * int64>
Type parameters: 'T

Generate floating windows from the input sequence. New floating window is
started for each element. To find the end of the window, the function calls
the provided argument f with the first and the last elements of the window
as arguments. A window ends when f returns false .
The function returns the windows as pairs of their indices.

windowRangesWithBounds (...)
Signature: size:int64 > boundary:Boundary > length:int64 > seq<DataSegmentKind * int64 * int64>

Generates addresses of chunks in a collection of size 'length'. For example, consider
a collection with 7 elements (and indices 0 .. 6) and the requirement to create chunks
of length 4:
0 1 2 3 4 5 6
s
s s
s s s
w w w w
w w w w
w w w w
w w w w
e e e
e e
e
The windows 's' are returned when boundary = Boundary.AtBeginning and the windows
'e' are returned when boundary = Boundary.AtEnding . The middle is returned always.
The windows are specified by inclusive indices, so, e.g. the first window is returned
as a pair (0, 0).
