<?xml version="1.0" encoding="utf-8"?>
<doc>
<assembly><name>FSharp.PowerPack.Parallel.Seq</name></assembly>
<members>
<member name="">

</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.averageBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the average of the results generated by applying the function to each element 
 of the sequence.</summary>

 <remarks>The elements are averaged using the <c>+</c> operator, <c>DivideByInt</c> method and <c>Zero</c> property 
 associated with the generated type.</remarks>

 <param name="projection">A function applied to transform each element of the sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence has zero elements.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.average``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <remarks>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 <c>Int32.MaxValue</c>.</remarks>

 <param name="initializer">A function that generates an item in the sequence from a given index.</param>

 <returns>The result sequence.</returns>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that is built from the given delayed specification of a
 sequence.</summary>

 <remarks>The input function is evaluated each time an IEnumerator for the sequence 
 is requested.</remarks>

 <param name="generator">The generating function for the sequence.</param>
 <summary>Operates in parallel, using System.Linq.Parallel. Compares two sequences using the given comparison function, element by element.
 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.</summary>

 <param name="comparer">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.</param>
 <param name="source1">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the input sequences
 is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that corresponds to a cached version of the input sequence.
 This 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.</summary>

 <remarks>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.</remarks>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the average of the elements in the sequence.</summary>

 <remarks>The elements are averaged using the <c>+</c> operator, <c>DivideByInt</c> method and <c>Zero</c> property 
 associated with the element type.</remarks>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence has zero elements.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.maxBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the greatest of all elements of the sequence, compared via Operators.max on the function result.</summary>

 <param name="projection">A function to transform items from the input sequence into comparable keys.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.max``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence of each element in the input sequence and its predecessor, with the
 exception of the first element which is only returned as the predecessor of the second element.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the greatest of all elements of the sequence, compared via Operators.max</summary>

 <param name="source">The input sequence.</param>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>

 <returns>The result sequence.</returns>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.minBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the lowest of all elements of the sequence, compared via Operators.min on the function result.</summary>

 <param name="projection">A function to transform items from the input sequence into comparable keys.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.min``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Like fold, but computes on-demand and returns the sequence of intermediary and final results.</summary>

 <param name="folder">A function that updates the state with each element from the sequence.</param>
 <param name="state">The initial state.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Builds a new sequence object that delegates to the given sequence object. This ensures 
 the original sequence cannot be rediscovered and mutated by a type cast. For example, 
 if given an array the returned sequence will return the elements of the array, but
 you cannot cast the returned sequence object to an array.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the lowest of all elements of the sequence, compared via <c>Operators.min</c>.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.sumBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the sum of the results generated by applying the function to each element of the sequence.</summary>
 <remarks>The generated elements are summed using the <c>+</c> operator and <c>Zero</c> property associated with the generated type.</remarks>

 <param name="projection">A function to transform items from the input sequence into the type that will be summed.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.sum``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the first N elements of the sequence.</summary>
 <remarks>Throws <c>InvalidOperationException</c>
 if the count exceeds the number of elements in the sequence. <c>Seq.truncate</c>
 returns as many items as the sequence contains instead of throwing an exception.</remarks>

 <param name="count">The number of items to take.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>
 <exception cref="System.InvalidOperationException">Thrown when count exceeds the number of elements
 in the sequence.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Applies the given function to successive elements, returning the first
 result where the function returns "Some(x)".</summary>

 <param name="chooser">A function that transforms items from the input sequence into options.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that contains the elements generated by the given computation.
 The given initial <c>state</c> argument is passed to the element generator.
 For each IEnumerator elements in the stream are generated on-demand by applying the element
 generator, until a None value is returned by the element generator. Each call to the element
 generator returns a new residual <c>state</c>.</summary>

 <remarks>The stream will be recomputed each time an IEnumerator is requested and iterated for the Seq.

 The returned sequence may be passed between threads safely. However, 
 individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>

 <param name="generator">A function that takes in the current state and returns an option tuple of the next
 element of the sequence and the next state value.</param>
 <param name="state">The initial state value.</param>

 <returns>The result sequence.</returns>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that yields sliding windows of containing elements drawn from the input
 sequence. Each window is returned as a fresh array.</summary>

 <param name="windowSize">The number of elements in each window.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Combines the three sequences into a list of triples. The sequences need not have equal lengths:
 when one sequence is exhausted any remaining elements in the other
 sequences are ignored.</summary>

 <param name="source1">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>
 <param name="source3">The third input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when any of the input sequences is null.</exception>
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the sum of the elements in the sequence.</summary>

 <remarks>The elements are summed using the <c>+</c> operator and <c>Zero</c> property associated with the generated type.</remarks>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>
</member>
<member name="">

</member>
<member name="">

</member>
<member name="">

</member>
<member name="">

</member>
<member name="">

</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
 <summary>Operates in parallel, using System.Linq.Parallel. Combines the two sequences into a list of pairs. The two sequences need not have equal lengths:
 when one sequence is exhausted any remaining elements in the other
 sequence are ignored.</summary>

 <param name="source1">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the input sequences is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.truncate``1(System.Int32,System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that when enumerated returns at most N elements.</summary>

 <param name="count">The maximum number of items to enumerate.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.tryFindIndex``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the index of the first element in the sequence 
 that satisfies the given predicate. Return <c>None</c> if no such element exists.</summary>

 <param name="predicate">A function that evaluates to a Boolean when given an item in the sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.tryFind``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the first element for which the given function returns <c>true</c>.
 Return <c>None</c> if no such element exists.</summary>

 <param name="predicate">A function that evaluates to a Boolean when given an item in the sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.toList``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Builds a list from the given collection.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.toArray``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Builds an array from the given collection.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.takeWhile``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that, when iterated, yields elements of the underlying sequence while the 
 given predicate returns <c>true</c>, and then returns no further elements.</summary>

 <param name="predicate">A function that evaluates to false when no more items should be returned.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.sortBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies a key-generating function to each element of a sequence and yield a sequence ordered
 by keys.  The keys are compared using generic comparison as implemented by <c>Operators.compare</c>.</summary> 
 
 <remarks>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 a stable sort, that is the original order of equal elements is preserved.</remarks>

 <param name="projection">A function to transform items of the input sequence into comparable keys.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.sort``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Yields a sequence ordered by keys.</summary>
 
 <remarks>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 a stable sort, that is the original order of equal elements is preserved.</remarks>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.skipWhile``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that, when iterated, skips elements of the underlying sequence while the 
 given predicate returns <c>true</c>, and then yields the remaining elements of the sequence.</summary>

 <param name="predicate">A function that evaluates an element of the sequence to a boolean value.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.skip``1(System.Int32,System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that skips N elements of the underlying sequence and then yields the
 remaining elements of the sequence.</summary>

 <param name="count">The number of items to skip.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.InvalidOperationException">Thrown when count exceeds the number of elements
 in the sequence.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.singleton``1(``0)">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a sequence that yields one item only.</summary>

 <param name="value">The input item.</param>

 <returns>The result sequence.</returns>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.reduce``1(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpFunc{``0,``0}},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies a function to each element of the sequence, threading an accumulator argument
 through the computation. Begin by applying the function to the first two elements.
 Then feed this result into the function along with the third element and so on.  
 Return the final result.</summary>

 <param name="reduction">A function that takes in the current accumulated result and the next
 element of the sequence to produce the next accumulated result.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input sequence is empty.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.pick``2(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpOption{``1}},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies the given function to successive elements, returning the first
 <c>x</c> where the function returns "Some(x)".</summary>

 <param name="chooser">A function to transform each item of the input sequence into an option of the output type.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.Collections.Generic.KeyNotFoundException">Thrown when every item of the sequence
 evaluates to <c>None</c> when the given function is applied.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.ofList``1(Microsoft.FSharp.Collections.FSharpList{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Views the given list as a sequence.</summary>

 <param name="source">The input list.</param>

 <returns>The result sequence.</returns>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.ofArray``1(``0[])">
 <summary>Operates in parallel, using System.Linq.Parallel. Views the given array as a sequence.</summary>

 <param name="source">The input array.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.nth``1(System.Int32,System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Computes the nth element in the collection.</summary>

 <param name="index">The index of element to retrieve.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.mapi``2(Microsoft.FSharp.Core.FSharpFunc{System.Int32,Microsoft.FSharp.Core.FSharpFunc{``0,``1}},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <param name="mapping">A function to transform items from the input sequence that also supplies the current index.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.map2``3(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpFunc{``1,``2}},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <param name="mapping">A function to transform pairs of items from the input sequences.</param>
 <param name="source">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the input sequences is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.map``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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 <c>MoveNext</c> method on enumerators retrieved from the
 object.</summary>

 <remarks>The returned sequence may be passed between threads safely. However, 
 individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>

 <param name="mapping">A function to transform items from the input sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.length``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the lengthof the sequence</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.iter2``2(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpFunc{``1,Microsoft.FSharp.Core.Unit}},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <param name="action">A function to apply to each pair of elements from the input sequences.</param>
 <param name="source1">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the input sequences is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.iteri``1(Microsoft.FSharp.Core.FSharpFunc{System.Int32,Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.Unit}},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies the given function to each element of the collection. The integer passed to the
 function indicates the index of element.</summary>

 <param name="action">A function to apply to each element of the sequence that can also access the current index.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.iter``1(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.Unit},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies the given function to each element of the collection.</summary>

 <param name="action">A function to apply to each element of the sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.init``1(System.Int32,Microsoft.FSharp.Core.FSharpFunc{System.Int32,``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <remarks>The returned sequence may be passed between threads safely. However, 
 individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>

 <param name="count">The maximum number of items to generate for the sequence.</param>
 <param name="initializer">A function that generates an item in the sequence from a given index.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentException">Thrown when count is negative.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.isEmpty``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns true if the sequence contains no elements, false otherwise.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.head``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the first element of the sequence.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
 <exception cref="System.ArgumentException">Thrown when the input does not have any elements.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.groupBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies a key-generating function to each element of a sequence and yields a sequence of 
 unique keys. Each unique key has also contains a sequence of all elements that match 
 to this key.</summary>
 
 <remarks>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.</remarks>

 <param name="projection">A function that transforms an element of the sequence into a comparable key.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.forall2``2(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpFunc{``1,System.Boolean}},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <param name="predicate">A function to test pairs of elements from the input sequences.</param>
 <param name="source1">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the input sequences is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.forall``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Tests if all elements of the sequence satisfy the given predicate.</summary>

 <remarks>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.</remarks>

 <param name="predicate">A function to test an element of the input sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.fold``2(Microsoft.FSharp.Core.FSharpFunc{``1,Microsoft.FSharp.Core.FSharpFunc{``0,``1}},``1,System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies a function to each element of the collection, threading an accumulator argument
 through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> 
 then computes <c>f (... (f s i0)...) iN</c></summary>

 <param name="folder">A function that updates the state with each element from the sequence.</param>
 <param name="state">The initial state.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.findIndex``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the index of the first element for which the given function returns <c>true</c>.</summary>

 <param name="predicate">A function to test whether the index of a particular element should be returned.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.Collections.Generic.KeyNotFoundException">Thrown if no element returns true when
 evaluated by the predicate</exception>
 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.find``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns the first element for which the given function returns <c>true</c>.</summary>

 <param name="predicate">A function to test whether an item in the sequence should be returned.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.Collections.Generic.KeyNotFoundException">Thrown if no element returns true when
 evaluated by the predicate</exception>
 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.filter``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Returns a new collection containing only the elements of the collection
 for which the given predicate returns "true".</summary>

 <remarks>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.</remarks>

 <param name="predicate">A function to test whether each item in the input sequence should be included in the output.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>    
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.exists2``2(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpFunc{``1,System.Boolean}},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
 <summary>Operates in parallel, using System.Linq.Parallel. Tests if any pair of corresponding elements of the input sequences satisfies the given predicate.</summary>

 <remarks>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.</remarks>

 <param name="predicate">A function to test each pair of items from the input sequences.</param>
 <param name="source1">The first input sequence.</param>
 <param name="source2">The second input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the two input sequences is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.exists``1(Microsoft.FSharp.Core.FSharpFunc{``0,System.Boolean},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Tests if any element of the sequence satisfies the given predicate.</summary>

 <remarks>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.</remarks>

 <param name="predicate">A function to test each item of the input sequence.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.empty``1">
 <summary>Operates in parallel, using System.Linq.Parallel. Creates an empty sequence.</summary>

 <returns>The result sequence.</returns>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.distinctBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <param name="projection">A function transforming the sequence items into comparable keys.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.distinct``1(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. 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.</summary>

 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.countBy``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies a key-generating function to each element of a sequence and return a sequence yielding unique
 keys and their number of occurrences in the original sequence.</summary>
 
 <remarks>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.</remarks>

 <param name="projection">A function transforming each item of input sequence into a key to be
 compared against the others.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.concat``2(System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Combines the given enumeration-of-enumerations as a single concatenated
 enumeration.</summary>

 <remarks>The returned sequence may be passed between threads safely. However, 
 individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>

 <param name="sources">The input enumeration-of-enumerations.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.collect``3(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies the given function to each element of the sequence and concatenates all the
 results.</summary>

 <remarks>Remember sequence is lazy, effects are delayed until it is enumerated.</remarks>

 <param name="mapping">A function to transform elements of the input sequence into the sequences
 that will then be concatenated.</param>
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.choose``2(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpOption{``1}},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Applies the given function to each element of the list. Return
 the list comprised of the results "x" for each element where
 the function returns Some(x).</summary>

 <remarks>The returned sequence may be passed between threads safely. However, 
 individual IEnumerator values generated from the returned sequence should not
 be accessed concurrently.</remarks>

 <param name="chooser">A function to transform items of type T into options of type U.</param>
 <param name="source">The input sequence of type T.</param>

 <returns>The result sequence.</returns>
 
 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.cast``1(System.Collections.IEnumerable)">
 <summary>Operates in parallel, using System.Linq.Parallel. Wraps a loosely-typed System.Collections sequence as a typed sequence.</summary>

 <remarks>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.</remarks>
 
 <param name="source">The input sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
</member>
<member name="M:Microsoft.FSharp.Collections.PSeqModule.append``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
 <summary>Operates in parallel, using System.Linq.Parallel. Wraps the two given enumerations as a single concatenated
 enumeration.</summary>

 <remarks>The returned sequence may be passed between threads safely. However, 
 individual IEnumerator values generated from the returned sequence should not be accessed
 concurrently.</remarks>

 <param name="source1">The first sequence.</param>
 <param name="source2">The second sequence.</param>

 <returns>The result sequence.</returns>

 <exception cref="System.ArgumentNullException">Thrown when either of the two provided sequences is
 null.</exception>
</member>
<member name="T:Microsoft.FSharp.Collections.PSeqModule">
 <summary>Parallel operations on IEnumerables.</summary>
</member>
</members>
</doc>
