From b2858424d8e3e67dd7903443ce5bcd3c6a11151b Mon Sep 17 00:00:00 2001 From: dsyme Date: Fri, 12 Jun 2026 18:20:17 +0000 Subject: [PATCH] deploy: 8a058c6f5eb319c66345958f8daa8b5936eff26f --- .nojekyll | 0 Dockerfile | 29 + NuGet.config | 14 + TaskSeqAdvanced.fsx | 251 + TaskSeqAdvanced.html | 571 + TaskSeqCombining.fsx | 264 + TaskSeqCombining.html | 533 + TaskSeqConsuming.fsx | 227 + TaskSeqConsuming.html | 581 + TaskSeqGenerating.fsx | 268 + TaskSeqGenerating.html | 636 + TaskSeqTransforming.fsx | 165 + TaskSeqTransforming.html | 465 + content/fsdocs-default.css | 1288 + content/fsdocs-details-set-expanded.js | 9 + content/fsdocs-details-toggle.js | 46 + content/fsdocs-search.js | 126 + content/fsdocs-theme-set-dark.js | 5 + content/fsdocs-theme-toggle.js | 38 + content/fsdocs-theme.css | 1 + content/fsdocs-theme.js | 35 + content/fsdocs-tips.js | 59 + content/img/github-pages-settings.png | Bin 0 -> 33534 bytes img/logo.png | Bin 0 -> 31302 bytes index.fsx | 88 + index.html | 292 + index.json | 1 + reference/fsharp-control-async.html | 780 + reference/fsharp-control-asyncextensions.html | 327 + reference/fsharp-control-debug.html | 448 + reference/fsharp-control-highpriority.html | 412 + reference/fsharp-control-internal.html | 470 + reference/fsharp-control-lowpriority.html | 319 + reference/fsharp-control-mediumpriority.html | 659 + reference/fsharp-control-resumabletsc-1.html | 208 + reference/fsharp-control-task.html | 1135 + reference/fsharp-control-taskextensions.html | 332 + reference/fsharp-control-taskseq-1-0.html | 205 + reference/fsharp-control-taskseq-1.html | 208 + reference/fsharp-control-taskseq-2.html | 505 + reference/fsharp-control-taskseq.html | 21497 ++++++++++++++++ reference/fsharp-control-taskseqbase-1.html | 357 + reference/fsharp-control-taskseqbuilder.html | 1136 + .../fsharp-control-taskseqbuildermodule.html | 285 + .../fsharp-control-taskseqdynamic-1.html | 480 + .../fsharp-control-taskseqdynamicbuilder.html | 276 + ...p-control-taskseqdynamicbuildermodule.html | 284 + .../fsharp-control-taskseqdynamicinfo-1.html | 299 + ...arp-control-taskseqextensions-taskseq.html | 1099 + .../fsharp-control-taskseqextensions.html | 244 + ...ontrol-taskseqresumptiondynamicinfo-1.html | 316 + ...sharp-control-taskseqresumptionfunc-1.html | 208 + .../fsharp-control-taskseqstatemachine-1.html | 211 + ...arp-control-taskseqstatemachinedata-1.html | 848 + reference/fsharp-control-valuetask.html | 713 + .../fsharp-control-valuetaskextensions.html | 312 + reference/fsharp-control.html | 1069 + reference/index.html | 199 + 58 files changed, 41833 insertions(+) create mode 100644 .nojekyll create mode 100755 Dockerfile create mode 100755 NuGet.config create mode 100644 TaskSeqAdvanced.fsx create mode 100644 TaskSeqAdvanced.html create mode 100644 TaskSeqCombining.fsx create mode 100644 TaskSeqCombining.html create mode 100644 TaskSeqConsuming.fsx create mode 100644 TaskSeqConsuming.html create mode 100644 TaskSeqGenerating.fsx create mode 100644 TaskSeqGenerating.html create mode 100644 TaskSeqTransforming.fsx create mode 100644 TaskSeqTransforming.html create mode 100755 content/fsdocs-default.css create mode 100755 content/fsdocs-details-set-expanded.js create mode 100755 content/fsdocs-details-toggle.js create mode 100755 content/fsdocs-search.js create mode 100755 content/fsdocs-theme-set-dark.js create mode 100755 content/fsdocs-theme-toggle.js create mode 100755 content/fsdocs-theme.css create mode 100755 content/fsdocs-theme.js create mode 100755 content/fsdocs-tips.js create mode 100755 content/img/github-pages-settings.png create mode 100644 img/logo.png create mode 100644 index.fsx create mode 100644 index.html create mode 100644 index.json create mode 100644 reference/fsharp-control-async.html create mode 100644 reference/fsharp-control-asyncextensions.html create mode 100644 reference/fsharp-control-debug.html create mode 100644 reference/fsharp-control-highpriority.html create mode 100644 reference/fsharp-control-internal.html create mode 100644 reference/fsharp-control-lowpriority.html create mode 100644 reference/fsharp-control-mediumpriority.html create mode 100644 reference/fsharp-control-resumabletsc-1.html create mode 100644 reference/fsharp-control-task.html create mode 100644 reference/fsharp-control-taskextensions.html create mode 100644 reference/fsharp-control-taskseq-1-0.html create mode 100644 reference/fsharp-control-taskseq-1.html create mode 100644 reference/fsharp-control-taskseq-2.html create mode 100644 reference/fsharp-control-taskseq.html create mode 100644 reference/fsharp-control-taskseqbase-1.html create mode 100644 reference/fsharp-control-taskseqbuilder.html create mode 100644 reference/fsharp-control-taskseqbuildermodule.html create mode 100644 reference/fsharp-control-taskseqdynamic-1.html create mode 100644 reference/fsharp-control-taskseqdynamicbuilder.html create mode 100644 reference/fsharp-control-taskseqdynamicbuildermodule.html create mode 100644 reference/fsharp-control-taskseqdynamicinfo-1.html create mode 100644 reference/fsharp-control-taskseqextensions-taskseq.html create mode 100644 reference/fsharp-control-taskseqextensions.html create mode 100644 reference/fsharp-control-taskseqresumptiondynamicinfo-1.html create mode 100644 reference/fsharp-control-taskseqresumptionfunc-1.html create mode 100644 reference/fsharp-control-taskseqstatemachine-1.html create mode 100644 reference/fsharp-control-taskseqstatemachinedata-1.html create mode 100644 reference/fsharp-control-valuetask.html create mode 100644 reference/fsharp-control-valuetaskextensions.html create mode 100644 reference/fsharp-control.html create mode 100644 reference/index.html diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 00000000..e69de29b diff --git a/Dockerfile b/Dockerfile new file mode 100755 index 00000000..989c9abb --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM mcr.microsoft.com/dotnet/sdk:7.0 + +RUN apt-get update \ + && apt-get -y upgrade \ + && apt-get -y install python3 python3-pip python3-dev ipython3 + +RUN python3 -m pip install --no-cache-dir notebook jupyterlab + +ARG NB_USER=fsdocs-user +ARG NB_UID=1000 +ENV USER ${NB_USER} +ENV NB_UID ${NB_UID} +ENV HOME /home/${NB_USER} + +RUN adduser --disabled-password \ + --gecos "Default user" \ + --uid ${NB_UID} \ + ${NB_USER} + +COPY . ${HOME} +USER root +RUN chown -R ${NB_UID} ${HOME} +USER ${NB_USER} + +ENV PATH="${PATH}:$HOME/.dotnet/tools/" + +RUN dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.410202 + +RUN dotnet-interactive jupyter install diff --git a/NuGet.config b/NuGet.config new file mode 100755 index 00000000..cf1ace51 --- /dev/null +++ b/NuGet.config @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TaskSeqAdvanced.fsx b/TaskSeqAdvanced.fsx new file mode 100644 index 00000000..bd250d2f --- /dev/null +++ b/TaskSeqAdvanced.fsx @@ -0,0 +1,251 @@ +(** + +*) +#r "nuget: FSharp.Control.TaskSeq,1.1.1" +(** +# Advanced Task Sequence Operations + +This page covers advanced `TaskSeq<'T>` operations: grouping, stateful transformation with +`mapFold` and `threadState`, deduplication, set-difference, partitioning, counting by key, lexicographic +comparison, cancellation, and positional editing. + +*) +open System.Threading +open System.Threading.Tasks +open FSharp.Control +(** +----------------------- + +## groupBy and groupByAsync + +`TaskSeq.groupBy` partitions a sequence into groups by a key-projection function. The result +is an array of `(key, elements[])` pairs, one per distinct key, in order of first occurrence. + +> **Note:** `groupBy` consumes the entire source before returning. Do not use it on +potentially infinite sequences. +> + +*) +type Event = { EntityId: int; Payload: string } + +let events : TaskSeq = + TaskSeq.ofList + [ { EntityId = 1; Payload = "A" } + { EntityId = 2; Payload = "B" } + { EntityId = 1; Payload = "C" } + { EntityId = 3; Payload = "D" } + { EntityId = 2; Payload = "E" } ] + +// groups: (1, [A;C]), (2, [B;E]), (3, [D]) +let grouped : Task<(int * Event[])[]> = + events |> TaskSeq.groupBy (fun e -> e.EntityId) +(** +`TaskSeq.groupByAsync` accepts an async key projection: + +*) +let groupedAsync : Task<(int * Event[])[]> = + events |> TaskSeq.groupByAsync (fun e -> task { return e.EntityId }) +(** +----------------------- + +## countBy and countByAsync + +`TaskSeq.countBy` counts how many elements map to each key, returning `(key, count)[]`: + +*) +let counts : Task<(int * int)[]> = + events |> TaskSeq.countBy (fun e -> e.EntityId) +// (1,2), (2,2), (3,1) +(** +----------------------- + +## mapFold and mapFoldAsync + +`TaskSeq.mapFold` threads a state accumulator through a sequence while simultaneously mapping +each element to a result value. The output is a task returning a pair of `(result[], finalState)`: + +*) +// Number each word sequentially while building a running concatenation +let words : TaskSeq = + TaskSeq.ofList [ "hello"; "world"; "foo" ] + +let numbered : Task = + words + |> TaskSeq.mapFold (fun count w -> $"{count}: {w}", count + 1) 0 + +// result: ([| "0: hello"; "1: world"; "2: foo" |], 3) +(** +`TaskSeq.mapFoldAsync` is the same but the mapping function returns `Task<'Result * 'State>`. + +----------------------- + +## threadState and threadStateAsync + +`TaskSeq.threadState` is the lazy, streaming counterpart to `mapFold`. It threads a state +accumulator through the sequence while yielding each mapped result — but unlike `mapFold` it +never materialises the results into an array, and it discards the final state. This makes it +suitable for infinite sequences and pipelines where intermediate results should be streamed rather +than buffered: + +*) +let numbers : TaskSeq = TaskSeq.ofSeq (seq { 1..5 }) + +// Produce a running total without collecting the whole sequence first +let runningSum : TaskSeq = + numbers + |> TaskSeq.threadState (fun acc x -> acc + x, acc + x) 0 + +// yields lazily: 1, 3, 6, 10, 15 +(** +Compare with `scan`, which also emits a running result but prepends the initial state: + +```fsharp +let viaScan = numbers |> TaskSeq.scan (fun acc x -> acc + x) 0 +// yields: 0, 1, 3, 6, 10, 15 (one extra initial element) + +let viaThreadState = numbers |> TaskSeq.threadState (fun acc x -> acc + x, acc + x) 0 +// yields: 1, 3, 6, 10, 15 (no initial element; result == new state here) +``` + +`TaskSeq.threadStateAsync` accepts an asynchronous folder: + +*) +let asyncRunningSum : TaskSeq = + numbers + |> TaskSeq.threadStateAsync (fun acc x -> Task.fromResult (acc + x, acc + x)) 0 +(** +`TaskSeq.scan` is the streaming sibling of `fold`: it emits each intermediate state as a new +element, starting with the initial state: + +*) +let runningTotals : TaskSeq = + numbers |> TaskSeq.scan (fun acc n -> acc + n) 0 + +// yields: 0, 1, 3, 6, 10, 15 +(** +----------------------- + +## distinct and distinctBy + +`TaskSeq.distinct` removes duplicates (keeps first occurrence), using generic equality: + +*) +let withDups : TaskSeq = TaskSeq.ofList [ 1; 2; 2; 3; 1; 4 ] + +let deduped : TaskSeq = withDups |> TaskSeq.distinct // 1, 2, 3, 4 +(** +`TaskSeq.distinctBy` deduplicates by a key projection: + +*) +let strings : TaskSeq = + TaskSeq.ofList [ "hello"; "HELLO"; "world"; "WORLD" ] + +let caseInsensitiveDistinct : TaskSeq = + strings |> TaskSeq.distinctBy (fun s -> s.ToLowerInvariant()) +// "hello", "world" +(** +> **Note:** both `distinct` and `distinctBy` buffer all unique keys in a hash set. Do not use +them on potentially infinite sequences. +> + +`TaskSeq.distinctByAsync` accepts an async key projection. + +----------------------- + +## distinctUntilChanged + +`TaskSeq.distinctUntilChanged` removes consecutive duplicates only — it does not buffer the +whole sequence, so it is safe on infinite streams: + +*) +let run : TaskSeq = TaskSeq.ofList [ 1; 1; 2; 2; 2; 3; 1; 1 ] + +let noConsecDups : TaskSeq = run |> TaskSeq.distinctUntilChanged +// 1, 2, 3, 1 +(** +----------------------- + +## except and exceptOfSeq + +`TaskSeq.except itemsToExclude source` returns elements of `source` that do not appear in +`itemsToExclude`. The exclusion set is materialised eagerly before iteration: + +*) +let exclusions : TaskSeq = TaskSeq.ofList [ 2; 4 ] +let source : TaskSeq = TaskSeq.ofSeq (seq { 1..5 }) + +let filtered : TaskSeq = TaskSeq.except exclusions source // 1, 3, 5 +(** +`TaskSeq.exceptOfSeq` accepts a plain `seq<'T>` as the exclusion set. + +----------------------- + +## partition and partitionAsync + +`TaskSeq.partition` splits the sequence into two arrays in a single pass. Elements for which +the predicate returns `true` go into the first array; the rest into the second: + +*) +let partitioned : Task = + source |> TaskSeq.partition (fun n -> n % 2 = 0) +// trueItems: [|2;4|] falseItems: [|1;3;5|] +(** +`TaskSeq.partitionAsync` accepts an async predicate. + +----------------------- + +## compareWith and compareWithAsync + +`TaskSeq.compareWith` performs a lexicographic comparison of two sequences using a custom +comparer. It returns the first non-zero comparison result, or `0` if the sequences are +element-wise equal and have the same length: + +*) +let a : TaskSeq = TaskSeq.ofList [ 1; 2; 3 ] +let b : TaskSeq = TaskSeq.ofList [ 1; 2; 4 ] + +let cmp : Task = + TaskSeq.compareWith (fun x y -> compare x y) a b +// negative (a < b) +(** +`TaskSeq.compareWithAsync` accepts an async comparer. + +----------------------- + +## withCancellation + +`TaskSeq.withCancellation token source` injects a `CancellationToken` into the underlying +`IAsyncEnumerable<'T>`. This is equivalent to calling `.WithCancellation(token)` in C# and +is useful when consuming sequences from libraries (e.g. Entity Framework Core) that require a +token at the enumeration site: + +*) +let cts = new CancellationTokenSource() + +let cancellable : TaskSeq = + source |> TaskSeq.withCancellation cts.Token +(** +----------------------- + +## Positional editing + +`TaskSeq.insertAt`, `TaskSeq.insertManyAt`, `TaskSeq.removeAt`, `TaskSeq.removeManyAt`, and +`TaskSeq.updateAt` produce new sequences with an element inserted, removed, or replaced at a +given zero-based index: + +*) +let original : TaskSeq = TaskSeq.ofList [ 1; 2; 4; 5 ] + +let inserted : TaskSeq = original |> TaskSeq.insertAt 2 3 // 1,2,3,4,5 + +let removed : TaskSeq = original |> TaskSeq.removeAt 1 // 1,4,5 + +let updated : TaskSeq = original |> TaskSeq.updateAt 0 99 // 99,2,4,5 + +let manyInserted : TaskSeq = + original + |> TaskSeq.insertManyAt 2 (TaskSeq.ofList [ 10; 11 ]) +// 1, 2, 10, 11, 4, 5 + +let manyRemoved : TaskSeq = original |> TaskSeq.removeManyAt 1 2 // 1, 5 + diff --git a/TaskSeqAdvanced.html b/TaskSeqAdvanced.html new file mode 100644 index 00000000..71415bd0 --- /dev/null +++ b/TaskSeqAdvanced.html @@ -0,0 +1,571 @@ + + + + + + + + + + + + + + + + + + + + + Advanced Task Sequence Operations | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
+
+ + + Header menu logo + FSharp.Control.TaskSeq + +
+
+ + + + + +
+
+ +
+
+ +

Advanced Task Sequence Operations

+

This page covers advanced TaskSeq<'T> operations: grouping, stateful transformation with +mapFold and threadState, deduplication, set-difference, partitioning, counting by key, lexicographic +comparison, cancellation, and positional editing.

+
open System.Threading
+open System.Threading.Tasks
+open FSharp.Control
+
+
+

groupBy and groupByAsync

+

TaskSeq.groupBy partitions a sequence into groups by a key-projection function. The result +is an array of (key, elements[]) pairs, one per distinct key, in order of first occurrence.

+
+

Note: groupBy consumes the entire source before returning. Do not use it on +potentially infinite sequences.

+
+
type Event = { EntityId: int; Payload: string }
+
+let events : TaskSeq<Event> =
+    TaskSeq.ofList
+        [ { EntityId = 1; Payload = "A" }
+          { EntityId = 2; Payload = "B" }
+          { EntityId = 1; Payload = "C" }
+          { EntityId = 3; Payload = "D" }
+          { EntityId = 2; Payload = "E" } ]
+
+// groups: (1, [A;C]), (2, [B;E]), (3, [D])
+let grouped : Task<(int * Event[])[]> =
+    events |> TaskSeq.groupBy (fun e -> e.EntityId)
+
+

TaskSeq.groupByAsync accepts an async key projection:

+
let groupedAsync : Task<(int * Event[])[]> =
+    events |> TaskSeq.groupByAsync (fun e -> task { return e.EntityId })
+
+
+

countBy and countByAsync

+

TaskSeq.countBy counts how many elements map to each key, returning (key, count)[]:

+
let counts : Task<(int * int)[]> =
+    events |> TaskSeq.countBy (fun e -> e.EntityId)
+// (1,2), (2,2), (3,1)
+
+
+

mapFold and mapFoldAsync

+

TaskSeq.mapFold threads a state accumulator through a sequence while simultaneously mapping +each element to a result value. The output is a task returning a pair of (result[], finalState):

+
// Number each word sequentially while building a running concatenation
+let words : TaskSeq<string> =
+    TaskSeq.ofList [ "hello"; "world"; "foo" ]
+
+let numbered : Task<string[] * int> =
+    words
+    |> TaskSeq.mapFold (fun count w -> $"{count}: {w}", count + 1) 0
+
+// result: ([| "0: hello"; "1: world"; "2: foo" |], 3)
+
+

TaskSeq.mapFoldAsync is the same but the mapping function returns Task<'Result * 'State>.

+
+

threadState and threadStateAsync

+

TaskSeq.threadState is the lazy, streaming counterpart to mapFold. It threads a state +accumulator through the sequence while yielding each mapped result — but unlike mapFold it +never materialises the results into an array, and it discards the final state. This makes it +suitable for infinite sequences and pipelines where intermediate results should be streamed rather +than buffered:

+
let numbers : TaskSeq<int> = TaskSeq.ofSeq (seq { 1..5 })
+
+// Produce a running total without collecting the whole sequence first
+let runningSum : TaskSeq<int> =
+    numbers
+    |> TaskSeq.threadState (fun acc x -> acc + x, acc + x) 0
+
+// yields lazily: 1, 3, 6, 10, 15
+
+

Compare with scan, which also emits a running result but prepends the initial state:

+
let viaScan = numbers |> TaskSeq.scan (fun acc x -> acc + x) 0
+// yields: 0, 1, 3, 6, 10, 15  (one extra initial element)
+
+let viaThreadState = numbers |> TaskSeq.threadState (fun acc x -> acc + x, acc + x) 0
+// yields: 1, 3, 6, 10, 15  (no initial element; result == new state here)
+
+

TaskSeq.threadStateAsync accepts an asynchronous folder:

+
let asyncRunningSum : TaskSeq<int> =
+    numbers
+    |> TaskSeq.threadStateAsync (fun acc x -> Task.fromResult (acc + x, acc + x)) 0
+
+

TaskSeq.scan is the streaming sibling of fold: it emits each intermediate state as a new +element, starting with the initial state:

+
let runningTotals : TaskSeq<int> =
+    numbers |> TaskSeq.scan (fun acc n -> acc + n) 0
+
+// yields: 0, 1, 3, 6, 10, 15
+
+
+

distinct and distinctBy

+

TaskSeq.distinct removes duplicates (keeps first occurrence), using generic equality:

+
let withDups : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 2; 3; 1; 4 ]
+
+let deduped : TaskSeq<int> = withDups |> TaskSeq.distinct // 1, 2, 3, 4
+
+

TaskSeq.distinctBy deduplicates by a key projection:

+
let strings : TaskSeq<string> =
+    TaskSeq.ofList [ "hello"; "HELLO"; "world"; "WORLD" ]
+
+let caseInsensitiveDistinct : TaskSeq<string> =
+    strings |> TaskSeq.distinctBy (fun s -> s.ToLowerInvariant())
+// "hello", "world"
+
+
+

Note: both distinct and distinctBy buffer all unique keys in a hash set. Do not use +them on potentially infinite sequences.

+
+

TaskSeq.distinctByAsync accepts an async key projection.

+
+

distinctUntilChanged

+

TaskSeq.distinctUntilChanged removes consecutive duplicates only — it does not buffer the +whole sequence, so it is safe on infinite streams:

+
let run : TaskSeq<int> = TaskSeq.ofList [ 1; 1; 2; 2; 2; 3; 1; 1 ]
+
+let noConsecDups : TaskSeq<int> = run |> TaskSeq.distinctUntilChanged
+// 1, 2, 3, 1
+
+
+

except and exceptOfSeq

+

TaskSeq.except itemsToExclude source returns elements of source that do not appear in +itemsToExclude. The exclusion set is materialised eagerly before iteration:

+
let exclusions : TaskSeq<int> = TaskSeq.ofList [ 2; 4 ]
+let source : TaskSeq<int> = TaskSeq.ofSeq (seq { 1..5 })
+
+let filtered : TaskSeq<int> = TaskSeq.except exclusions source // 1, 3, 5
+
+

TaskSeq.exceptOfSeq accepts a plain seq<'T> as the exclusion set.

+
+

partition and partitionAsync

+

TaskSeq.partition splits the sequence into two arrays in a single pass. Elements for which +the predicate returns true go into the first array; the rest into the second:

+
let partitioned : Task<int[] * int[]> =
+    source |> TaskSeq.partition (fun n -> n % 2 = 0)
+// trueItems: [|2;4|]   falseItems: [|1;3;5|]
+
+

TaskSeq.partitionAsync accepts an async predicate.

+
+

compareWith and compareWithAsync

+

TaskSeq.compareWith performs a lexicographic comparison of two sequences using a custom +comparer. It returns the first non-zero comparison result, or 0 if the sequences are +element-wise equal and have the same length:

+
let a : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 3 ]
+let b : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 4 ]
+
+let cmp : Task<int> =
+    TaskSeq.compareWith (fun x y -> compare x y) a b
+// negative (a < b)
+
+

TaskSeq.compareWithAsync accepts an async comparer.

+
+

withCancellation

+

TaskSeq.withCancellation token source injects a CancellationToken into the underlying +IAsyncEnumerable<'T>. This is equivalent to calling .WithCancellation(token) in C# and +is useful when consuming sequences from libraries (e.g. Entity Framework Core) that require a +token at the enumeration site:

+
let cts = new CancellationTokenSource()
+
+let cancellable : TaskSeq<int> =
+    source |> TaskSeq.withCancellation cts.Token
+
+
+

Positional editing

+

TaskSeq.insertAt, TaskSeq.insertManyAt, TaskSeq.removeAt, TaskSeq.removeManyAt, and +TaskSeq.updateAt produce new sequences with an element inserted, removed, or replaced at a +given zero-based index:

+
let original : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 4; 5 ]
+
+let inserted : TaskSeq<int> = original |> TaskSeq.insertAt 2 3 // 1,2,3,4,5
+
+let removed : TaskSeq<int> = original |> TaskSeq.removeAt 1 // 1,4,5
+
+let updated : TaskSeq<int> = original |> TaskSeq.updateAt 0 99 // 99,2,4,5
+
+let manyInserted : TaskSeq<int> =
+    original
+    |> TaskSeq.insertManyAt 2 (TaskSeq.ofList [ 10; 11 ])
+// 1, 2, 10, 11, 4, 5
+
+let manyRemoved : TaskSeq<int> = original |> TaskSeq.removeManyAt 1 2 // 1, 5
+
+ +
namespace System
+
namespace System.Threading
+
namespace System.Threading.Tasks
+
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
+
Multiple items
namespace FSharp.Control

--------------------
namespace Microsoft.FSharp.Control
+
Multiple items
module Event + +from Microsoft.FSharp.Control

--------------------
type Event = + { + EntityId: int + Payload: string + }

--------------------
type Event<'T> = + new: unit -> Event<'T> + member Trigger: arg: 'T -> unit + member Publish: IEvent<'T> with get

--------------------
type Event<'Delegate,'Args (requires delegate and 'Delegate :> Delegate and reference type)> = + new: unit -> Event<'Delegate,'Args> + member Trigger: sender: objnull * args: 'Args -> unit + member Publish: IEvent<'Delegate,'Args> with get

--------------------
new: unit -> Event<'T>

--------------------
new: unit -> Event<'Delegate,'Args>
+
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 events: TaskSeq<Event>
+
Multiple items
module TaskSeq + +from FSharp.Control.TaskSeqExtensions

--------------------
type TaskSeq = + static member append: source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> TaskSeq<'T> + static member appendSeq: source1: TaskSeq<'T> -> source2: 'T seq -> TaskSeq<'T> + static member box: source: TaskSeq<'T> -> TaskSeq<obj> + static member cast: source: TaskSeq<obj> -> TaskSeq<'U> + static member choose: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseAsync: chooser: ('T -> #Task<'U option>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseV: chooser: ('T -> 'U voption) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseVAsync: chooser: ('T -> #Task<'U voption>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chunkBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + static member chunkByAsync: projection: ('T -> #Task<'Key>) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + ...

--------------------
type TaskSeq<'T> = System.Collections.Generic.IAsyncEnumerable<'T>
<summary> + Represents a task sequence and is the output of using the <paramref name="taskSeq{...}" /> + computation expression from this library. It is an alias for <see cref="T:System.IAsyncEnumerable&lt;_&gt;" />. + </summary>

--------------------
type TaskSeq<'Machine,'T (requires 'Machine :> IAsyncStateMachine and 'Machine :> IResumableStateMachine<TaskSeqStateMachineData<'T>>)> = + inherit TaskSeqBase<'T> + interface IValueTaskSource + interface IValueTaskSource<bool> + interface IAsyncStateMachine + interface IAsyncEnumerable<'T> + interface IAsyncEnumerator<'T> + new: unit -> TaskSeq<'Machine,'T> + member InitMachineData: ct: CancellationToken * machine: byref<'Machine> -> unit + override MoveNextAsyncResult: unit -> ValueTask<bool>
<summary> + Main implementation of generic <see cref="T:System.IAsyncEnumerable&lt;'T&gt;" /> and related interfaces, + which forms the meat of the logic behind <see cref="taskSeq" /> computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + </summary>

--------------------
new: unit -> TaskSeq<'Machine,'T>
+
static member TaskSeq.ofList: source: 'T list -> TaskSeq<'T>
+
val grouped: Task<(int * Event array) array>
+
Multiple items
type Task = + interface IAsyncResult + interface IDisposable + new: action: Action -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable + 1 overload + member ContinueWith: continuationAction: Action<Task,obj> * state: obj -> Task + 19 overloads + member Dispose: unit -> unit + member GetAwaiter: unit -> TaskAwaiter + member RunSynchronously: unit -> unit + 1 overload + member Start: unit -> unit + 1 overload + member Wait: unit -> unit + 5 overloads + ...
<summary>Represents an asynchronous operation.</summary>

--------------------
type Task<'TResult> = + inherit Task + new: ``function`` : Func<obj,'TResult> * state: obj -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable<'TResult> + 1 overload + member ContinueWith: continuationAction: Action<Task<'TResult>,obj> * state: obj -> Task + 19 overloads + member GetAwaiter: unit -> TaskAwaiter<'TResult> + member WaitAsync: cancellationToken: CancellationToken -> Task<'TResult> + 4 overloads + member Result: 'TResult + static member Factory: TaskFactory<'TResult>
<summary>Represents an asynchronous operation that can return a value.</summary>
<typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>

--------------------
Task(action: System.Action) : Task
Task(action: System.Action, cancellationToken: CancellationToken) : Task
Task(action: System.Action, creationOptions: TaskCreationOptions) : Task
Task(action: System.Action<obj>, state: obj) : Task
Task(action: System.Action, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task
Task(action: System.Action<obj>, state: obj, cancellationToken: CancellationToken) : Task
Task(action: System.Action<obj>, state: obj, creationOptions: TaskCreationOptions) : Task
Task(action: System.Action<obj>, state: obj, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task

--------------------
Task(``function`` : System.Func<'TResult>) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj) : Task<'TResult>
Task(``function`` : System.Func<'TResult>, cancellationToken: CancellationToken) : Task<'TResult>
Task(``function`` : System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : System.Func<'TResult>, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
+
static member TaskSeq.groupBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> Task<('Key * 'T array) array> (requires equality)
+
val e: Event
+
Event.EntityId: int
+
val groupedAsync: Task<(int * Event array) array>
+
static member TaskSeq.groupByAsync: projection: ('T -> #Task<'Key>) -> source: TaskSeq<'T> -> Task<('Key * 'T array) array> (requires equality)
+
val task: TaskBuilder
+
val counts: Task<(int * int) array>
+
static member TaskSeq.countBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> Task<('Key * int) array> (requires equality)
+
val words: TaskSeq<string>
+
val numbered: Task<string array * int>
+
static member TaskSeq.mapFold: mapping: ('State -> 'T -> 'Result * 'State) -> state: 'State -> source: TaskSeq<'T> -> Task<'Result array * 'State>
+
val count: int
+
val w: string
+
val numbers: TaskSeq<int>
+
static member TaskSeq.ofSeq: source: 'T seq -> TaskSeq<'T>
+
Multiple items
val seq: sequence: 'T seq -> 'T seq

--------------------
type 'T seq = System.Collections.Generic.IEnumerable<'T>
+
val runningSum: TaskSeq<int>
+
static member TaskSeq.threadState: folder: ('State -> 'T -> 'Result * 'State) -> state: 'State -> source: TaskSeq<'T> -> TaskSeq<'Result>
+
val acc: int
+
val x: int
+
val viaScan: obj
+
val viaThreadState: obj
+
val asyncRunningSum: TaskSeq<int>
+
static member TaskSeq.threadStateAsync: folder: ('State -> 'T -> #Task<'Result * 'State>) -> state: 'State -> source: TaskSeq<'T> -> TaskSeq<'Result>
+
val fromResult: value: 'U -> Task<'U>
<summary> + Creates a Task&lt;'U&gt; that's completed successfully with the specified result. +</summary>
+
val runningTotals: TaskSeq<int>
+
static member TaskSeq.scan: folder: ('State -> 'T -> 'State) -> state: 'State -> source: TaskSeq<'T> -> TaskSeq<'State>
+
val n: int
+
val withDups: TaskSeq<int>
+
val deduped: TaskSeq<int>
+
static member TaskSeq.distinct: source: TaskSeq<'T> -> TaskSeq<'T> (requires equality)
+
val strings: TaskSeq<string>
+
val caseInsensitiveDistinct: TaskSeq<string>
+
static member TaskSeq.distinctBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'T> (requires equality)
+
val s: string
+
System.String.ToLowerInvariant() : string
+
val run: TaskSeq<int>
+
val noConsecDups: TaskSeq<int>
+
static member TaskSeq.distinctUntilChanged: source: TaskSeq<'T> -> TaskSeq<'T> (requires equality)
+
val exclusions: TaskSeq<int>
+
val source: TaskSeq<int>
+
val filtered: TaskSeq<int>
+
static member TaskSeq.except: itemsToExclude: TaskSeq<'T> -> source: TaskSeq<'T> -> TaskSeq<'T> (requires equality)
+
val partitioned: Task<int array * int array>
+
static member TaskSeq.partition: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<'T array * 'T array>
+
val a: TaskSeq<int>
+
val b: TaskSeq<int>
+
val cmp: Task<int>
+
static member TaskSeq.compareWith: comparer: ('T -> 'T -> int) -> source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> Task<int>
+
val y: int
+
val compare: e1: 'T -> e2: 'T -> int (requires comparison)
+
val cts: CancellationTokenSource
+
Multiple items
type CancellationTokenSource = + interface IDisposable + new: unit -> unit + 3 overloads + member Cancel: unit -> unit + 1 overload + member CancelAfter: millisecondsDelay: int -> unit + 1 overload + member CancelAsync: unit -> Task + member Dispose: unit -> unit + member TryReset: unit -> bool + static member CreateLinkedTokenSource: token: CancellationToken -> CancellationTokenSource + 3 overloads + member IsCancellationRequested: bool + member Token: CancellationToken
<summary>Signals to a <see cref="T:System.Threading.CancellationToken" /> that it should be canceled.</summary>

--------------------
CancellationTokenSource() : CancellationTokenSource
CancellationTokenSource(millisecondsDelay: int) : CancellationTokenSource
CancellationTokenSource(delay: System.TimeSpan) : CancellationTokenSource
CancellationTokenSource(delay: System.TimeSpan, timeProvider: System.TimeProvider) : CancellationTokenSource
+
val cancellable: TaskSeq<int>
+
static member TaskSeq.withCancellation: cancellationToken: CancellationToken -> source: TaskSeq<'T> -> TaskSeq<'T>
+
property CancellationTokenSource.Token: CancellationToken with get
<summary>Gets the <see cref="T:System.Threading.CancellationToken" /> associated with this <see cref="T:System.Threading.CancellationTokenSource" />.</summary>
<exception cref="T:System.ObjectDisposedException">The token source has been disposed.</exception>
<returns>The <see cref="T:System.Threading.CancellationToken" /> associated with this <see cref="T:System.Threading.CancellationTokenSource" />.</returns>
+
val original: TaskSeq<int>
+
val inserted: TaskSeq<int>
+
static member TaskSeq.insertAt: index: int -> value: 'T -> source: TaskSeq<'T> -> TaskSeq<'T>
+
val removed: TaskSeq<int>
+
static member TaskSeq.removeAt: index: int -> source: TaskSeq<'T> -> TaskSeq<'T>
+
val updated: TaskSeq<int>
+
static member TaskSeq.updateAt: index: int -> value: 'T -> source: TaskSeq<'T> -> TaskSeq<'T>
+
val manyInserted: TaskSeq<int>
+
static member TaskSeq.insertManyAt: index: int -> values: TaskSeq<'T> -> source: TaskSeq<'T> -> TaskSeq<'T>
+
val manyRemoved: TaskSeq<int>
+
static member TaskSeq.removeManyAt: index: int -> count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
+ +
+
+ + + +
+
    +

    Type something to start searching.

    +
    +     + + + + + + + + \ No newline at end of file diff --git a/TaskSeqCombining.fsx b/TaskSeqCombining.fsx new file mode 100644 index 00000000..c94e53eb --- /dev/null +++ b/TaskSeqCombining.fsx @@ -0,0 +1,264 @@ +(** + +*) +#r "nuget: FSharp.Control.TaskSeq,1.1.1" +(** +# Combining Task Sequences + +This page covers operations that combine multiple sequences or reshape a single sequence: append, +zip, zipWith, concat, slicing with take/skip/splitAt, chunking and windowing. + +*) +open FSharp.Control +(** +----------------------- + +## Append + +`TaskSeq.append` produces all elements of the first sequence followed by all elements of the +second. The second sequence does not start until the first is exhausted: + +*) +let first = TaskSeq.ofList [ 1; 2; 3 ] +let second = TaskSeq.ofList [ 4; 5; 6 ] + +let appended : TaskSeq = TaskSeq.append first second // 1, 2, 3, 4, 5, 6 +(** +Inside `taskSeq { ... }`, `yield!` is the natural way to concatenate: + +*) +let combined = taskSeq { + yield! first + yield! second +} +(** +`TaskSeq.appendSeq` appends a plain `seq<'T>` after a task sequence. +`TaskSeq.prependSeq` prepends a plain `seq<'T>` before a task sequence: + +*) +let withPrefix : TaskSeq = TaskSeq.prependSeq [ 0 ] first // 0, 1, 2, 3 +let withSuffix : TaskSeq = TaskSeq.appendSeq first [ 4; 5 ] // 1, 2, 3, 4, 5 +(** +----------------------- + +## concat + +`TaskSeq.concat` flattens a task sequence of task sequences into a single flat sequence. +Each inner sequence is consumed fully before the next one begins: + +*) +let nested : TaskSeq> = + TaskSeq.ofList + [ TaskSeq.ofList [ 1; 2 ] + TaskSeq.ofList [ 3; 4 ] + TaskSeq.ofList [ 5; 6 ] ] + +let flat : TaskSeq = TaskSeq.concat nested // 1, 2, 3, 4, 5, 6 +(** +Overloads also exist for `TaskSeq>`, `TaskSeq<'T list>`, `TaskSeq<'T[]>`, and +`TaskSeq>`. + +----------------------- + +## zip and zip3 + +`TaskSeq.zip` pairs up elements from two sequences, stopping when the shorter sequence ends: + +*) +let letters : TaskSeq = TaskSeq.ofList [ 'a'; 'b'; 'c' ] +let nums : TaskSeq = TaskSeq.ofList [ 1; 2; 3; 4 ] + +let pairs : TaskSeq = TaskSeq.zip letters nums +// ('a',1), ('b',2), ('c',3) — stops when letters runs out +(** +`TaskSeq.zip3` does the same for three sequences: + +*) +let booleans : TaskSeq = TaskSeq.ofList [ true; false; true ] + +let triples : TaskSeq = TaskSeq.zip3 letters nums booleans +(** +----------------------- + +## zipWith and zipWithAsync + +`TaskSeq.zipWith` is like `zip` but applies a mapping function to produce a result instead of +yielding a tuple. The result sequence stops when the shorter source ends: + +*) +let addPairs : TaskSeq = TaskSeq.zipWith (+) nums nums +// 2, 4, 6, 8 +(** +`TaskSeq.zipWithAsync` accepts an asynchronous mapping function: + +*) +let asyncProduct : TaskSeq = + TaskSeq.zipWithAsync (fun a b -> Task.fromResult (a * b)) nums nums +// 1, 4, 9, 16, ... +(** +----------------------- + +## zipWith3 and zipWithAsync3 + +`TaskSeq.zipWith3` combines three sequences with a three-argument mapping function, stopping at +the shortest: + +*) +let sumThree : TaskSeq = + TaskSeq.zipWith3 (fun a b c -> a + b + c) nums nums nums +// 3, 6, 9, 12, ... +(** +`TaskSeq.zipWithAsync3` takes an asynchronous three-argument mapper: + +*) +let asyncSumThree : TaskSeq = + TaskSeq.zipWithAsync3 (fun a b c -> Task.fromResult (a + b + c)) nums nums nums +(** +----------------------- + +## pairwise + +`TaskSeq.pairwise` produces a sequence of consecutive pairs. An input with fewer than two elements +produces an empty result: + +*) +let consecutive : TaskSeq = TaskSeq.ofList [ 1; 2; 3; 4; 5 ] + +let pairs2 : TaskSeq = consecutive |> TaskSeq.pairwise +// (1,2), (2,3), (3,4), (4,5) +(** +----------------------- + +## take and truncate + +`TaskSeq.take count` yields exactly `count` elements and throws if the source is shorter: + +*) +let first3 : TaskSeq = consecutive |> TaskSeq.take 3 // 1, 2, 3 +(** +`TaskSeq.truncate count` yields **at most** `count` elements without throwing when the source is +shorter: + +*) +let atMost10 : TaskSeq = consecutive |> TaskSeq.truncate 10 // 1, 2, 3, 4, 5 +(** +----------------------- + +## splitAt + +`TaskSeq.splitAt count` splits a sequence into a prefix array and a lazy remainder sequence. The +prefix always contains **at most** `count` elements — it never throws when the sequence is shorter. +The remainder sequence is a lazy view over the unconsumed tail and can be iterated once: + +*) +let splitData : TaskSeq = TaskSeq.ofList [ 1..10 ] + +let splitExample : Task> = TaskSeq.splitAt 4 splitData +// prefix = [|1;2;3;4|], rest = lazy 5,6,7,8,9,10 +(** +Unlike `take`/`skip`, a single `splitAt` call evaluates elements only once — the prefix is +materialised eagerly and the rest is yielded lazily without re-reading the source. + +----------------------- + +## skip and drop + +`TaskSeq.skip count` skips exactly `count` elements and throws if the source is shorter: + +*) +let afterFirst2 : TaskSeq = consecutive |> TaskSeq.skip 2 // 3, 4, 5 +(** +`TaskSeq.drop count` drops **at most** `count` elements without throwing: + +*) +let safeAfter10 : TaskSeq = consecutive |> TaskSeq.drop 10 // empty +(** +----------------------- + +## takeWhile and takeWhileInclusive + +`TaskSeq.takeWhile predicate` yields elements while the predicate is `true`, then stops (the +element that caused the stop is **not** yielded): + +*) +let lessThan4 : TaskSeq = consecutive |> TaskSeq.takeWhile (fun n -> n < 4) +// 1, 2, 3 +(** +`TaskSeq.takeWhileInclusive` yields the first element for which the predicate is `false` and +then stops — so at least one element is always yielded from a non-empty source: + +*) +let upToFirstGe4 : TaskSeq = + consecutive |> TaskSeq.takeWhileInclusive (fun n -> n < 4) +// 1, 2, 3, 4 +(** +Async variants: `TaskSeq.takeWhileAsync`, `TaskSeq.takeWhileInclusiveAsync`. + +----------------------- + +## skipWhile and skipWhileInclusive + +`TaskSeq.skipWhile predicate` skips elements while the predicate is `true`, then yields the +rest (the first failing element **is** yielded): + +*) +let from3 : TaskSeq = consecutive |> TaskSeq.skipWhile (fun n -> n < 3) +// 3, 4, 5 +(** +`TaskSeq.skipWhileInclusive` also skips the first element for which the predicate is `false`: + +*) +let afterFirst3 : TaskSeq = + consecutive |> TaskSeq.skipWhileInclusive (fun n -> n < 3) +// 4, 5 +(** +Async variants: `TaskSeq.skipWhileAsync`, `TaskSeq.skipWhileInclusiveAsync`. + +----------------------- + +## chunkBySize + +`TaskSeq.chunkBySize chunkSize` divides the sequence into non-overlapping arrays of at most +`chunkSize` elements. The last chunk may be smaller if the sequence does not divide evenly: + +*) +let chunks : TaskSeq = consecutive |> TaskSeq.chunkBySize 2 +// [|1;2|], [|3;4|], [|5|] +(** +----------------------- + +## chunkBy and chunkByAsync + +`TaskSeq.chunkBy projection` groups **consecutive** elements with the same key into `(key, elements[])` pairs. +A new group starts each time the key changes. Unlike `groupBy`, elements that are not adjacent are +**not** merged, so the source order is preserved and the sequence can be infinite: + +*) +let words : TaskSeq = TaskSeq.ofList [ "apple"; "apricot"; "banana"; "blueberry"; "cherry" ] + +let byFirstLetter : TaskSeq = + words |> TaskSeq.chunkBy (fun w -> w[0]) +// ('a', [|"apple";"apricot"|]), ('b', [|"banana";"blueberry"|]), ('c', [|"cherry"|]) +(** +`TaskSeq.chunkByAsync` accepts an asynchronous projection: + +*) +let byFirstLetterAsync : TaskSeq = + words |> TaskSeq.chunkByAsync (fun w -> Task.fromResult w[0]) +(** +----------------------- + +## windowed + +`TaskSeq.windowed windowSize` produces a sliding window of exactly `windowSize` consecutive +elements. The result is empty if the source has fewer elements than the window size: + +*) +let windows : TaskSeq = consecutive |> TaskSeq.windowed 3 +// [|1;2;3|], [|2;3;4|], [|3;4;5|] +(** +`windowed` uses a ring buffer internally, so each window allocation is separate — safe to +store the windows independently. + +*) + diff --git a/TaskSeqCombining.html b/TaskSeqCombining.html new file mode 100644 index 00000000..8c4571ff --- /dev/null +++ b/TaskSeqCombining.html @@ -0,0 +1,533 @@ + + + + + + + + + + + + + + + + + + + + + Combining Task Sequences | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
    +
    + + + Header menu logo + FSharp.Control.TaskSeq + +
    +
    + + + + + +
    +
    + +
    +
    + +

    Combining Task Sequences

    +

    This page covers operations that combine multiple sequences or reshape a single sequence: append, +zip, zipWith, concat, slicing with take/skip/splitAt, chunking and windowing.

    +
    open FSharp.Control
+
    +
    +

    Append

    +

    TaskSeq.append produces all elements of the first sequence followed by all elements of the +second. The second sequence does not start until the first is exhausted:

    +
    let first = TaskSeq.ofList [ 1; 2; 3 ]
+let second = TaskSeq.ofList [ 4; 5; 6 ]
+
+let appended : TaskSeq<int> = TaskSeq.append first second // 1, 2, 3, 4, 5, 6
+
    +

    Inside taskSeq { ... }, yield! is the natural way to concatenate:

    +
    let combined = taskSeq {
+    yield! first
+    yield! second
+}
+
    +

    TaskSeq.appendSeq appends a plain seq<'T> after a task sequence. +TaskSeq.prependSeq prepends a plain seq<'T> before a task sequence:

    +
    let withPrefix : TaskSeq<int> = TaskSeq.prependSeq [ 0 ] first // 0, 1, 2, 3
+let withSuffix : TaskSeq<int> = TaskSeq.appendSeq first [ 4; 5 ] // 1, 2, 3, 4, 5
+
    +
    +

    concat

    +

    TaskSeq.concat flattens a task sequence of task sequences into a single flat sequence. +Each inner sequence is consumed fully before the next one begins:

    +
    let nested : TaskSeq<TaskSeq<int>> =
+    TaskSeq.ofList
+        [ TaskSeq.ofList [ 1; 2 ]
+          TaskSeq.ofList [ 3; 4 ]
+          TaskSeq.ofList [ 5; 6 ] ]
+
+let flat : TaskSeq<int> = TaskSeq.concat nested // 1, 2, 3, 4, 5, 6
+
    +

    Overloads also exist for TaskSeq<seq<'T>>, TaskSeq<'T list>, TaskSeq<'T[]>, and +TaskSeq<ResizeArray<'T>>.

    +
    +

    zip and zip3

    +

    TaskSeq.zip pairs up elements from two sequences, stopping when the shorter sequence ends:

    +
    let letters : TaskSeq<char> = TaskSeq.ofList [ 'a'; 'b'; 'c' ]
+let nums : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 3; 4 ]
+
+let pairs : TaskSeq<char * int> = TaskSeq.zip letters nums
+// ('a',1), ('b',2), ('c',3)  — stops when letters runs out
+
    +

    TaskSeq.zip3 does the same for three sequences:

    +
    let booleans : TaskSeq<bool> = TaskSeq.ofList [ true; false; true ]
+
+let triples : TaskSeq<char * int * bool> = TaskSeq.zip3 letters nums booleans
+
    +
    +

    zipWith and zipWithAsync

    +

    TaskSeq.zipWith is like zip but applies a mapping function to produce a result instead of +yielding a tuple. The result sequence stops when the shorter source ends:

    +
    let addPairs : TaskSeq<int> = TaskSeq.zipWith (+) nums nums
+// 2, 4, 6, 8
+
    +

    TaskSeq.zipWithAsync accepts an asynchronous mapping function:

    +
    let asyncProduct : TaskSeq<int> =
+    TaskSeq.zipWithAsync (fun a b -> Task.fromResult (a * b)) nums nums
+// 1, 4, 9, 16, ...
+
    +
    +

    zipWith3 and zipWithAsync3

    +

    TaskSeq.zipWith3 combines three sequences with a three-argument mapping function, stopping at +the shortest:

    +
    let sumThree : TaskSeq<int> =
+    TaskSeq.zipWith3 (fun a b c -> a + b + c) nums nums nums
+// 3, 6, 9, 12, ...
+
    +

    TaskSeq.zipWithAsync3 takes an asynchronous three-argument mapper:

    +
    let asyncSumThree : TaskSeq<int> =
+    TaskSeq.zipWithAsync3 (fun a b c -> Task.fromResult (a + b + c)) nums nums nums
+
    +
    +

    pairwise

    +

    TaskSeq.pairwise produces a sequence of consecutive pairs. An input with fewer than two elements +produces an empty result:

    +
    let consecutive : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 3; 4; 5 ]
+
+let pairs2 : TaskSeq<int * int> = consecutive |> TaskSeq.pairwise
+// (1,2), (2,3), (3,4), (4,5)
+
    +
    +

    take and truncate

    +

    TaskSeq.take count yields exactly count elements and throws if the source is shorter:

    +
    let first3 : TaskSeq<int> = consecutive |> TaskSeq.take 3 // 1, 2, 3
+
    +

    TaskSeq.truncate count yields at most count elements without throwing when the source is +shorter:

    +
    let atMost10 : TaskSeq<int> = consecutive |> TaskSeq.truncate 10 // 1, 2, 3, 4, 5
+
    +
    +

    splitAt

    +

    TaskSeq.splitAt count splits a sequence into a prefix array and a lazy remainder sequence. The +prefix always contains at most count elements — it never throws when the sequence is shorter. +The remainder sequence is a lazy view over the unconsumed tail and can be iterated once:

    +
    let splitData : TaskSeq<int> = TaskSeq.ofList [ 1..10 ]
+
+let splitExample : Task<int[] * TaskSeq<int>> = TaskSeq.splitAt 4 splitData
+// prefix = [|1;2;3;4|], rest = lazy 5,6,7,8,9,10
+
    +

    Unlike take/skip, a single splitAt call evaluates elements only once — the prefix is +materialised eagerly and the rest is yielded lazily without re-reading the source.

    +
    +

    skip and drop

    +

    TaskSeq.skip count skips exactly count elements and throws if the source is shorter:

    +
    let afterFirst2 : TaskSeq<int> = consecutive |> TaskSeq.skip 2 // 3, 4, 5
+
    +

    TaskSeq.drop count drops at most count elements without throwing:

    +
    let safeAfter10 : TaskSeq<int> = consecutive |> TaskSeq.drop 10 // empty
+
    +
    +

    takeWhile and takeWhileInclusive

    +

    TaskSeq.takeWhile predicate yields elements while the predicate is true, then stops (the +element that caused the stop is not yielded):

    +
    let lessThan4 : TaskSeq<int> = consecutive |> TaskSeq.takeWhile (fun n -> n < 4)
+// 1, 2, 3
+
    +

    TaskSeq.takeWhileInclusive yields the first element for which the predicate is false and +then stops — so at least one element is always yielded from a non-empty source:

    +
    let upToFirstGe4 : TaskSeq<int> =
+    consecutive |> TaskSeq.takeWhileInclusive (fun n -> n < 4)
+// 1, 2, 3, 4
+
    +

    Async variants: TaskSeq.takeWhileAsync, TaskSeq.takeWhileInclusiveAsync.

    +
    +

    skipWhile and skipWhileInclusive

    +

    TaskSeq.skipWhile predicate skips elements while the predicate is true, then yields the +rest (the first failing element is yielded):

    +
    let from3 : TaskSeq<int> = consecutive |> TaskSeq.skipWhile (fun n -> n < 3)
+// 3, 4, 5
+
    +

    TaskSeq.skipWhileInclusive also skips the first element for which the predicate is false:

    +
    let afterFirst3 : TaskSeq<int> =
+    consecutive |> TaskSeq.skipWhileInclusive (fun n -> n < 3)
+// 4, 5
+
    +

    Async variants: TaskSeq.skipWhileAsync, TaskSeq.skipWhileInclusiveAsync.

    +
    +

    chunkBySize

    +

    TaskSeq.chunkBySize chunkSize divides the sequence into non-overlapping arrays of at most +chunkSize elements. The last chunk may be smaller if the sequence does not divide evenly:

    +
    let chunks : TaskSeq<int[]> = consecutive |> TaskSeq.chunkBySize 2
+// [|1;2|], [|3;4|], [|5|]
+
    +
    +

    chunkBy and chunkByAsync

    +

    TaskSeq.chunkBy projection groups consecutive elements with the same key into (key, elements[]) pairs. +A new group starts each time the key changes. Unlike groupBy, elements that are not adjacent are +not merged, so the source order is preserved and the sequence can be infinite:

    +
    let words : TaskSeq<string> = TaskSeq.ofList [ "apple"; "apricot"; "banana"; "blueberry"; "cherry" ]
+
+let byFirstLetter : TaskSeq<char * string[]> =
+    words |> TaskSeq.chunkBy (fun w -> w[0])
+// ('a', [|"apple";"apricot"|]), ('b', [|"banana";"blueberry"|]), ('c', [|"cherry"|])
+
    +

    TaskSeq.chunkByAsync accepts an asynchronous projection:

    +
    let byFirstLetterAsync : TaskSeq<char * string[]> =
+    words |> TaskSeq.chunkByAsync (fun w -> Task.fromResult w[0])
+
    +
    +

    windowed

    +

    TaskSeq.windowed windowSize produces a sliding window of exactly windowSize consecutive +elements. The result is empty if the source has fewer elements than the window size:

    +
    let windows : TaskSeq<int[]> = consecutive |> TaskSeq.windowed 3
+// [|1;2;3|], [|2;3;4|], [|3;4;5|]
+
    +

    windowed uses a ring buffer internally, so each window allocation is separate — safe to +store the windows independently.

    + +
    Multiple items
    namespace FSharp

    --------------------
    namespace Microsoft.FSharp
    +
    Multiple items
    namespace FSharp.Control

    --------------------
    namespace Microsoft.FSharp.Control
    +
    val first: TaskSeq<int>
    +
    Multiple items
    module TaskSeq + +from FSharp.Control.TaskSeqExtensions

    --------------------
    type TaskSeq = + static member append: source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> TaskSeq<'T> + static member appendSeq: source1: TaskSeq<'T> -> source2: 'T seq -> TaskSeq<'T> + static member box: source: TaskSeq<'T> -> TaskSeq<obj> + static member cast: source: TaskSeq<obj> -> TaskSeq<'U> + static member choose: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseAsync: chooser: ('T -> #Task<'U option>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseV: chooser: ('T -> 'U voption) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseVAsync: chooser: ('T -> #Task<'U voption>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chunkBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + static member chunkByAsync: projection: ('T -> #Task<'Key>) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + ...

    --------------------
    type TaskSeq<'T> = System.Collections.Generic.IAsyncEnumerable<'T>
    <summary> + Represents a task sequence and is the output of using the <paramref name="taskSeq{...}" /> + computation expression from this library. It is an alias for <see cref="T:System.IAsyncEnumerable&lt;_&gt;" />. + </summary>

    --------------------
    type TaskSeq<'Machine,'T (requires 'Machine :> IAsyncStateMachine and 'Machine :> IResumableStateMachine<TaskSeqStateMachineData<'T>>)> = + inherit TaskSeqBase<'T> + interface IValueTaskSource + interface IValueTaskSource<bool> + interface IAsyncStateMachine + interface IAsyncEnumerable<'T> + interface IAsyncEnumerator<'T> + new: unit -> TaskSeq<'Machine,'T> + member InitMachineData: ct: CancellationToken * machine: byref<'Machine> -> unit + override MoveNextAsyncResult: unit -> ValueTask<bool>
    <summary> + Main implementation of generic <see cref="T:System.IAsyncEnumerable&lt;'T&gt;" /> and related interfaces, + which forms the meat of the logic behind <see cref="taskSeq" /> computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + </summary>

    --------------------
    new: unit -> TaskSeq<'Machine,'T>
    +
    static member TaskSeq.ofList: source: 'T list -> TaskSeq<'T>
    +
    val second: TaskSeq<int>
    +
    val appended: TaskSeq<int>
    +
    Multiple items
    val int: value: 'T -> int (requires member op_Explicit)

    --------------------
    type int = int32

    --------------------
    type int<'Measure> = + int
    +
    static member TaskSeq.append: source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> TaskSeq<'T>
    +
    val combined: TaskSeq<int>
    +
    val taskSeq: TaskSeqBuilder
    <summary> + Builds an asynchronous task sequence based on <see cref="IAsyncEnumerable&lt;'T&gt;" /> using computation expression syntax. + </summary>
    +
    val withPrefix: TaskSeq<int>
    +
    static member TaskSeq.prependSeq: source1: 'T seq -> source2: TaskSeq<'T> -> TaskSeq<'T>
    +
    val withSuffix: TaskSeq<int>
    +
    static member TaskSeq.appendSeq: source1: TaskSeq<'T> -> source2: 'T seq -> TaskSeq<'T>
    +
    val nested: TaskSeq<TaskSeq<int>>
    +
    val flat: TaskSeq<int>
    +
    static member TaskSeq.concat: sources: TaskSeq<ResizeArray<'T>> -> TaskSeq<'T>
    static member TaskSeq.concat: sources: TaskSeq<'T list> -> TaskSeq<'T>
    static member TaskSeq.concat: sources: TaskSeq<'T array> -> TaskSeq<'T>
    static member TaskSeq.concat: sources: TaskSeq<'T seq> -> TaskSeq<'T>
    static member TaskSeq.concat: sources: TaskSeq<#TaskSeq<'T>> -> TaskSeq<'T>
    +
    val letters: TaskSeq<char>
    +
    Multiple items
    val char: value: 'T -> char (requires member op_Explicit)

    --------------------
    type char = System.Char
    +
    val nums: TaskSeq<int>
    +
    val pairs: TaskSeq<char * int>
    +
    static member TaskSeq.zip: source1: TaskSeq<'T> -> source2: TaskSeq<'U> -> TaskSeq<'T * 'U>
    +
    val booleans: TaskSeq<bool>
    +
    type bool = System.Boolean
    +
    val triples: TaskSeq<char * int * bool>
    +
    static member TaskSeq.zip3: source1: TaskSeq<'T1> -> source2: TaskSeq<'T2> -> source3: TaskSeq<'T3> -> TaskSeq<'T1 * 'T2 * 'T3>
    +
    val addPairs: TaskSeq<int>
    +
    static member TaskSeq.zipWith: mapping: ('T -> 'U -> 'V) -> source1: TaskSeq<'T> -> source2: TaskSeq<'U> -> TaskSeq<'V>
    +
    val asyncProduct: TaskSeq<int>
    +
    static member TaskSeq.zipWithAsync: mapping: ('T -> 'U -> #System.Threading.Tasks.Task<'V>) -> source1: TaskSeq<'T> -> source2: TaskSeq<'U> -> TaskSeq<'V>
    +
    val a: int
    +
    val b: int
    +
    module Task + +from FSharp.Control
    +
    val fromResult: value: 'U -> System.Threading.Tasks.Task<'U>
    <summary> + Creates a Task&lt;'U&gt; that's completed successfully with the specified result. +</summary>
    +
    val sumThree: TaskSeq<int>
    +
    static member TaskSeq.zipWith3: mapping: ('T1 -> 'T2 -> 'T3 -> 'V) -> source1: TaskSeq<'T1> -> source2: TaskSeq<'T2> -> source3: TaskSeq<'T3> -> TaskSeq<'V>
    +
    val c: int
    +
    val asyncSumThree: TaskSeq<int>
    +
    static member TaskSeq.zipWithAsync3: mapping: ('T1 -> 'T2 -> 'T3 -> #System.Threading.Tasks.Task<'V>) -> source1: TaskSeq<'T1> -> source2: TaskSeq<'T2> -> source3: TaskSeq<'T3> -> TaskSeq<'V>
    +
    val consecutive: TaskSeq<int>
    +
    val pairs2: TaskSeq<int * int>
    +
    static member TaskSeq.pairwise: source: TaskSeq<'T> -> TaskSeq<'T * 'T>
    +
    val first3: TaskSeq<int>
    +
    static member TaskSeq.take: count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val atMost10: TaskSeq<int>
    +
    static member TaskSeq.truncate: count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val splitData: TaskSeq<int>
    +
    val splitExample: System.Threading.Tasks.Task<int array * TaskSeq<int>>
    +
    static member TaskSeq.splitAt: count: int -> source: TaskSeq<'T> -> System.Threading.Tasks.Task<'T array * TaskSeq<'T>>
    +
    val afterFirst2: TaskSeq<int>
    +
    static member TaskSeq.skip: count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val safeAfter10: TaskSeq<int>
    +
    static member TaskSeq.drop: count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val lessThan4: TaskSeq<int>
    +
    static member TaskSeq.takeWhile: predicate: ('T -> bool) -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val n: int
    +
    val upToFirstGe4: TaskSeq<int>
    +
    static member TaskSeq.takeWhileInclusive: predicate: ('T -> bool) -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val from3: TaskSeq<int>
    +
    static member TaskSeq.skipWhile: predicate: ('T -> bool) -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val afterFirst3: TaskSeq<int>
    +
    static member TaskSeq.skipWhileInclusive: predicate: ('T -> bool) -> source: TaskSeq<'T> -> TaskSeq<'T>
    +
    val chunks: TaskSeq<int array>
    +
    static member TaskSeq.chunkBySize: chunkSize: int -> source: TaskSeq<'T> -> TaskSeq<'T array>
    +
    val words: TaskSeq<string>
    +
    Multiple items
    val string: value: 'T -> string

    --------------------
    type string = System.String
    +
    val byFirstLetter: TaskSeq<char * string array>
    +
    static member TaskSeq.chunkBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality)
    +
    val w: string
    +
    val byFirstLetterAsync: TaskSeq<char * string array>
    +
    static member TaskSeq.chunkByAsync: projection: ('T -> #System.Threading.Tasks.Task<'Key>) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality)
    +
    val windows: TaskSeq<int array>
    +
    static member TaskSeq.windowed: windowSize: int -> source: TaskSeq<'T> -> TaskSeq<'T array>
    + +
    +
    + + + +
    +
      +

      Type something to start searching.

      +
      +       + + + + + + + + \ No newline at end of file diff --git a/TaskSeqConsuming.fsx b/TaskSeqConsuming.fsx new file mode 100644 index 00000000..4fe22625 --- /dev/null +++ b/TaskSeqConsuming.fsx @@ -0,0 +1,227 @@ +(** + +*) +#r "nuget: FSharp.Control.TaskSeq,1.1.1" +(** +# Consuming Task Sequences + +All `TaskSeq<'T>` values are **lazy** — they produce elements only when actively consumed. This +page covers all the ways to consume a task sequence: iteration with side effects, collection +into arrays and lists, folding, aggregation, searching, and element access. + +*) +open System.Threading.Tasks +open FSharp.Control + +let numbers : TaskSeq = TaskSeq.ofSeq (seq { 1..5 }) +(** +----------------------- + +## Iterating with a for loop + +Inside a `task { ... }` or `taskSeq { ... }` computation expression, you can iterate a +`TaskSeq<'T>` with a plain `for` loop. The loop body may contain `let!` and `do!`: + +*) +task { + for n in numbers do + printfn "Got %d" n +} +|> Task.WaitAll +(** +----------------------- + +## iter and iterAsync + +`TaskSeq.iter` applies a synchronous side-effecting function to every element: + +*) +let printAll : Task = numbers |> TaskSeq.iter (printfn "item: %d") +(** +`TaskSeq.iterAsync` awaits the returned task before consuming the next element — ideal for +actions that themselves do IO, such as writing to a database: + +*) +let processItem (n: int) : Task = + task { printfn "processing %d" n } + +let processAll : Task = numbers |> TaskSeq.iterAsync processItem +(** +### iteri and iteriAsync + +`TaskSeq.iteri` and `TaskSeq.iteriAsync` additionally pass the zero-based index to the action: + +*) +let printWithIndex : Task = + numbers |> TaskSeq.iteri (fun i n -> printfn "[%d] %d" i n) +(** +----------------------- + +## Collecting into arrays and lists + +`TaskSeq.toArrayAsync` and `TaskSeq.toListAsync` consume the whole sequence into an in-memory +collection. The blocking (synchronous) variants `toArray`, `toList`, and `toSeq` are also +available when you need them in a synchronous context: + +*) +let arr : Task = numbers |> TaskSeq.toArrayAsync +let lst : Task = numbers |> TaskSeq.toListAsync +let rz : Task> = numbers |> TaskSeq.toResizeArrayAsync + +// Blocking variants (avoid in async code) +let arrSync : int[] = numbers |> TaskSeq.toArray +let lstSync : int list = numbers |> TaskSeq.toList +(** +----------------------- + +## fold and foldAsync + +`TaskSeq.fold` threads an accumulator through the sequence, returning the final state: + +*) +let sum : Task = + numbers |> TaskSeq.fold (fun acc n -> acc + n) 0 + +let concat : Task = + TaskSeq.ofList [ "hello"; " "; "world" ] + |> TaskSeq.fold (fun acc s -> acc + s) "" +(** +`TaskSeq.foldAsync` is the same but the folder returns `Task<'State>`: + +*) +let sumAsync : Task = + numbers + |> TaskSeq.foldAsync (fun acc n -> task { return acc + n }) 0 +(** +----------------------- + +## scan and scanAsync + +`TaskSeq.scan` is like `fold` but emits each intermediate state as a new element. The output +sequence has `N + 1` elements when the input has `N`, because the initial state is also +emitted: + +*) +let runningTotals : TaskSeq = + numbers |> TaskSeq.scan (fun acc n -> acc + n) 0 + +// yields 0, 1, 3, 6, 10, 15 +(** +----------------------- + +## reduce and reduceAsync + +`TaskSeq.reduce` uses the first element as the initial state — there is no extra zero argument: + +*) +let product : Task = numbers |> TaskSeq.reduce (fun acc n -> acc * n) +(** +----------------------- + +## Aggregation: sum, average, min, max + +Numeric aggregates follow the same pattern as the `Seq` module: + +*) +let total : Task = numbers |> TaskSeq.sum + +let avg : Task = + TaskSeq.ofList [ 1.0; 2.0; 3.0 ] |> TaskSeq.average + +let biggest : Task = numbers |> TaskSeq.max +let smallest : Task = numbers |> TaskSeq.min +(** +`sumBy`, `averageBy`, `maxBy`, and `minBy` apply a projection first. Async variants +`sumByAsync`, `averageByAsync`, `maxByAsync`, and `minByAsync` are also available: + +*) +let sumOfSquares : Task = numbers |> TaskSeq.sumBy (fun n -> n * n) +(** +----------------------- + +## length and isEmpty + +`TaskSeq.length` consumes the whole sequence. Use `TaskSeq.lengthOrMax` to avoid evaluating +more than a known upper bound — useful for infinite sequences or for early termination: + +*) +let len : Task = numbers |> TaskSeq.length // 5 + +let atMost3 : Task = numbers |> TaskSeq.lengthOrMax 3 // 3 (stops early) + +let empty : Task = numbers |> TaskSeq.isEmpty // false +(** +`TaskSeq.lengthBy` counts elements satisfying a predicate in a single pass: + +*) +let countEvens : Task = numbers |> TaskSeq.lengthBy (fun n -> n % 2 = 0) +(** +----------------------- + +## Element access: head, last, item, exactlyOne, firstOrDefault, lastOrDefault + +*) +let first : Task = numbers |> TaskSeq.head // 1 +let last : Task = numbers |> TaskSeq.last // 5 +let third : Task = numbers |> TaskSeq.item 2 // 3 (zero-based) +let only : Task = TaskSeq.singleton 42 |> TaskSeq.exactlyOne // 42 + +// Safe "try" variants return None instead of throwing: +let tryFirst : Task = numbers |> TaskSeq.tryHead +let tryLast : Task = numbers |> TaskSeq.tryLast +let tryThird : Task = numbers |> TaskSeq.tryItem 2 +let tryOnly : Task = TaskSeq.singleton 42 |> TaskSeq.tryExactlyOne +(** +`TaskSeq.firstOrDefault` and `TaskSeq.lastOrDefault` return a caller-supplied default when the +sequence is empty — useful as a concise alternative to `tryHead`/`tryLast` when `None` would +need to be immediately unwrapped: + +*) +let firstOrZero : Task = TaskSeq.empty |> TaskSeq.firstOrDefault 0 // 0 +let lastOrZero : Task = TaskSeq.empty |> TaskSeq.lastOrDefault 0 // 0 + +let firstOrMinus1 : Task = numbers |> TaskSeq.firstOrDefault -1 // 1 +let lastOrMinus1 : Task = numbers |> TaskSeq.lastOrDefault -1 // 5 +(** +----------------------- + +## Searching: find, pick, contains, exists, forall + +`TaskSeq.find` returns the first element satisfying a predicate, or throws if none is found. +`TaskSeq.tryFind` returns `None` instead of throwing: + +*) +let firstEven : Task = numbers |> TaskSeq.find (fun n -> n % 2 = 0) + +let maybeEven : Task = numbers |> TaskSeq.tryFind (fun n -> n % 2 = 0) +(** +`TaskSeq.findIndex` and `TaskSeq.tryFindIndex` return the zero-based index: + +*) +let indexOfFirst3 : Task = numbers |> TaskSeq.findIndex (fun n -> n = 3) +(** +`TaskSeq.pick` and `TaskSeq.tryPick` are like `find` but the predicate also projects to a new +value — equivalent to a combined `choose` + `head`: + +*) +let firstSquareOver10 : Task = + numbers + |> TaskSeq.tryPick (fun n -> + let sq = n * n + if sq > 10 then Some sq else None) +(** +`TaskSeq.contains` tests membership by equality. `TaskSeq.exists` tests with a predicate. +`TaskSeq.forall` tests that all elements satisfy a predicate: + +*) +let has3 : Task = numbers |> TaskSeq.contains 3 + +let anyNegative : Task = numbers |> TaskSeq.exists (fun n -> n < 0) + +let allPositive : Task = numbers |> TaskSeq.forall (fun n -> n > 0) +(** +All search/predicate operations have `Async` variants (`findAsync`, `existsAsync`, +`forallAsync`, etc.) that accept a predicate returning `Task`. + +*) + diff --git a/TaskSeqConsuming.html b/TaskSeqConsuming.html new file mode 100644 index 00000000..ec7ef02b --- /dev/null +++ b/TaskSeqConsuming.html @@ -0,0 +1,581 @@ + + + + + + + + + + + + + + + + + + + + + Consuming Task Sequences | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
      +
      + + + Header menu logo + FSharp.Control.TaskSeq + +
      +
      + + + + + +
      +
      + +
      +
      + +

      Consuming Task Sequences

      +

      All TaskSeq<'T> values are lazy — they produce elements only when actively consumed. This +page covers all the ways to consume a task sequence: iteration with side effects, collection +into arrays and lists, folding, aggregation, searching, and element access.

      +
      open System.Threading.Tasks
+open FSharp.Control
+
+let numbers : TaskSeq<int> = TaskSeq.ofSeq (seq { 1..5 })
+
      +
      +

      Iterating with a for loop

      +

      Inside a task { ... } or taskSeq { ... } computation expression, you can iterate a +TaskSeq<'T> with a plain for loop. The loop body may contain let! and do!:

      +
      task {
+    for n in numbers do
+        printfn "Got %d" n
+}
+|> Task.WaitAll
+
      +
      +

      iter and iterAsync

      +

      TaskSeq.iter applies a synchronous side-effecting function to every element:

      +
      let printAll : Task<unit> = numbers |> TaskSeq.iter (printfn "item: %d")
+
      +

      TaskSeq.iterAsync awaits the returned task before consuming the next element — ideal for +actions that themselves do IO, such as writing to a database:

      +
      let processItem (n: int) : Task<unit> =
+    task { printfn "processing %d" n }
+
+let processAll : Task<unit> = numbers |> TaskSeq.iterAsync processItem
+
      +

      iteri and iteriAsync

      +

      TaskSeq.iteri and TaskSeq.iteriAsync additionally pass the zero-based index to the action:

      +
      let printWithIndex : Task<unit> =
+    numbers |> TaskSeq.iteri (fun i n -> printfn "[%d] %d" i n)
+
      +
      +

      Collecting into arrays and lists

      +

      TaskSeq.toArrayAsync and TaskSeq.toListAsync consume the whole sequence into an in-memory +collection. The blocking (synchronous) variants toArray, toList, and toSeq are also +available when you need them in a synchronous context:

      +
      let arr : Task<int[]> = numbers |> TaskSeq.toArrayAsync
+let lst : Task<int list> = numbers |> TaskSeq.toListAsync
+let rz : Task<System.Collections.Generic.List<int>> = numbers |> TaskSeq.toResizeArrayAsync
+
+// Blocking variants (avoid in async code)
+let arrSync : int[] = numbers |> TaskSeq.toArray
+let lstSync : int list = numbers |> TaskSeq.toList
+
      +
      +

      fold and foldAsync

      +

      TaskSeq.fold threads an accumulator through the sequence, returning the final state:

      +
      let sum : Task<int> =
+    numbers |> TaskSeq.fold (fun acc n -> acc + n) 0
+
+let concat : Task<string> =
+    TaskSeq.ofList [ "hello"; " "; "world" ]
+    |> TaskSeq.fold (fun acc s -> acc + s) ""
+
      +

      TaskSeq.foldAsync is the same but the folder returns Task<'State>:

      +
      let sumAsync : Task<int> =
+    numbers
+    |> TaskSeq.foldAsync (fun acc n -> task { return acc + n }) 0
+
      +
      +

      scan and scanAsync

      +

      TaskSeq.scan is like fold but emits each intermediate state as a new element. The output +sequence has N + 1 elements when the input has N, because the initial state is also +emitted:

      +
      let runningTotals : TaskSeq<int> =
+    numbers |> TaskSeq.scan (fun acc n -> acc + n) 0
+
+// yields 0, 1, 3, 6, 10, 15
+
      +
      +

      reduce and reduceAsync

      +

      TaskSeq.reduce uses the first element as the initial state — there is no extra zero argument:

      +
      let product : Task<int> = numbers |> TaskSeq.reduce (fun acc n -> acc * n)
+
      +
      +

      Aggregation: sum, average, min, max

      +

      Numeric aggregates follow the same pattern as the Seq module:

      +
      let total : Task<int> = numbers |> TaskSeq.sum
+
+let avg : Task<float> =
+    TaskSeq.ofList [ 1.0; 2.0; 3.0 ] |> TaskSeq.average
+
+let biggest : Task<int> = numbers |> TaskSeq.max
+let smallest : Task<int> = numbers |> TaskSeq.min
+
      +

      sumBy, averageBy, maxBy, and minBy apply a projection first. Async variants +sumByAsync, averageByAsync, maxByAsync, and minByAsync are also available:

      +
      let sumOfSquares : Task<int> = numbers |> TaskSeq.sumBy (fun n -> n * n)
+
      +
      +

      length and isEmpty

      +

      TaskSeq.length consumes the whole sequence. Use TaskSeq.lengthOrMax to avoid evaluating +more than a known upper bound — useful for infinite sequences or for early termination:

      +
      let len : Task<int> = numbers |> TaskSeq.length // 5
+
+let atMost3 : Task<int> = numbers |> TaskSeq.lengthOrMax 3 // 3 (stops early)
+
+let empty : Task<bool> = numbers |> TaskSeq.isEmpty // false
+
      +

      TaskSeq.lengthBy counts elements satisfying a predicate in a single pass:

      +
      let countEvens : Task<int> = numbers |> TaskSeq.lengthBy (fun n -> n % 2 = 0)
+
      +
      +

      Element access: head, last, item, exactlyOne, firstOrDefault, lastOrDefault

      +
      let first : Task<int> = numbers |> TaskSeq.head // 1
+let last : Task<int> = numbers |> TaskSeq.last // 5
+let third : Task<int> = numbers |> TaskSeq.item 2 // 3 (zero-based)
+let only : Task<int> = TaskSeq.singleton 42 |> TaskSeq.exactlyOne // 42
+
+// Safe "try" variants return None instead of throwing:
+let tryFirst : Task<int option> = numbers |> TaskSeq.tryHead
+let tryLast : Task<int option> = numbers |> TaskSeq.tryLast
+let tryThird : Task<int option> = numbers |> TaskSeq.tryItem 2
+let tryOnly : Task<int option> = TaskSeq.singleton 42 |> TaskSeq.tryExactlyOne
+
      +

      TaskSeq.firstOrDefault and TaskSeq.lastOrDefault return a caller-supplied default when the +sequence is empty — useful as a concise alternative to tryHead/tryLast when None would +need to be immediately unwrapped:

      +
      let firstOrZero : Task<int> = TaskSeq.empty<int> |> TaskSeq.firstOrDefault 0 // 0
+let lastOrZero : Task<int> = TaskSeq.empty<int> |> TaskSeq.lastOrDefault 0 // 0
+
+let firstOrMinus1 : Task<int> = numbers |> TaskSeq.firstOrDefault -1 // 1
+let lastOrMinus1 : Task<int> = numbers |> TaskSeq.lastOrDefault -1 // 5
+
      +
      +

      Searching: find, pick, contains, exists, forall

      +

      TaskSeq.find returns the first element satisfying a predicate, or throws if none is found. +TaskSeq.tryFind returns None instead of throwing:

      +
      let firstEven : Task<int> = numbers |> TaskSeq.find (fun n -> n % 2 = 0)
+
+let maybeEven : Task<int option> = numbers |> TaskSeq.tryFind (fun n -> n % 2 = 0)
+
      +

      TaskSeq.findIndex and TaskSeq.tryFindIndex return the zero-based index:

      +
      let indexOfFirst3 : Task<int> = numbers |> TaskSeq.findIndex (fun n -> n = 3)
+
      +

      TaskSeq.pick and TaskSeq.tryPick are like find but the predicate also projects to a new +value — equivalent to a combined choose + head:

      +
      let firstSquareOver10 : Task<int option> =
+    numbers
+    |> TaskSeq.tryPick (fun n ->
+        let sq = n * n
+        if sq > 10 then Some sq else None)
+
      +

      TaskSeq.contains tests membership by equality. TaskSeq.exists tests with a predicate. +TaskSeq.forall tests that all elements satisfy a predicate:

      +
      let has3 : Task<bool> = numbers |> TaskSeq.contains 3
+
+let anyNegative : Task<bool> = numbers |> TaskSeq.exists (fun n -> n < 0)
+
+let allPositive : Task<bool> = numbers |> TaskSeq.forall (fun n -> n > 0)
+
      +

      All search/predicate operations have Async variants (findAsync, existsAsync, +forallAsync, etc.) that accept a predicate returning Task<bool>.

      + +
      namespace System
      +
      namespace System.Threading
      +
      namespace System.Threading.Tasks
      +
      Multiple items
      namespace FSharp

      --------------------
      namespace Microsoft.FSharp
      +
      Multiple items
      namespace FSharp.Control

      --------------------
      namespace Microsoft.FSharp.Control
      +
      val numbers: TaskSeq<int>
      +
      Multiple items
      module TaskSeq + +from FSharp.Control.TaskSeqExtensions

      --------------------
      type TaskSeq = + static member append: source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> TaskSeq<'T> + static member appendSeq: source1: TaskSeq<'T> -> source2: 'T seq -> TaskSeq<'T> + static member box: source: TaskSeq<'T> -> TaskSeq<obj> + static member cast: source: TaskSeq<obj> -> TaskSeq<'U> + static member choose: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseAsync: chooser: ('T -> #Task<'U option>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseV: chooser: ('T -> 'U voption) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseVAsync: chooser: ('T -> #Task<'U voption>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chunkBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + static member chunkByAsync: projection: ('T -> #Task<'Key>) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + ...

      --------------------
      type TaskSeq<'T> = System.Collections.Generic.IAsyncEnumerable<'T>
      <summary> + Represents a task sequence and is the output of using the <paramref name="taskSeq{...}" /> + computation expression from this library. It is an alias for <see cref="T:System.IAsyncEnumerable&lt;_&gt;" />. + </summary>

      --------------------
      type TaskSeq<'Machine,'T (requires 'Machine :> IAsyncStateMachine and 'Machine :> IResumableStateMachine<TaskSeqStateMachineData<'T>>)> = + inherit TaskSeqBase<'T> + interface IValueTaskSource + interface IValueTaskSource<bool> + interface IAsyncStateMachine + interface IAsyncEnumerable<'T> + interface IAsyncEnumerator<'T> + new: unit -> TaskSeq<'Machine,'T> + member InitMachineData: ct: CancellationToken * machine: byref<'Machine> -> unit + override MoveNextAsyncResult: unit -> ValueTask<bool>
      <summary> + Main implementation of generic <see cref="T:System.IAsyncEnumerable&lt;'T&gt;" /> and related interfaces, + which forms the meat of the logic behind <see cref="taskSeq" /> computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + </summary>

      --------------------
      new: unit -> TaskSeq<'Machine,'T>
      +
      Multiple items
      val int: value: 'T -> int (requires member op_Explicit)

      --------------------
      type int = int32

      --------------------
      type int<'Measure> = + int
      +
      static member TaskSeq.ofSeq: source: 'T seq -> TaskSeq<'T>
      +
      Multiple items
      val seq: sequence: 'T seq -> 'T seq

      --------------------
      type 'T seq = System.Collections.Generic.IEnumerable<'T>
      +
      val task: TaskBuilder
      +
      val n: int
      +
      val printfn: format: Printf.TextWriterFormat<'T> -> 'T
      +
      Multiple items
      type Task = + interface IAsyncResult + interface IDisposable + new: action: Action -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable + 1 overload + member ContinueWith: continuationAction: Action<Task,obj> * state: obj -> Task + 19 overloads + member Dispose: unit -> unit + member GetAwaiter: unit -> TaskAwaiter + member RunSynchronously: unit -> unit + 1 overload + member Start: unit -> unit + 1 overload + member Wait: unit -> unit + 5 overloads + ...
      <summary>Represents an asynchronous operation.</summary>

      --------------------
      type Task<'TResult> = + inherit Task + new: ``function`` : Func<obj,'TResult> * state: obj -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable<'TResult> + 1 overload + member ContinueWith: continuationAction: Action<Task<'TResult>,obj> * state: obj -> Task + 19 overloads + member GetAwaiter: unit -> TaskAwaiter<'TResult> + member WaitAsync: cancellationToken: CancellationToken -> Task<'TResult> + 4 overloads + member Result: 'TResult + static member Factory: TaskFactory<'TResult>
      <summary>Represents an asynchronous operation that can return a value.</summary>
      <typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>

      --------------------
      Task(action: System.Action) : Task
      Task(action: System.Action, cancellationToken: System.Threading.CancellationToken) : Task
      Task(action: System.Action, creationOptions: TaskCreationOptions) : Task
      Task(action: System.Action<obj>, state: obj) : Task
      Task(action: System.Action, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task
      Task(action: System.Action<obj>, state: obj, cancellationToken: System.Threading.CancellationToken) : Task
      Task(action: System.Action<obj>, state: obj, creationOptions: TaskCreationOptions) : Task
      Task(action: System.Action<obj>, state: obj, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task

      --------------------
      Task(``function`` : System.Func<'TResult>) : Task<'TResult>
      Task(``function`` : System.Func<obj,'TResult>, state: obj) : Task<'TResult>
      Task(``function`` : System.Func<'TResult>, cancellationToken: System.Threading.CancellationToken) : Task<'TResult>
      Task(``function`` : System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
      Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: System.Threading.CancellationToken) : Task<'TResult>
      Task(``function`` : System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
      Task(``function`` : System.Func<'TResult>, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
      Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
      +
      Task.WaitAll([<System.ParamArray>] tasks: Task array) : unit
      Task.WaitAll(tasks: System.ReadOnlySpan<Task>) : unit
      Task.WaitAll(tasks: Task array, timeout: System.TimeSpan) : bool
      Task.WaitAll(tasks: Task array, cancellationToken: System.Threading.CancellationToken) : unit
      Task.WaitAll(tasks: Task array, millisecondsTimeout: int) : bool
      Task.WaitAll(tasks: System.Collections.Generic.IEnumerable<Task>, ?cancellationToken: System.Threading.CancellationToken) : unit
      Task.WaitAll(tasks: Task array, millisecondsTimeout: int, cancellationToken: System.Threading.CancellationToken) : bool
      +
      val printAll: Task<unit>
      +
      type unit = Unit
      +
      static member TaskSeq.iter: action: ('T -> unit) -> source: TaskSeq<'T> -> Task<unit>
      +
      val processItem: n: int -> Task<unit>
      +
      val processAll: Task<unit>
      +
      static member TaskSeq.iterAsync: action: ('T -> #Task<unit>) -> source: TaskSeq<'T> -> Task<unit>
      +
      val printWithIndex: Task<unit>
      +
      static member TaskSeq.iteri: action: (int -> 'T -> unit) -> source: TaskSeq<'T> -> Task<unit>
      +
      val i: int
      +
      val arr: Task<int array>
      +
      static member TaskSeq.toArrayAsync: source: TaskSeq<'T> -> Task<'T array>
      +
      val lst: Task<int list>
      +
      type 'T list = List<'T>
      +
      static member TaskSeq.toListAsync: source: TaskSeq<'T> -> Task<'T list>
      +
      val rz: Task<System.Collections.Generic.List<int>>
      +
      namespace System.Collections
      +
      namespace System.Collections.Generic
      +
      Multiple items
      type List<'T> = + interface ICollection<'T> + interface IEnumerable<'T> + interface IEnumerable + interface IList<'T> + interface IReadOnlyCollection<'T> + interface IReadOnlyList<'T> + interface ICollection + interface IList + new: unit -> unit + 2 overloads + member Add: item: 'T -> unit + ...
      <summary>Represents a strongly typed list of objects that can be accessed by index. Provides methods to search, sort, and manipulate lists.</summary>
      <typeparam name="T">The type of elements in the list.</typeparam>

      --------------------
      System.Collections.Generic.List() : System.Collections.Generic.List<'T>
      System.Collections.Generic.List(collection: System.Collections.Generic.IEnumerable<'T>) : System.Collections.Generic.List<'T>
      System.Collections.Generic.List(capacity: int) : System.Collections.Generic.List<'T>
      +
      static member TaskSeq.toResizeArrayAsync: source: TaskSeq<'T> -> Task<ResizeArray<'T>>
      +
      val arrSync: int array
      +
      static member TaskSeq.toArray: source: TaskSeq<'T> -> 'T array
      +
      val lstSync: int list
      +
      static member TaskSeq.toList: source: TaskSeq<'T> -> 'T list
      +
      val sum: Task<int>
      +
      static member TaskSeq.fold: folder: ('State -> 'T -> 'State) -> state: 'State -> source: TaskSeq<'T> -> Task<'State>
      +
      val acc: int
      +
      val concat: Task<string>
      +
      Multiple items
      val string: value: 'T -> string

      --------------------
      type string = System.String
      +
      static member TaskSeq.ofList: source: 'T list -> TaskSeq<'T>
      +
      val acc: string
      +
      val s: string
      +
      val sumAsync: Task<int>
      +
      static member TaskSeq.foldAsync: folder: ('State -> 'T -> #Task<'State>) -> state: 'State -> source: TaskSeq<'T> -> Task<'State>
      +
      val runningTotals: TaskSeq<int>
      +
      static member TaskSeq.scan: folder: ('State -> 'T -> 'State) -> state: 'State -> source: TaskSeq<'T> -> TaskSeq<'State>
      +
      val product: Task<int>
      +
      static member TaskSeq.reduce: folder: ('T -> 'T -> 'T) -> source: TaskSeq<'T> -> Task<'T>
      +
      val total: Task<int>
      +
      val sum: source: TaskSeq<'T> -> Task<'T> (requires member (+))
      <summary> + Returns the sum of all elements of the task sequence. The elements must support the <c>+</c> operator, + which is the case for all built-in numeric types. For sequences with a projection, use <see cref="TaskSeq.sumBy" />. + </summary>
      <param name="source">The input task sequence.</param>
      <returns>The sum of all elements in the sequence, starting from <c>Unchecked.defaultof</c> as zero.</returns>
      <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
      +
      val avg: Task<float>
      +
      Multiple items
      val float: value: 'T -> float (requires member op_Explicit)

      --------------------
      type float = System.Double

      --------------------
      type float<'Measure> = + float
      +
      val average: source: TaskSeq<'T> -> Task<'T> (requires member (+) and member DivideByInt)
      <summary> + Returns the average of all elements of the task sequence. The elements must support the <c>+</c> operator + and <c>DivideByInt</c>, which is the case for all built-in F# floating-point types. + For sequences with a projection, consider using <see cref="TaskSeq.averageBy" />. + </summary>
      <param name="source">The input task sequence.</param>
      <returns>The average of the elements in the sequence.</returns>
      <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
      <exception cref="T:ArgumentException">Thrown when the input task sequence is empty.</exception>
      +
      val biggest: Task<int>
      +
      static member TaskSeq.max: source: TaskSeq<'T> -> Task<'T> (requires comparison)
      +
      val smallest: Task<int>
      +
      static member TaskSeq.min: source: TaskSeq<'T> -> Task<'T> (requires comparison)
      +
      val sumOfSquares: Task<int>
      +
      val sumBy: projection: ('T -> 'U) -> source: TaskSeq<'T> -> Task<'U> (requires member (+))
      <summary> + Returns the sum of the results generated by applying the <paramref name="projection" /> function to each element + of the task sequence. The result type must support the <c>+</c> operator, which is the case for all built-in numeric types. + If <paramref name="projection" /> is asynchronous, consider using <see cref="TaskSeq.sumByAsync" />. + </summary>
      <param name="projection">A function to transform items from the input sequence into summable values.</param>
      <param name="source">The input task sequence.</param>
      <returns>The sum of the projected values.</returns>
      <exception cref="T:ArgumentNullException">Thrown when the input task sequence is null.</exception>
      +
      val len: Task<int>
      +
      static member TaskSeq.length: source: TaskSeq<'T> -> Task<int>
      +
      val atMost3: Task<int>
      +
      static member TaskSeq.lengthOrMax: max: int -> source: TaskSeq<'T> -> Task<int>
      +
      val empty: Task<bool>
      +
      type bool = System.Boolean
      +
      static member TaskSeq.isEmpty: source: TaskSeq<'T> -> Task<bool>
      +
      val countEvens: Task<int>
      +
      static member TaskSeq.lengthBy: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<int>
      +
      val first: Task<int>
      +
      static member TaskSeq.head: source: TaskSeq<'T> -> Task<'T>
      +
      val last: Task<int>
      +
      static member TaskSeq.last: source: TaskSeq<'T> -> Task<'T>
      +
      val third: Task<int>
      +
      static member TaskSeq.item: index: int -> source: TaskSeq<'T> -> Task<'T>
      +
      val only: Task<int>
      +
      static member TaskSeq.singleton: value: 'T -> TaskSeq<'T>
      +
      static member TaskSeq.exactlyOne: source: TaskSeq<'T> -> Task<'T>
      +
      val tryFirst: Task<int option>
      +
      type 'T option = Option<'T>
      +
      static member TaskSeq.tryHead: source: TaskSeq<'T> -> Task<'T option>
      +
      val tryLast: Task<int option>
      +
      static member TaskSeq.tryLast: source: TaskSeq<'T> -> Task<'T option>
      +
      val tryThird: Task<int option>
      +
      static member TaskSeq.tryItem: index: int -> source: TaskSeq<'T> -> Task<'T option>
      +
      val tryOnly: Task<int option>
      +
      static member TaskSeq.tryExactlyOne: source: TaskSeq<'T> -> Task<'T option>
      +
      val firstOrZero: Task<int>
      +
      val empty<'T> : TaskSeq<'T>
      <summary> + Initialize an empty task sequence. +</summary>
      +
      static member TaskSeq.firstOrDefault: defaultValue: 'T -> source: TaskSeq<'T> -> Task<'T>
      +
      val lastOrZero: Task<int>
      +
      static member TaskSeq.lastOrDefault: defaultValue: 'T -> source: TaskSeq<'T> -> Task<'T>
      +
      val firstOrMinus1: Task<int>
      +
      val lastOrMinus1: Task<int>
      +
      val firstEven: Task<int>
      +
      static member TaskSeq.find: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<'T>
      +
      val maybeEven: Task<int option>
      +
      static member TaskSeq.tryFind: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<'T option>
      +
      val indexOfFirst3: Task<int>
      +
      static member TaskSeq.findIndex: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<int>
      +
      val firstSquareOver10: Task<int option>
      +
      static member TaskSeq.tryPick: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> Task<'U option>
      +
      val sq: int
      +
      union case Option.Some: Value: 'T -> Option<'T>
      +
      union case Option.None: Option<'T>
      +
      val has3: Task<bool>
      +
      static member TaskSeq.contains: value: 'T -> source: TaskSeq<'T> -> Task<bool> (requires equality)
      +
      val anyNegative: Task<bool>
      +
      static member TaskSeq.exists: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<bool>
      +
      val allPositive: Task<bool>
      +
      static member TaskSeq.forall: predicate: ('T -> bool) -> source: TaskSeq<'T> -> Task<bool>
      + +
      +
      + + + +
      +
        +

        Type something to start searching.

        +
        +         + + + + + + + + \ No newline at end of file diff --git a/TaskSeqGenerating.fsx b/TaskSeqGenerating.fsx new file mode 100644 index 00000000..8ecd32bc --- /dev/null +++ b/TaskSeqGenerating.fsx @@ -0,0 +1,268 @@ +(** + +*) +#r "nuget: FSharp.Control.TaskSeq,1.1.1" +(** +# Generating Task Sequences + +This page covers the main ways to create `TaskSeq<'T>` values: the `taskSeq` computation +expression, factory functions such as `TaskSeq.init` and `TaskSeq.unfold`, and conversion +functions that wrap existing collections. + +*) +open System.Threading.Tasks +open FSharp.Control +(** +## Computation Expression Syntax + +`taskSeq { ... }` is a computation expression that lets you write asynchronous sequences +using familiar F# constructs. Under the hood it compiles to a resumable state machine, so +there is no allocation per element. + +### Yielding values + +Use `yield` to emit a single value and `yield!` to splice in another sequence: + +*) +let helloWorld = taskSeq { + yield "hello" + yield "world" +} + +let combined = taskSeq { + yield! helloWorld + yield "!" +} +(** +### Conditionals + +`if`/`then`/`else` works just like in ordinary F#: + +*) +let evenNumbers = taskSeq { + for i in 1..10 do + if i % 2 = 0 then + yield i +} +(** +### Match expressions + +`match` expressions are fully supported: + +*) +type Shape = + | Circle of radius: float + | Rectangle of width: float * height: float + +let areas = taskSeq { + for shape in [ Circle 3.0; Rectangle(4.0, 5.0); Circle 1.5 ] do + match shape with + | Circle r -> yield System.Math.PI * r * r + | Rectangle(w, h) -> yield w * h +} +(** +### For loops + +`for` iterates over any `seq<'T>`/`IEnumerable<'T>` synchronously, or over another +`TaskSeq<'T>` asynchronously: + +*) +let squaresOfList = taskSeq { + for n in [ 1; 2; 3; 4; 5 ] do + yield n * n +} + +// Iterate another TaskSeq +let doubled = taskSeq { + for n in squaresOfList do + yield n * 2 +} +(** +### While loops + +`while` emits elements until a condition becomes false. Async operations can appear in the +loop body: + +*) +let countdown = taskSeq { + let mutable i = 5 + + while i > 0 do + yield i + do! Task.Delay 100 + i <- i - 1 +} +(** +### Awaiting tasks with `let!` and `do!` + +Inside `taskSeq { ... }` you can await any `Task<'T>` with `let!` and any `Task` with +`do!`: + +*) +let fetchData (url: string) : Task = + task { return $"data from {url}" } // placeholder + +let results = taskSeq { + for url in [ "https://example.com/a"; "https://example.com/b" ] do + let! data = fetchData url + yield data +} +(** +### Use bindings and try / with + +`use` and `use!` dispose the resource when the sequence finishes or is abandoned. `try/with` +and `try/finally` work as expected: + +*) +let withResource = taskSeq { + use resource = { new System.IDisposable with member _.Dispose() = () } // placeholder + yield 1 + yield 2 +} + +let withErrorHandling = taskSeq { + try + yield 1 + failwith "oops" + yield 2 + with ex -> + yield -1 +} +(** +----------------------- + +## init and initInfinite + +`TaskSeq.init count initializer` generates `count` elements by calling `initializer` with the +zero-based index: + +*) +// [| 0; 1; 4; 9; 16 |] +let squares : TaskSeq = TaskSeq.init 5 (fun i -> i * i) + +// With an async initializer +let asyncSquares : TaskSeq = + TaskSeq.initAsync 5 (fun i -> task { return i * i }) +(** +`TaskSeq.initInfinite` generates an unbounded sequence — use `TaskSeq.take` or +`TaskSeq.takeWhile` to limit consumption: + +*) +let naturals : TaskSeq = TaskSeq.initInfinite id + +let first10 : TaskSeq = naturals |> TaskSeq.take 10 // 0 .. 9 +(** +----------------------- + +## unfold + +`TaskSeq.unfold` derives a sequence from a state value. Each call to the generator returns +either `None` (end) or `Some (element, nextState)`: + +*) +// 0, 1, 2, ... up to but not including 5 +let counting : TaskSeq = + TaskSeq.unfold + (fun state -> + if state < 5 then + Some(state, state + 1) + else + None) + 0 + +// Same with an async generator +let countingAsync : TaskSeq = + TaskSeq.unfoldAsync + (fun state -> + task { + if state < 5 then + return Some(state, state + 1) + else + return None + }) + 0 +(** +----------------------- + +## singleton, replicate, replicateInfinite, and empty + +*) +let one : TaskSeq = TaskSeq.singleton "hello" + +let fives : TaskSeq = TaskSeq.replicate 3 5 // 5, 5, 5 + +let nothing : TaskSeq = TaskSeq.empty +(** +`TaskSeq.replicateInfinite` yields a constant value indefinitely. Always combine it with a +bounding operation such as `take` or `takeWhile`: + +*) +let infinitePings : TaskSeq = TaskSeq.replicateInfinite "ping" + +let first10pings : TaskSeq = infinitePings |> TaskSeq.take 10 +(** +`TaskSeq.replicateInfiniteAsync` calls a function on every step, useful for polling or streaming +side-effectful sources: + +*) +let mutable counter = 0 + +let pollingSeq : TaskSeq = + TaskSeq.replicateInfiniteAsync (fun () -> + task { + counter <- counter + 1 + return counter + }) + +let first5counts : TaskSeq = pollingSeq |> TaskSeq.take 5 +(** +`TaskSeq.replicateUntilNoneAsync` stops when the function returns `None`, making it easy to +wrap a pull-based source that signals end-of-stream with `None`: + +*) +let readLine (reader: System.IO.TextReader) = + TaskSeq.replicateUntilNoneAsync (fun () -> + task { + let! line = reader.ReadLineAsync() + return if line = null then None else Some line + }) +(** +----------------------- + +## delay + +`TaskSeq.delay` creates a sequence whose body is not evaluated until iteration starts. This +is useful when the sequence depends on side-effectful initialisation: + +*) +let deferred = + TaskSeq.delay (fun () -> + taskSeq { + printfn "sequence started" + yield! [ 1; 2; 3 ] + }) +(** +----------------------- + +## Converting from existing collections + +All of these produce a `TaskSeq<'T>` that replays the source on each iteration: + +*) +let fromArray : TaskSeq = TaskSeq.ofArray [| 1; 2; 3 |] +let fromList : TaskSeq = TaskSeq.ofList [ 1; 2; 3 ] +let fromSeq : TaskSeq = TaskSeq.ofSeq (seq { 1..3 }) +let fromResizeArray : TaskSeq = TaskSeq.ofResizeArray (System.Collections.Generic.List([ 1; 2; 3 ])) +(** +You can also wrap existing task or async collections. Note that wrapping a list of already +started `Task`s does **not** guarantee sequential execution—the tasks are already running: + +*) +// Sequence of not-yet-started task factories (safe) +let fromTaskSeq : TaskSeq = + TaskSeq.ofTaskSeq (seq { yield task { return 1 }; yield task { return 2 } }) + +// Sequence of asyncs (each started on demand as the sequence is consumed) +let fromAsyncSeq : TaskSeq = + TaskSeq.ofAsyncSeq (seq { yield async { return 1 }; yield async { return 2 } }) + diff --git a/TaskSeqGenerating.html b/TaskSeqGenerating.html new file mode 100644 index 00000000..0b02cc74 --- /dev/null +++ b/TaskSeqGenerating.html @@ -0,0 +1,636 @@ + + + + + + + + + + + + + + + + + + + + + Generating Task Sequences | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
        +
        + + + Header menu logo + FSharp.Control.TaskSeq + +
        +
        + + + + + +
        +
        + +
        +
        + +

        Generating Task Sequences

        +

        This page covers the main ways to create TaskSeq<'T> values: the taskSeq computation +expression, factory functions such as TaskSeq.init and TaskSeq.unfold, and conversion +functions that wrap existing collections.

        +
        open System.Threading.Tasks
+open FSharp.Control
+
        +

        Computation Expression Syntax

        +

        taskSeq { ... } is a computation expression that lets you write asynchronous sequences +using familiar F# constructs. Under the hood it compiles to a resumable state machine, so +there is no allocation per element.

        +

        Yielding values

        +

        Use yield to emit a single value and yield! to splice in another sequence:

        +
        let helloWorld = taskSeq {
+    yield "hello"
+    yield "world"
+}
+
+let combined = taskSeq {
+    yield! helloWorld
+    yield "!"
+}
+
        +

        Conditionals

        +

        if/then/else works just like in ordinary F#:

        +
        let evenNumbers = taskSeq {
+    for i in 1..10 do
+        if i % 2 = 0 then
+            yield i
+}
+
        +

        Match expressions

        +

        match expressions are fully supported:

        +
        type Shape =
+    | Circle of radius: float
+    | Rectangle of width: float * height: float
+
+let areas = taskSeq {
+    for shape in [ Circle 3.0; Rectangle(4.0, 5.0); Circle 1.5 ] do
+        match shape with
+        | Circle r -> yield System.Math.PI * r * r
+        | Rectangle(w, h) -> yield w * h
+}
+
        +

        For loops

        +

        for iterates over any seq<'T>/IEnumerable<'T> synchronously, or over another +TaskSeq<'T> asynchronously:

        +
        let squaresOfList = taskSeq {
+    for n in [ 1; 2; 3; 4; 5 ] do
+        yield n * n
+}
+
+// Iterate another TaskSeq
+let doubled = taskSeq {
+    for n in squaresOfList do
+        yield n * 2
+}
+
        +

        While loops

        +

        while emits elements until a condition becomes false. Async operations can appear in the +loop body:

        +
        let countdown = taskSeq {
+    let mutable i = 5
+
+    while i > 0 do
+        yield i
+        do! Task.Delay 100
+        i <- i - 1
+}
+
        +

        Awaiting tasks with let! and do!

        +

        Inside taskSeq { ... } you can await any Task<'T> with let! and any Task<unit> with +do!:

        +
        let fetchData (url: string) : Task<string> =
+    task { return $"data from {url}" } // placeholder
+
+let results = taskSeq {
+    for url in [ "https://example.com/a"; "https://example.com/b" ] do
+        let! data = fetchData url
+        yield data
+}
+
        +

        Use bindings and try / with

        +

        use and use! dispose the resource when the sequence finishes or is abandoned. try/with +and try/finally work as expected:

        +
        let withResource = taskSeq {
+    use resource = { new System.IDisposable with member _.Dispose() = () } // placeholder
+    yield 1
+    yield 2
+}
+
+let withErrorHandling = taskSeq {
+    try
+        yield 1
+        failwith "oops"
+        yield 2
+    with ex ->
+        yield -1
+}
+
        +
        +

        init and initInfinite

        +

        TaskSeq.init count initializer generates count elements by calling initializer with the +zero-based index:

        +
        // [| 0; 1; 4; 9; 16 |]
+let squares : TaskSeq<int> = TaskSeq.init 5 (fun i -> i * i)
+
+// With an async initializer
+let asyncSquares : TaskSeq<int> =
+    TaskSeq.initAsync 5 (fun i -> task { return i * i })
+
        +

        TaskSeq.initInfinite generates an unbounded sequence — use TaskSeq.take or +TaskSeq.takeWhile to limit consumption:

        +
        let naturals : TaskSeq<int> = TaskSeq.initInfinite id
+
+let first10 : TaskSeq<int> = naturals |> TaskSeq.take 10 // 0 .. 9
+
        +
        +

        unfold

        +

        TaskSeq.unfold derives a sequence from a state value. Each call to the generator returns +either None (end) or Some (element, nextState):

        +
        // 0, 1, 2, ... up to but not including 5
+let counting : TaskSeq<int> =
+    TaskSeq.unfold
+        (fun state ->
+            if state < 5 then
+                Some(state, state + 1)
+            else
+                None)
+        0
+
+// Same with an async generator
+let countingAsync : TaskSeq<int> =
+    TaskSeq.unfoldAsync
+        (fun state ->
+            task {
+                if state < 5 then
+                    return Some(state, state + 1)
+                else
+                    return None
+            })
+        0
+
        +
        +

        singleton, replicate, replicateInfinite, and empty

        +
        let one : TaskSeq<string> = TaskSeq.singleton "hello"
+
+let fives : TaskSeq<int> = TaskSeq.replicate 3 5 // 5, 5, 5
+
+let nothing : TaskSeq<int> = TaskSeq.empty<int>
+
        +

        TaskSeq.replicateInfinite yields a constant value indefinitely. Always combine it with a +bounding operation such as take or takeWhile:

        +
        let infinitePings : TaskSeq<string> = TaskSeq.replicateInfinite "ping"
+
+let first10pings : TaskSeq<string> = infinitePings |> TaskSeq.take 10
+
        +

        TaskSeq.replicateInfiniteAsync calls a function on every step, useful for polling or streaming +side-effectful sources:

        +
        let mutable counter = 0
+
+let pollingSeq : TaskSeq<int> =
+    TaskSeq.replicateInfiniteAsync (fun () ->
+        task {
+            counter <- counter + 1
+            return counter
+        })
+
+let first5counts : TaskSeq<int> = pollingSeq |> TaskSeq.take 5
+
        +

        TaskSeq.replicateUntilNoneAsync stops when the function returns None, making it easy to +wrap a pull-based source that signals end-of-stream with None:

        +
        let readLine (reader: System.IO.TextReader) =
+    TaskSeq.replicateUntilNoneAsync (fun () ->
+        task {
+            let! line = reader.ReadLineAsync()
+            return if line = null then None else Some line
+        })
+
        +
        +

        delay

        +

        TaskSeq.delay creates a sequence whose body is not evaluated until iteration starts. This +is useful when the sequence depends on side-effectful initialisation:

        +
        let deferred =
+    TaskSeq.delay (fun () ->
+        taskSeq {
+            printfn "sequence started"
+            yield! [ 1; 2; 3 ]
+        })
+
        +
        +

        Converting from existing collections

        +

        All of these produce a TaskSeq<'T> that replays the source on each iteration:

        +
        let fromArray : TaskSeq<int> = TaskSeq.ofArray [| 1; 2; 3 |]
+let fromList : TaskSeq<int> = TaskSeq.ofList [ 1; 2; 3 ]
+let fromSeq : TaskSeq<int> = TaskSeq.ofSeq (seq { 1..3 })
+let fromResizeArray : TaskSeq<int> = TaskSeq.ofResizeArray (System.Collections.Generic.List<int>([ 1; 2; 3 ]))
+
        +

        You can also wrap existing task or async collections. Note that wrapping a list of already +started Tasks does not guarantee sequential execution—the tasks are already running:

        +
        // Sequence of not-yet-started task factories (safe)
+let fromTaskSeq : TaskSeq<int> =
+    TaskSeq.ofTaskSeq (seq { yield task { return 1 }; yield task { return 2 } })
+
+// Sequence of asyncs (each started on demand as the sequence is consumed)
+let fromAsyncSeq : TaskSeq<int> =
+    TaskSeq.ofAsyncSeq (seq { yield async { return 1 }; yield async { return 2 } })
+
        + +
        namespace System
        +
        namespace System.Threading
        +
        namespace System.Threading.Tasks
        +
        Multiple items
        namespace FSharp

        --------------------
        namespace Microsoft.FSharp
        +
        Multiple items
        namespace FSharp.Control

        --------------------
        namespace Microsoft.FSharp.Control
        +
        val helloWorld: TaskSeq<string>
        +
        val taskSeq: TaskSeqBuilder
        <summary> + Builds an asynchronous task sequence based on <see cref="IAsyncEnumerable&lt;'T&gt;" /> using computation expression syntax. + </summary>
        +
        val combined: TaskSeq<string>
        +
        val evenNumbers: TaskSeq<int>
        +
        val i: int
        +
        type Shape = + | Circle of radius: float + | Rectangle of width: float * height: float
        +
        Multiple items
        val float: value: 'T -> float (requires member op_Explicit)

        --------------------
        type float = System.Double

        --------------------
        type float<'Measure> = + float
        +
        val areas: TaskSeq<float>
        +
        val shape: Shape
        +
        union case Shape.Circle: radius: float -> Shape
        +
        union case Shape.Rectangle: width: float * height: float -> Shape
        +
        val r: float
        +
        type Math = + static member Abs: value: decimal -> decimal + 7 overloads + static member Acos: d: float -> float + static member Acosh: d: float -> float + static member Asin: d: float -> float + static member Asinh: d: float -> float + static member Atan: d: float -> float + static member Atan2: y: float * x: float -> float + static member Atanh: d: float -> float + static member BigMul: a: int * b: int -> int64 + 5 overloads + static member BitDecrement: x: float -> float + ...
        <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary>
        +
        field System.Math.PI: float = 3.14159265359
        +
        val w: float
        +
        val h: float
        +
        val squaresOfList: TaskSeq<int>
        +
        val n: int
        +
        val doubled: TaskSeq<int>
        +
        val countdown: TaskSeq<int>
        +
        val mutable i: int
        +
        Multiple items
        type Task = + interface IAsyncResult + interface IDisposable + new: action: Action -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable + 1 overload + member ContinueWith: continuationAction: Action<Task,obj> * state: obj -> Task + 19 overloads + member Dispose: unit -> unit + member GetAwaiter: unit -> TaskAwaiter + member RunSynchronously: unit -> unit + 1 overload + member Start: unit -> unit + 1 overload + member Wait: unit -> unit + 5 overloads + ...
        <summary>Represents an asynchronous operation.</summary>

        --------------------
        type Task<'TResult> = + inherit Task + new: ``function`` : Func<obj,'TResult> * state: obj -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable<'TResult> + 1 overload + member ContinueWith: continuationAction: Action<Task<'TResult>,obj> * state: obj -> Task + 19 overloads + member GetAwaiter: unit -> TaskAwaiter<'TResult> + member WaitAsync: cancellationToken: CancellationToken -> Task<'TResult> + 4 overloads + member Result: 'TResult + static member Factory: TaskFactory<'TResult>
        <summary>Represents an asynchronous operation that can return a value.</summary>
        <typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>

        --------------------
        Task(action: System.Action) : Task
        Task(action: System.Action, cancellationToken: System.Threading.CancellationToken) : Task
        Task(action: System.Action, creationOptions: TaskCreationOptions) : Task
        Task(action: System.Action<obj>, state: obj) : Task
        Task(action: System.Action, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task
        Task(action: System.Action<obj>, state: obj, cancellationToken: System.Threading.CancellationToken) : Task
        Task(action: System.Action<obj>, state: obj, creationOptions: TaskCreationOptions) : Task
        Task(action: System.Action<obj>, state: obj, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task

        --------------------
        Task(``function`` : System.Func<'TResult>) : Task<'TResult>
        Task(``function`` : System.Func<obj,'TResult>, state: obj) : Task<'TResult>
        Task(``function`` : System.Func<'TResult>, cancellationToken: System.Threading.CancellationToken) : Task<'TResult>
        Task(``function`` : System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
        Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: System.Threading.CancellationToken) : Task<'TResult>
        Task(``function`` : System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
        Task(``function`` : System.Func<'TResult>, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
        Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
        +
        Task.Delay(delay: System.TimeSpan) : Task
        Task.Delay(millisecondsDelay: int) : Task
        Task.Delay(delay: System.TimeSpan, timeProvider: System.TimeProvider) : Task
        Task.Delay(delay: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : Task
        Task.Delay(millisecondsDelay: int, cancellationToken: System.Threading.CancellationToken) : Task
        Task.Delay(delay: System.TimeSpan, timeProvider: System.TimeProvider, cancellationToken: System.Threading.CancellationToken) : Task
        +
        val fetchData: url: string -> Task<string>
        +
        val url: string
        +
        Multiple items
        val string: value: 'T -> string

        --------------------
        type string = System.String
        +
        val task: TaskBuilder
        +
        val results: TaskSeq<string>
        +
        val data: string
        +
        val withResource: TaskSeq<int>
        +
        val resource: System.IDisposable
        +
        type IDisposable = + override Dispose: unit -> unit
        <summary>Provides a mechanism for releasing unmanaged resources.</summary>
        +
        val withErrorHandling: TaskSeq<int>
        +
        val failwith: message: string -> 'T
        +
        val ex: exn
        +
        val squares: TaskSeq<int>
        +
        Multiple items
        module TaskSeq + +from FSharp.Control.TaskSeqExtensions

        --------------------
        type TaskSeq = + static member append: source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> TaskSeq<'T> + static member appendSeq: source1: TaskSeq<'T> -> source2: 'T seq -> TaskSeq<'T> + static member box: source: TaskSeq<'T> -> TaskSeq<obj> + static member cast: source: TaskSeq<obj> -> TaskSeq<'U> + static member choose: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseAsync: chooser: ('T -> #Task<'U option>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseV: chooser: ('T -> 'U voption) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseVAsync: chooser: ('T -> #Task<'U voption>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chunkBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + static member chunkByAsync: projection: ('T -> #Task<'Key>) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + ...

        --------------------
        type TaskSeq<'T> = System.Collections.Generic.IAsyncEnumerable<'T>
        <summary> + Represents a task sequence and is the output of using the <paramref name="taskSeq{...}" /> + computation expression from this library. It is an alias for <see cref="T:System.IAsyncEnumerable&lt;_&gt;" />. + </summary>

        --------------------
        type TaskSeq<'Machine,'T (requires 'Machine :> IAsyncStateMachine and 'Machine :> IResumableStateMachine<TaskSeqStateMachineData<'T>>)> = + inherit TaskSeqBase<'T> + interface IValueTaskSource + interface IValueTaskSource<bool> + interface IAsyncStateMachine + interface IAsyncEnumerable<'T> + interface IAsyncEnumerator<'T> + new: unit -> TaskSeq<'Machine,'T> + member InitMachineData: ct: CancellationToken * machine: byref<'Machine> -> unit + override MoveNextAsyncResult: unit -> ValueTask<bool>
        <summary> + Main implementation of generic <see cref="T:System.IAsyncEnumerable&lt;'T&gt;" /> and related interfaces, + which forms the meat of the logic behind <see cref="taskSeq" /> computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + </summary>

        --------------------
        new: unit -> TaskSeq<'Machine,'T>
        +
        Multiple items
        val int: value: 'T -> int (requires member op_Explicit)

        --------------------
        type int = int32

        --------------------
        type int<'Measure> = + int
        +
        static member TaskSeq.init: count: int -> initializer: (int -> 'T) -> TaskSeq<'T>
        +
        val asyncSquares: TaskSeq<int>
        +
        static member TaskSeq.initAsync: count: int -> initializer: (int -> #Task<'T>) -> TaskSeq<'T>
        +
        val naturals: TaskSeq<int>
        +
        static member TaskSeq.initInfinite: initializer: (int -> 'T) -> TaskSeq<'T>
        +
        val id: x: 'T -> 'T
        +
        val first10: TaskSeq<int>
        +
        static member TaskSeq.take: count: int -> source: TaskSeq<'T> -> TaskSeq<'T>
        +
        val counting: TaskSeq<int>
        +
        static member TaskSeq.unfold: generator: ('State -> ('T * 'State) option) -> state: 'State -> TaskSeq<'T>
        +
        val state: int
        +
        union case Option.Some: Value: 'T -> Option<'T>
        +
        union case Option.None: Option<'T>
        +
        val countingAsync: TaskSeq<int>
        +
        static member TaskSeq.unfoldAsync: generator: ('State -> Task<('T * 'State) option>) -> state: 'State -> TaskSeq<'T>
        +
        val one: TaskSeq<string>
        +
        static member TaskSeq.singleton: value: 'T -> TaskSeq<'T>
        +
        val fives: TaskSeq<int>
        +
        static member TaskSeq.replicate: count: int -> value: 'T -> TaskSeq<'T>
        +
        val nothing: TaskSeq<int>
        +
        val empty<'T> : TaskSeq<'T>
        <summary> + Initialize an empty task sequence. +</summary>
        +
        val infinitePings: TaskSeq<string>
        +
        static member TaskSeq.replicateInfinite: value: 'T -> TaskSeq<'T>
        +
        val first10pings: TaskSeq<string>
        +
        val mutable counter: int
        +
        val pollingSeq: TaskSeq<int>
        +
        static member TaskSeq.replicateInfiniteAsync: computation: (unit -> #Task<'T>) -> TaskSeq<'T>
        +
        val first5counts: TaskSeq<int>
        +
        val readLine: reader: System.IO.TextReader -> TaskSeq<string>
        +
        val reader: System.IO.TextReader
        +
        namespace System.IO
        +
        type TextReader = + inherit MarshalByRefObject + interface IDisposable + member Close: unit -> unit + member Dispose: unit -> unit + member Peek: unit -> int + member Read: unit -> int + 2 overloads + member ReadAsync: buffer: char array * index: int * count: int -> Task<int> + 1 overload + member ReadBlock: buffer: char array * index: int * count: int -> int + 1 overload + member ReadBlockAsync: buffer: char array * index: int * count: int -> Task<int> + 1 overload + member ReadLine: unit -> string + ...
        <summary>Represents a reader that can read a sequential series of characters.</summary>
        +
        static member TaskSeq.replicateUntilNoneAsync: computation: (unit -> #Task<'T option>) -> TaskSeq<'T>
        +
        val line: string
        +
        System.IO.TextReader.ReadLineAsync() : Task<string>
        System.IO.TextReader.ReadLineAsync(cancellationToken: System.Threading.CancellationToken) : ValueTask<string>
        +
        val deferred: TaskSeq<int>
        +
        static member TaskSeq.delay: generator: (unit -> TaskSeq<'T>) -> TaskSeq<'T>
        +
        val printfn: format: Printf.TextWriterFormat<'T> -> 'T
        +
        val fromArray: TaskSeq<int>
        +
        static member TaskSeq.ofArray: source: 'T array -> TaskSeq<'T>
        +
        val fromList: TaskSeq<int>
        +
        static member TaskSeq.ofList: source: 'T list -> TaskSeq<'T>
        +
        val fromSeq: TaskSeq<int>
        +
        static member TaskSeq.ofSeq: source: 'T seq -> TaskSeq<'T>
        +
        Multiple items
        val seq: sequence: 'T seq -> 'T seq

        --------------------
        type 'T seq = System.Collections.Generic.IEnumerable<'T>
        +
        val fromResizeArray: TaskSeq<int>
        +
        static member TaskSeq.ofResizeArray: source: ResizeArray<'T> -> TaskSeq<'T>
        +
        namespace System.Collections
        +
        namespace System.Collections.Generic
        +
        Multiple items
        type List<'T> = + interface ICollection<'T> + interface IEnumerable<'T> + interface IEnumerable + interface IList<'T> + interface IReadOnlyCollection<'T> + interface IReadOnlyList<'T> + interface ICollection + interface IList + new: unit -> unit + 2 overloads + member Add: item: 'T -> unit + ...
        <summary>Represents a strongly typed list of objects that can be accessed by index. Provides methods to search, sort, and manipulate lists.</summary>
        <typeparam name="T">The type of elements in the list.</typeparam>

        --------------------
        System.Collections.Generic.List() : System.Collections.Generic.List<'T>
        System.Collections.Generic.List(collection: System.Collections.Generic.IEnumerable<'T>) : System.Collections.Generic.List<'T>
        System.Collections.Generic.List(capacity: int) : System.Collections.Generic.List<'T>
        +
        val fromTaskSeq: TaskSeq<int>
        +
        static member TaskSeq.ofTaskSeq: source: #Task<'T> seq -> TaskSeq<'T>
        +
        val fromAsyncSeq: TaskSeq<int>
        +
        static member TaskSeq.ofAsyncSeq: source: Async<'T> seq -> TaskSeq<'T>
        +
        val async: AsyncBuilder
        + +
        +
        + + + +
        +
          +

          Type something to start searching.

          +
          +           + + + + + + + + \ No newline at end of file diff --git a/TaskSeqTransforming.fsx b/TaskSeqTransforming.fsx new file mode 100644 index 00000000..fec6a5b9 --- /dev/null +++ b/TaskSeqTransforming.fsx @@ -0,0 +1,165 @@ +(** + +*) +#r "nuget: FSharp.Control.TaskSeq,1.1.1" +(** +# Transforming Task Sequences + +This page covers the core operations for transforming `TaskSeq<'T>` values: `map`, `filter`, +`choose`, `collect`, `indexed`, and type conversions. +For operations that consume a sequence into a single result, see +[Consuming Sequences](TaskSeqConsuming.fsx). + +*) +open System.Threading.Tasks +open FSharp.Control +(** +## Transforming with a computation expression + +The most flexible way to transform a task sequence is to write a function that accepts a +`TaskSeq<_>` and returns a `TaskSeq<_>` using a `taskSeq { ... }` computation expression. The +`for` loop inside the CE is an asynchronous loop that awaits each element: + +*) +let labelEvenOdd (input: TaskSeq) : TaskSeq = + taskSeq { + for n in input do + if n % 2 = 0 then + do! Task.Delay 10 // simulate async work + yield $"Even: {n}" + else + yield $"Odd: {n}" + } +(** +Inside `taskSeq { ... }` you can freely mix synchronous logic, `let!`/`do!` awaits, loops, +and conditionals. + +----------------------- + +## map and mapAsync + +`TaskSeq.map` applies a synchronous function to every element: + +*) +let numbers : TaskSeq = TaskSeq.ofSeq (seq { 1..5 }) + +let doubled : TaskSeq = numbers |> TaskSeq.map (fun n -> n * 2) +(** +`TaskSeq.mapAsync` is the same but the projection returns `Task<'U>`, allowing async work per +element — for example, a database lookup or HTTP request: + +*) +let fetchDescription (n: int) : Task = + task { return $"item {n}" } // placeholder for a real async call + +let descriptions : TaskSeq = numbers |> TaskSeq.mapAsync fetchDescription +(** +### mapi and mapiAsync + +`TaskSeq.mapi` and `TaskSeq.mapiAsync` additionally pass the zero-based index to the mapper: + +*) +let indexed : TaskSeq = + numbers |> TaskSeq.mapi (fun i n -> $"[{i}] {n}") +(** +----------------------- + +## filter and filterAsync + +`TaskSeq.filter` keeps only elements satisfying a synchronous predicate: + +*) +let evens : TaskSeq = numbers |> TaskSeq.filter (fun n -> n % 2 = 0) +(** +`TaskSeq.filterAsync` does the same with an async predicate — useful when the keep/discard +decision requires an async lookup: + +*) +let isInteresting (n: int) : Task = + task { return n > 2 } // placeholder + +let interesting : TaskSeq = numbers |> TaskSeq.filterAsync isInteresting +(** +`TaskSeq.where` and `TaskSeq.whereAsync` are aliases for `filter` and `filterAsync` provided +for readability. + +----------------------- + +## choose and chooseAsync + +`TaskSeq.choose` applies a function that returns `'U option`; only `Some` values are kept and +the option wrapper is removed — it is equivalent to `filter` + `map` in a single pass: + +*) +let strings : TaskSeq = + TaskSeq.ofList [ ""; "hello"; ""; "world" ] + +let nonEmpty : TaskSeq = + strings + |> TaskSeq.choose (fun s -> + if s.Length > 0 then Some s else None) +(** +`TaskSeq.chooseAsync` accepts an async chooser: + +*) +let parseAsync (s: string) : Task = + task { + match System.Int32.TryParse s with + | true, n -> return Some n + | _ -> return None + } + +let parsed : TaskSeq = + TaskSeq.ofList [ "1"; "two"; "3" ] + |> TaskSeq.chooseAsync parseAsync +(** +----------------------- + +## collect and collectSeq + +`TaskSeq.collect` is the monadic bind for `TaskSeq`: it maps each element to a new task +sequence and concatenates all the results end-to-end: + +*) +let words : TaskSeq = + TaskSeq.ofList [ "foo bar"; "baz qux" ] + +let chars : TaskSeq = + words + |> TaskSeq.collectSeq (fun sentence -> + sentence.Split(' ') |> Array.toSeq) +(** +`TaskSeq.collect` maps to another `TaskSeq<'U>`, while `TaskSeq.collectSeq` maps to a plain +`seq<'U>`. Async variants `TaskSeq.collectAsync` and `TaskSeq.collectSeqAsync` accept mappers +that return tasks. + +----------------------- + +## indexed + +`TaskSeq.indexed` pairs each element with its zero-based index, returning a +`TaskSeq`: + +*) +let withIndex : TaskSeq = + TaskSeq.ofList [ "a"; "b"; "c" ] |> TaskSeq.indexed + +// yields (0,"a"), (1,"b"), (2,"c") +(** +----------------------- + +## Type conversions + +`TaskSeq.cast` casts items from `TaskSeq` to a target reference type. For value types use +`TaskSeq.unbox`: + +*) +let boxed : TaskSeq = + TaskSeq.ofList [ box 1; box 2; box 3 ] + +let unboxed : TaskSeq = boxed |> TaskSeq.unbox + +let castToString : TaskSeq = + TaskSeq.ofList [ box "hello"; box "world" ] + |> TaskSeq.cast + diff --git a/TaskSeqTransforming.html b/TaskSeqTransforming.html new file mode 100644 index 00000000..018eb64e --- /dev/null +++ b/TaskSeqTransforming.html @@ -0,0 +1,465 @@ + + + + + + + + + + + + + + + + + + + + + Transforming Task Sequences | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
          +
          + + + Header menu logo + FSharp.Control.TaskSeq + +
          +
          + + + + + +
          +
          + +
          +
          + +

          Transforming Task Sequences

          +

          This page covers the core operations for transforming TaskSeq<'T> values: map, filter, +choose, collect, indexed, and type conversions. +For operations that consume a sequence into a single result, see +Consuming Sequences.

          +
          open System.Threading.Tasks
+open FSharp.Control
+
          +

          Transforming with a computation expression

          +

          The most flexible way to transform a task sequence is to write a function that accepts a +TaskSeq<_> and returns a TaskSeq<_> using a taskSeq { ... } computation expression. The +for loop inside the CE is an asynchronous loop that awaits each element:

          +
          let labelEvenOdd (input: TaskSeq<int>) : TaskSeq<string> =
+    taskSeq {
+        for n in input do
+            if n % 2 = 0 then
+                do! Task.Delay 10 // simulate async work
+                yield $"Even: {n}"
+            else
+                yield $"Odd: {n}"
+    }
+
          +

          Inside taskSeq { ... } you can freely mix synchronous logic, let!/do! awaits, loops, +and conditionals.

          +
          +

          map and mapAsync

          +

          TaskSeq.map applies a synchronous function to every element:

          +
          let numbers : TaskSeq<int> = TaskSeq.ofSeq (seq { 1..5 })
+
+let doubled : TaskSeq<int> = numbers |> TaskSeq.map (fun n -> n * 2)
+
          +

          TaskSeq.mapAsync is the same but the projection returns Task<'U>, allowing async work per +element — for example, a database lookup or HTTP request:

          +
          let fetchDescription (n: int) : Task<string> =
+    task { return $"item {n}" } // placeholder for a real async call
+
+let descriptions : TaskSeq<string> = numbers |> TaskSeq.mapAsync fetchDescription
+
          +

          mapi and mapiAsync

          +

          TaskSeq.mapi and TaskSeq.mapiAsync additionally pass the zero-based index to the mapper:

          +
          let indexed : TaskSeq<string> =
+    numbers |> TaskSeq.mapi (fun i n -> $"[{i}] {n}")
+
          +
          +

          filter and filterAsync

          +

          TaskSeq.filter keeps only elements satisfying a synchronous predicate:

          +
          let evens : TaskSeq<int> = numbers |> TaskSeq.filter (fun n -> n % 2 = 0)
+
          +

          TaskSeq.filterAsync does the same with an async predicate — useful when the keep/discard +decision requires an async lookup:

          +
          let isInteresting (n: int) : Task<bool> =
+    task { return n > 2 } // placeholder
+
+let interesting : TaskSeq<int> = numbers |> TaskSeq.filterAsync isInteresting
+
          +

          TaskSeq.where and TaskSeq.whereAsync are aliases for filter and filterAsync provided +for readability.

          +
          +

          choose and chooseAsync

          +

          TaskSeq.choose applies a function that returns 'U option; only Some values are kept and +the option wrapper is removed — it is equivalent to filter + map in a single pass:

          +
          let strings : TaskSeq<string> =
+    TaskSeq.ofList [ ""; "hello"; ""; "world" ]
+
+let nonEmpty : TaskSeq<string> =
+    strings
+    |> TaskSeq.choose (fun s ->
+        if s.Length > 0 then Some s else None)
+
          +

          TaskSeq.chooseAsync accepts an async chooser:

          +
          let parseAsync (s: string) : Task<int option> =
+    task {
+        match System.Int32.TryParse s with
+        | true, n -> return Some n
+        | _ -> return None
+    }
+
+let parsed : TaskSeq<int> =
+    TaskSeq.ofList [ "1"; "two"; "3" ]
+    |> TaskSeq.chooseAsync parseAsync
+
          +
          +

          collect and collectSeq

          +

          TaskSeq.collect is the monadic bind for TaskSeq: it maps each element to a new task +sequence and concatenates all the results end-to-end:

          +
          let words : TaskSeq<string> =
+    TaskSeq.ofList [ "foo bar"; "baz qux" ]
+
+let chars : TaskSeq<string> =
+    words
+    |> TaskSeq.collectSeq (fun sentence ->
+        sentence.Split(' ') |> Array.toSeq)
+
          +

          TaskSeq.collect maps to another TaskSeq<'U>, while TaskSeq.collectSeq maps to a plain +seq<'U>. Async variants TaskSeq.collectAsync and TaskSeq.collectSeqAsync accept mappers +that return tasks.

          +
          +

          indexed

          +

          TaskSeq.indexed pairs each element with its zero-based index, returning a +TaskSeq<int * 'T>:

          +
          let withIndex : TaskSeq<int * string> =
+    TaskSeq.ofList [ "a"; "b"; "c" ] |> TaskSeq.indexed
+
+// yields (0,"a"), (1,"b"), (2,"c")
+
          +
          +

          Type conversions

          +

          TaskSeq.cast casts items from TaskSeq<obj> to a target reference type. For value types use +TaskSeq.unbox:

          +
          let boxed : TaskSeq<obj> =
+    TaskSeq.ofList [ box 1; box 2; box 3 ]
+
+let unboxed : TaskSeq<int> = boxed |> TaskSeq.unbox<int>
+
+let castToString : TaskSeq<string> =
+    TaskSeq.ofList [ box "hello"; box "world" ]
+    |> TaskSeq.cast<string>
+
          + +
          namespace System
          +
          namespace System.Threading
          +
          namespace System.Threading.Tasks
          +
          Multiple items
          namespace FSharp

          --------------------
          namespace Microsoft.FSharp
          +
          Multiple items
          namespace FSharp.Control

          --------------------
          namespace Microsoft.FSharp.Control
          +
          val labelEvenOdd: input: TaskSeq<int> -> TaskSeq<string>
          +
          val input: TaskSeq<int>
          +
          Multiple items
          module TaskSeq + +from FSharp.Control.TaskSeqExtensions

          --------------------
          type TaskSeq = + static member append: source1: TaskSeq<'T> -> source2: TaskSeq<'T> -> TaskSeq<'T> + static member appendSeq: source1: TaskSeq<'T> -> source2: 'T seq -> TaskSeq<'T> + static member box: source: TaskSeq<'T> -> TaskSeq<obj> + static member cast: source: TaskSeq<obj> -> TaskSeq<'U> + static member choose: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseAsync: chooser: ('T -> #Task<'U option>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseV: chooser: ('T -> 'U voption) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chooseVAsync: chooser: ('T -> #Task<'U voption>) -> source: TaskSeq<'T> -> TaskSeq<'U> + static member chunkBy: projection: ('T -> 'Key) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + static member chunkByAsync: projection: ('T -> #Task<'Key>) -> source: TaskSeq<'T> -> TaskSeq<'Key * 'T array> (requires equality) + ...

          --------------------
          type TaskSeq<'T> = System.Collections.Generic.IAsyncEnumerable<'T>
          <summary> + Represents a task sequence and is the output of using the <paramref name="taskSeq{...}" /> + computation expression from this library. It is an alias for <see cref="T:System.IAsyncEnumerable&lt;_&gt;" />. + </summary>

          --------------------
          type TaskSeq<'Machine,'T (requires 'Machine :> IAsyncStateMachine and 'Machine :> IResumableStateMachine<TaskSeqStateMachineData<'T>>)> = + inherit TaskSeqBase<'T> + interface IValueTaskSource + interface IValueTaskSource<bool> + interface IAsyncStateMachine + interface IAsyncEnumerable<'T> + interface IAsyncEnumerator<'T> + new: unit -> TaskSeq<'Machine,'T> + member InitMachineData: ct: CancellationToken * machine: byref<'Machine> -> unit + override MoveNextAsyncResult: unit -> ValueTask<bool>
          <summary> + Main implementation of generic <see cref="T:System.IAsyncEnumerable&lt;'T&gt;" /> and related interfaces, + which forms the meat of the logic behind <see cref="taskSeq" /> computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + </summary>

          --------------------
          new: unit -> TaskSeq<'Machine,'T>
          +
          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 taskSeq: TaskSeqBuilder
          <summary> + Builds an asynchronous task sequence based on <see cref="IAsyncEnumerable&lt;'T&gt;" /> using computation expression syntax. + </summary>
          +
          val n: int
          +
          Multiple items
          type Task = + interface IAsyncResult + interface IDisposable + new: action: Action -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable + 1 overload + member ContinueWith: continuationAction: Action<Task,obj> * state: obj -> Task + 19 overloads + member Dispose: unit -> unit + member GetAwaiter: unit -> TaskAwaiter + member RunSynchronously: unit -> unit + 1 overload + member Start: unit -> unit + 1 overload + member Wait: unit -> unit + 5 overloads + ...
          <summary>Represents an asynchronous operation.</summary>

          --------------------
          type Task<'TResult> = + inherit Task + new: ``function`` : Func<obj,'TResult> * state: obj -> unit + 7 overloads + member ConfigureAwait: continueOnCapturedContext: bool -> ConfiguredTaskAwaitable<'TResult> + 1 overload + member ContinueWith: continuationAction: Action<Task<'TResult>,obj> * state: obj -> Task + 19 overloads + member GetAwaiter: unit -> TaskAwaiter<'TResult> + member WaitAsync: cancellationToken: CancellationToken -> Task<'TResult> + 4 overloads + member Result: 'TResult + static member Factory: TaskFactory<'TResult>
          <summary>Represents an asynchronous operation that can return a value.</summary>
          <typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>

          --------------------
          Task(action: System.Action) : Task
          Task(action: System.Action, cancellationToken: System.Threading.CancellationToken) : Task
          Task(action: System.Action, creationOptions: TaskCreationOptions) : Task
          Task(action: System.Action<obj>, state: obj) : Task
          Task(action: System.Action, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task
          Task(action: System.Action<obj>, state: obj, cancellationToken: System.Threading.CancellationToken) : Task
          Task(action: System.Action<obj>, state: obj, creationOptions: TaskCreationOptions) : Task
          Task(action: System.Action<obj>, state: obj, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task

          --------------------
          Task(``function`` : System.Func<'TResult>) : Task<'TResult>
          Task(``function`` : System.Func<obj,'TResult>, state: obj) : Task<'TResult>
          Task(``function`` : System.Func<'TResult>, cancellationToken: System.Threading.CancellationToken) : Task<'TResult>
          Task(``function`` : System.Func<'TResult>, creationOptions: TaskCreationOptions) : Task<'TResult>
          Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: System.Threading.CancellationToken) : Task<'TResult>
          Task(``function`` : System.Func<obj,'TResult>, state: obj, creationOptions: TaskCreationOptions) : Task<'TResult>
          Task(``function`` : System.Func<'TResult>, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
          Task(``function`` : System.Func<obj,'TResult>, state: obj, cancellationToken: System.Threading.CancellationToken, creationOptions: TaskCreationOptions) : Task<'TResult>
          +
          Task.Delay(delay: System.TimeSpan) : Task
          Task.Delay(millisecondsDelay: int) : Task
          Task.Delay(delay: System.TimeSpan, timeProvider: System.TimeProvider) : Task
          Task.Delay(delay: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : Task
          Task.Delay(millisecondsDelay: int, cancellationToken: System.Threading.CancellationToken) : Task
          Task.Delay(delay: System.TimeSpan, timeProvider: System.TimeProvider, cancellationToken: System.Threading.CancellationToken) : Task
          +
          val numbers: TaskSeq<int>
          +
          static member TaskSeq.ofSeq: source: 'T seq -> TaskSeq<'T>
          +
          Multiple items
          val seq: sequence: 'T seq -> 'T seq

          --------------------
          type 'T seq = System.Collections.Generic.IEnumerable<'T>
          +
          val doubled: TaskSeq<int>
          +
          static member TaskSeq.map: mapper: ('T -> 'U) -> source: TaskSeq<'T> -> TaskSeq<'U>
          +
          val fetchDescription: n: int -> Task<string>
          +
          val task: TaskBuilder
          +
          val descriptions: TaskSeq<string>
          +
          static member TaskSeq.mapAsync: mapper: ('T -> #Task<'U>) -> source: TaskSeq<'T> -> TaskSeq<'U>
          +
          val indexed: TaskSeq<string>
          +
          static member TaskSeq.mapi: mapper: (int -> 'T -> 'U) -> source: TaskSeq<'T> -> TaskSeq<'U>
          +
          val i: int
          +
          val evens: TaskSeq<int>
          +
          static member TaskSeq.filter: predicate: ('T -> bool) -> source: TaskSeq<'T> -> TaskSeq<'T>
          +
          val isInteresting: n: int -> Task<bool>
          +
          type bool = System.Boolean
          +
          val interesting: TaskSeq<int>
          +
          static member TaskSeq.filterAsync: predicate: ('T -> #Task<bool>) -> source: TaskSeq<'T> -> TaskSeq<'T>
          +
          val strings: TaskSeq<string>
          +
          static member TaskSeq.ofList: source: 'T list -> TaskSeq<'T>
          +
          val nonEmpty: TaskSeq<string>
          +
          static member TaskSeq.choose: chooser: ('T -> 'U option) -> source: TaskSeq<'T> -> TaskSeq<'U>
          +
          val s: string
          +
          property System.String.Length: int with get
          +
          union case Option.Some: Value: 'T -> Option<'T>
          +
          union case Option.None: Option<'T>
          +
          val parseAsync: s: string -> Task<int option>
          +
          type 'T option = Option<'T>
          +
          [<Struct>] +type Int32 = + member CompareTo: value: int -> int + 1 overload + member Equals: obj: int -> bool + 1 overload + member GetHashCode: unit -> int + member GetTypeCode: unit -> TypeCode + member ToString: unit -> string + 3 overloads + member TryFormat: utf8Destination: Span<byte> * bytesWritten: byref<int> * ?format: ReadOnlySpan<char> * ?provider: IFormatProvider -> bool + 1 overload + static member Abs: value: int -> int + static member BigMul: left: int * right: int -> int64 + static member Clamp: value: int * min: int * max: int -> int + static member CopySign: value: int * sign: int -> int + ...
          <summary>Represents a 32-bit signed integer.</summary>
          +
          System.Int32.TryParse([<NotNullWhenAttribute (true)>] s: string, result: byref<int>) : bool
          System.Int32.TryParse(s: System.ReadOnlySpan<char>, result: byref<int>) : bool
          System.Int32.TryParse(utf8Text: System.ReadOnlySpan<byte>, result: byref<int>) : bool
          System.Int32.TryParse([<NotNullWhenAttribute (true)>] s: string, provider: System.IFormatProvider, result: byref<int>) : bool
          System.Int32.TryParse(s: System.ReadOnlySpan<char>, provider: System.IFormatProvider, result: byref<int>) : bool
          System.Int32.TryParse(utf8Text: System.ReadOnlySpan<byte>, provider: System.IFormatProvider, result: byref<int>) : bool
          System.Int32.TryParse([<NotNullWhenAttribute (true)>] s: string, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool
          System.Int32.TryParse(s: System.ReadOnlySpan<char>, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool
          System.Int32.TryParse(utf8Text: System.ReadOnlySpan<byte>, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool
          +
          val parsed: TaskSeq<int>
          +
          static member TaskSeq.chooseAsync: chooser: ('T -> #Task<'U option>) -> source: TaskSeq<'T> -> TaskSeq<'U>
          +
          val words: TaskSeq<string>
          +
          val chars: TaskSeq<string>
          +
          static member TaskSeq.collectSeq: binder: ('T -> #('U seq)) -> source: TaskSeq<'T> -> TaskSeq<'U>
          +
          val sentence: string
          +
          System.String.Split(separator: System.ReadOnlySpan<char>) : string array
             (+0 other overloads)
          System.String.Split([<System.ParamArray>] separator: char array) : string array
             (+0 other overloads)
          System.String.Split(separator: string array, options: System.StringSplitOptions) : string array
             (+0 other overloads)
          System.String.Split(separator: string, ?options: System.StringSplitOptions) : string array
             (+0 other overloads)
          System.String.Split(separator: char array, options: System.StringSplitOptions) : string array
             (+0 other overloads)
          System.String.Split(separator: char array, count: int) : string array
             (+0 other overloads)
          System.String.Split(separator: char, ?options: System.StringSplitOptions) : string array
             (+0 other overloads)
          System.String.Split(separator: string array, count: int, options: System.StringSplitOptions) : string array
             (+0 other overloads)
          System.String.Split(separator: string, count: int, ?options: System.StringSplitOptions) : string array
             (+0 other overloads)
          System.String.Split(separator: char array, count: int, options: System.StringSplitOptions) : string array
             (+0 other overloads)
          +
          module Array + +from Microsoft.FSharp.Collections
          +
          val toSeq: array: 'T array -> 'T seq
          +
          val withIndex: TaskSeq<int * string>
          +
          static member TaskSeq.indexed: source: TaskSeq<'T> -> TaskSeq<int * 'T>
          +
          val boxed: TaskSeq<obj>
          +
          type obj = System.Object
          +
          val box: value: 'T -> objnull
          +
          val unboxed: TaskSeq<int>
          +
          static member TaskSeq.unbox: source: TaskSeq<obj> -> TaskSeq<'U> (requires value type)
          +
          val castToString: TaskSeq<string>
          +
          static member TaskSeq.cast: source: TaskSeq<obj> -> TaskSeq<'U>
          + +
          +
          + + + +
          +
            +

            Type something to start searching.

            +
            +             + + + + + + + + \ No newline at end of file diff --git a/content/fsdocs-default.css b/content/fsdocs-default.css new file mode 100755 index 00000000..7dea2286 --- /dev/null +++ b/content/fsdocs-default.css @@ -0,0 +1,1288 @@ +:root { + --monospace-font: "Fira Code", monospace; + --system-font: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif; + --heading-font-family: var(--system-font); + + --spacing-50: 4px; + --spacing-100: 8px; + --spacing-200: 12px; + --spacing-300: 16px; + --spacing-400: 24px; + --spacing-500: 32px; + --spacing-600: 48px; + --spacing-700: 64px; + --spacing-800: 96px; + --spacing-900: 128px; + --spacing-950: 192px; + + --font-50: 12px; + --font-100: 14px; + --font-200: 16px; + --font-300: 18px; + --font-400: 20px; + --font-500: 24px; + --font-600: 30px; + --font-700: 36px; + --font-800: 48px; + --font-900: 60px; + --font-950: 72px; + + --line-height: 1.5; + --heading-line-height: 1.25; + --radius: 6px; + + --container-sm: 768px; + --container-md: 960px; + --container-lg: 1024px; + --container-xl: 1200px; + --container-xxl: 1400px; + --container-xxxl: 1800px; + --main-menu-width: 260px; + --page-menu-width: var(--main-menu-width); + --header-height: 60px; + --body-grid-template-columns: var(--main-menu-width) minmax(0, 1fr); + --body-grid-template-columns-xl: var(--main-menu-width) minmax(0, 1fr) var(--page-menu-width); + --main-menu-grid-row: 2; + --main-menu-grid-column: 1; + --main-grid-row: 2; + --main-grid-column: 2; + --dialog-width: 500px; + --api-docs-first-column-min-width: 320px; + --api-docs-second-column-min-width: 240px; + + /* light theme */ + --primary: #1e8bc3; + --background: #f5f5f6; + --text-color: #020202; + --text-hover: #282828; + --heading-color: #2e293a; + --code-background: #ffffff; + --code-color: #1a4b0b; + --header-background: #f9fbfc; + --header-border: #e8ecf1; + --header-link-color: var(--text-color); + --mobile-menu-background: var(--header-background); + --menu-color: var(--text-color); + --menu-item-hover-background: #eff0f1; + --menu-item-hover-color: var(--menu-color); + --doc-tip-background: #F7F7F7; + --link-color: #4871f7; + --link-hover: #91aafa; + --search-background: rgb(229, 231, 235); + --nav-category: rgb(156, 163, 175); + --scrollbar-track-background: #424242; + --scrollbar-track-border: #4A4A4A; + --scrollbar-thumb-background: #686868; + --shadow-color: hsla(0, 0%, 0%, .1); + --main-shadow-color: hsla(0, 0%, 0%, .025); + --aside-background: var(--header-background); + --blockquote-bacground-color: var(--header-background); + --blockquote-color: var(--text-color); + --on-this-page-color: var(--menu-color); + --page-menu-background-color: var(--header-background); + --page-menu-background-border-color: var(--header-border); + --page-menu-background-hover-border-color: var(--text-color); + --nav-item-border-color: var(--header-border); + --nav-item-active-border-color: var(--text-color); + --dialog-background-color: var(--header-background); + --dialog-empty-color: var(--nav-category); + --dialog-icon-color: var(--text-color); + --dialog-link-color: var(--link-color); + --dialog-link-hover-color: var(--header-background); + --dialog-link-hover-background-color: var(--link-hover); + --code-fence-border-color: transparent; + + --header-brand-text-transform: none; + + --code-strings-color: #0093A1; + --code-printf-color: #6B2FBA; + --code-escaped-color: #EA8675; + --code-identifiers-color: #6B2FBA; + --code-module-color: #009999; + --code-reference-color: #4974D1; + --code-value-color: #1B6600; + --code-interface-color: #43AEC6; + --code-typearg-color: #43AEC6; + --code-disposable-color: #43AEC6; + --code-property-color: #43AEC6; + --code-punctuation-color: #43AEC6; + --code-punctuation2-color: var(--text-color); + --code-function-color: #6B2FBA; + --code-function2-color: #6B2FBA; + --code-activepattern-color: #4ec9b0; + --code-unioncase-color: #4ec9b0; + --code-enumeration-color: #8C6C41; + --code-keywords-color: #0F54D6; + --code-comment-color: #707070; + --code-operators-color: #0F54D6; + --code-numbers-color: #009999; + --code-linenumbers-color: #80b0b0; + --code-mutable-color: #1b6600; + --code-inactive-color: #808080; + --code-preprocessor-color: #af75c1; + --code-fsioutput-color: #808080; + --code-tooltip-color: #d1d1d1; +} + +/* dark theme */ + +[data-theme=dark] { + --primary: #81cfe0; + --background: rgb(20, 21, 26); + --text-color: #F7F7F7; + --text-hover: #FFF; + --heading-color: rgb(229, 231, 235); + --code-background: #28282D; + --code-color: #f5f5f6; + --header-background: #0c1318; + --header-border: #9b9b9b; + --menu-item-hover-background: #2c2624; + --doc-tip-background: #2e293a; + --link-color: #c5eff7; + --search-background: #020202; + --nav-category: rgb(207, 211, 215); + --code-strings-color: #86b4b9; + --code-printf-color: #6B2FBA; + --code-escaped-color: #EA8675; + --code-identifiers-color: #d1b3f5; + --code-module-color: #15e1e1; + --code-reference-color: #40fddd; + --code-value-color: #ffb4e9; + --code-interface-color: #43AEC6; + --code-typearg-color: #43AEC6; + --code-disposable-color: #6dd6f1; + --code-property-color: #6acfe7; + --code-punctuation-color: #43AEC6; + --code-punctuation2-color: var(--text-color); + --code-function-color: #6B2FBA; + --code-function2-color: #cbda9d; + --code-activepattern-color: #4ec9b0; + --code-unioncase-color: #4ec9b0; + --code-enumeration-color: #8C6C41; + --code-keywords-color: #a7c2f8; + --code-comment-color: #84d16e; + --code-operators-color: #b4c6ee; + --code-numbers-color: #009999; + --code-linenumbers-color: #80b0b0; + --code-mutable-color: #1b6600; + --code-inactive-color: #808080; + --code-preprocessor-color: #af75c1; + --code-fsioutput-color: #808080; + --code-tooltip-color: #d1d1d1; +} + +/* CSS Reset, source: https://www.joshwcomeau.com/css/custom-css-reset/ */ +*, *::before, *::after { + box-sizing: border-box; +} + +* { + margin: 0; +} + +html { + overflow-y: hidden; +} + +body { + line-height: 1.5; + -webkit-font-smoothing: antialiased; +} + +picture, video, canvas, svg { + display: block; + max-width: 100%; +} + +input, button, textarea, select { + font: inherit; +} + +p, h1, h2, h3, h4, h5, h6 { + overflow-wrap: break-word; +} + +/* Main layout */ +body { + font-family: var(--system-font); + background-color: var(--background); + color: var(--text-color); + line-height: var(--line-height); + scroll-padding-top: var(--header-height); + scroll-behavior: smooth; +} + +header { + background-color: var(--header-background); + padding: var(--spacing-300); + height: var(--header-height); + display: flex; + align-items: center; + justify-content: space-between; + position: sticky; + top: 0; + z-index: 100; + box-shadow: 0 1px 1px var(--shadow-color); + + & .start { + display: flex; + align-items: center; + + & #menu-toggle { + position: relative; + height: var(--spacing-500); + width: var(--spacing-500); + border: 1px solid var(--header-border); + border-radius: var(--radius); + box-shadow: 0 1px 1px var(--shadow-color); + + & .icon { + top: 4px; + left: 4px; + width: calc(var(--spacing-500) - 4px); + height: calc(var(--spacing-500) - 4px); + position: absolute; + color: var(--header-link-color); + + &.open { + display: none; + } + } + + & input[type=checkbox] { + position: absolute; + width: 100%; + height: 100%; + left: 0; + top: 0; + appearance: none; + cursor: pointer; + } + + & .menu { + visibility: hidden; + height: 0; + opacity: 0; + width: 100%; + transition: all 0.2s ease-in-out; + position: fixed; + top: var(--header-height); + left: 0; + background-color: var(--mobile-menu-background); + list-style: none; + padding: var(--spacing-300); + overflow-y: auto; + } + + & input:checked + .menu { + visibility: visible; + opacity: 1; + height: calc(100vh - var(--header-height)); + } + + &:has(input:checked) { + .icon.open { + display: block; + } + + .icon.closed { + display: none; + } + } + } + + > a { + display: flex; + justify-content: center; + align-items: center; + text-decoration: none; + color: var(--header-link-color); + } + + & img { + margin: 0 var(--spacing-200); + border-radius: var(--radius); + height: calc(var(--spacing-500) - 2px); + } + + & strong { + line-height: var(--spacing-500); + font-size: var(--font-200); + display: block; + text-transform: var(--header-brand-text-transform); + font-weight: 500; + } + } + + & .end { + display: flex; + align-items: center; + + & a { + display: none; + color: var(--header-link-color); + } + + & > .themeToggle, & > .search { + cursor: pointer; + height: var(--spacing-500); + align-items: center; + margin: 0 var(--spacing-100); + } + + & > .search { + display: flex; + color: var(--header-link-color); + } + } +} + +aside { + display: none; +} + +main { + height: calc(100dvh - var(--header-height)); +} + +#content { + padding: var(--spacing-300); + + > *:first-child { + margin-top: 0; + } +} + +#fsdocs-page-menu { + display: none; + padding: var(--spacing-300); + background-color: var(--page-menu-background-color); + border-left: 1px solid var(--page-menu-background-border-color); + + &:has(.empty) { + display: none; + } + + > #on-this-page { + font-size: var(--font-100); + line-height: 1.5; + color: var(--on-this-page-color); + font-weight: 500; + margin: 0 0 var(--spacing-50); + } + + & ul { + list-style: none; + padding: 0; + margin: 0; + + & li { + border-left: 1px solid var(--header-border); + margin: 0; + + &:hover, &:focus { + border-color: var(--page-menu-background-hover-border-color); + } + + & a { + color: var(--menu-color); + text-decoration: none; + padding: var(--spacing-50) var(--spacing-100); + display: block; + overflow-x: hidden; + text-overflow: ellipsis; + } + + &.level-3 { + padding-left: var(--spacing-100); + } + + &.level-4 { + padding-left: var(--spacing-300); + } + } + } +} + +/* menu items */ +.menu { + padding: 0; + + & li { + list-style: none; + margin: 0; + } + + .nav-header { + margin-top: var(--spacing-300); + text-transform: uppercase; + font-size: var(--font-200); + font-weight: 500; + color: var(--menu-color); + } +} + +.nav-header:first-child { + margin-top: 0; +} + +.nav-item { + border-left: 1px solid var(--nav-item-border-color); + + & a { + color: var(--menu-color); + text-decoration: none; + font-size: var(--font-200); + padding: var(--spacing-100); + display: block; + overflow-x: hidden; + text-overflow: ellipsis; + + &:hover { + background-color: var(--menu-item-hover-background); + color: var(--menu-item-hover-color); + } + } + + &:hover, &.active { + border-color: var(--nav-item-active-border-color); + } + + &.active { + font-weight: 600; + } +} + +@media screen and (min-width: 768px) { + #menu-toggle { + display: none; + } + + body { + display: grid; + grid-template-rows: var(--header-height) minmax(0, 1fr); + grid-template-columns:var(--body-grid-template-columns); + gap: 0; + } + + header { + border-bottom: 1px solid var(--header-border); + grid-row: 1; + grid-column: span 2; + box-shadow: none; + + & .end { + > a { + display: flex; + align-items: center; + text-decoration: none; + + &:hover { + color: var(--link-hover); + } + } + } + } + + aside, main { + height: calc(100vh - var(--header-height)); + } + + aside { + position: sticky; + top: var(--header-height); + } + + #fsdocs-main-menu { + display: block; + padding: var(--spacing-300) var(--spacing-500); + background-color: var(--aside-background); + width: var(--main-menu-width); + border-right: 1px solid var(--header-border); + grid-row: var(--main-menu-grid-row); + grid-column: var(--main-menu-grid-column); + overflow-y: auto; + } + + main { + grid-row: var(--main-grid-row); + grid-column: var(--main-grid-column); + box-shadow: inset 1px 1px var(--main-shadow-color); + border-radius: 0; + } + + #content { + padding-left: var(--spacing-300); + padding-right: var(--spacing-300); + } +} + +@media screen and (min-width: 768px) { + #content { + max-width: calc(100vw - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + margin: 0 auto; + } +} + +@media screen and (min-width: 960px) { + #content { + max-width: calc(var(--container-md) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1024px) { + #content { + max-width: calc(var(--container-lg) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1200px) { + body { + grid-template-columns: var(--body-grid-template-columns-xl); + + &.api-docs { + grid-template-columns: var(--body-grid-template-columns); + + #content { + max-width: calc(var(--container-xl) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } + + #fsdocs-page-menu { + display: none; + } + } + } + + header { + grid-column: span 3; + } + + #fsdocs-page-menu { + grid-column: 3; + display: block; + } + + #content { + max-width: calc(var(--container-xl) - var(--main-menu-width) - var(--page-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1400px) { + body { + &.api-docs, &:has(#fsdocs-page-menu .empty) { + #content { + max-width: calc(var(--container-xxl) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } + } + } + + #content { + max-width: calc(var(--container-xxl) - var(--main-menu-width) - var(--page-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +@media screen and (min-width: 1800px) { + body { + &.api-docs, &:has(#fsdocs-page-menu .empty) { + #content { + max-width: calc(var(--container-xxxl) - var(--main-menu-width) - var(--spacing-300) - var(--spacing-300)); + } + } + } + + #content { + max-width: calc(var(--container-xxxl) - var(--main-menu-width) - var(--page-menu-width) - var(--spacing-300) - var(--spacing-300)); + } +} + +/* Headings */ +h1, h2, h3, h4, h5, h6 { + font-family: var(--heading-font-family); +} + +h1 a, h2 a, h3 a, h4 a, h5 a, h6 a { + color: var(--heading-color); + text-decoration: none; +} + +h1 { + font-size: var(--font-600); + line-height: var(--heading-line-height); + margin-bottom: var(--spacing-400); + margin-top: var(--spacing-50); +} + +h2 { + font-size: var(--font-500); + line-height: var(--heading-line-height); + margin-top: var(--spacing-400); + margin-bottom: var(--spacing-300); +} + +h3 { + font-size: var(--font-400); + line-height: var(--heading-line-height); + margin-top: var(--spacing-300); + margin-bottom: var(--spacing-200); +} + +h4 { + font-weight: bold; +} + +h4, h5, h6 { + font-size: var(--font-300); + margin-top: var(--spacing-200); + margin-bottom: var(--spacing-200); +} + +@media screen and (min-width: 768px) { + h1 { + font-size: var(--font-800); + margin-bottom: var(--spacing-400); + line-height: var(--heading-line-height); + } + + h2 { + font-size: var(--font-700); + margin-top: var(--spacing-500); + margin-bottom: var(--spacing-400); + } + + h3 { + font-size: var(--font-600); + margin-top: var(--spacing-500); + margin-bottom: var(--spacing-200); + } + + h4 { + font-size: var(--font-500); + } + + h4, h5, h6 { + margin-top: var(--spacing-300); + } +} + +/* Common items */ +a { + color: var(--link-color); +} + +p { + line-height: 1.8; + margin-top: var(--spacing-300); +} + +ol, ul { + padding-left: var(--spacing-400); +} + +ol li, ul li { + margin: var(--spacing-100) 0; +} + +img { + max-width: 100%; +} + +#content > table { + margin: var(--spacing-300) 0; +} + +blockquote { + border-left: var(--spacing-50) solid var(--primary); + margin: var(--spacing-200) 0; + margin-left: var(--spacing-200); + padding: var(--spacing-100) var(--spacing-300); + background-color: var(--blockquote-bacground-color); + color: var(--blockquote-color); + + > p { + margin: 0; + padding: 0; + } +} + +@media screen and (min-width: 768px) { + blockquote { + margin-left: var(--spacing-400); + } +} + +/* Code snippets */ + +/* reset browser style */ +pre { + margin: 0; + padding: 0; +} + +code, table.pre, pre { + background-color: var(--code-background); + color: var(--code-color); + font-family: var(--monospace-font); + font-variant-ligatures: none; + font-size: var(--font-200); + -webkit-text-size-adjust: 100%; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + font-size: inherit; +} + +table.pre, #content > pre.fssnip { + border: 1px solid var(--code-fence-border-color); +} + +table.pre, pre.fssnip.highlighted { + margin: var(--spacing-300) 0; + padding: var(--spacing-200); +} + +table.pre .snippet pre.fssnip { + padding: 0; + margin: 0; +} + +p > code, li > code { + padding: 2px var(--spacing-50); +} + +table.pre, pre > code { + display: block; +} + +pre.fssnip > code { + max-width: initial; + margin-bottom: initial; +} + +/* avoid problems with transparent background colors */ +pre.fssnip.highlighted > code, table.pre .fssnip, table.pre .fssnip code { + background-color: transparent; +} + +/* Custom scrollbar styling */ +body, aside, #menu-toggle .menu, table.pre, code, +.fsdocs-entity-xmldoc > div > pre, div.fsdocs-summary > pre, +dialog ul, div.fsdocs-tip, .fsdocs-xmldoc > pre { + overflow-x: auto; + max-width: 100%; + + &::-webkit-scrollbar { + height: var(--spacing-100); + width: var(--spacing-100); + } + + &::-webkit-scrollbar-track { + background-color: var(--scrollbar-track-background); + border: 1px solid var(--scrollbar-track-border); + } + + &::-webkit-scrollbar-thumb { + background-color: var(--scrollbar-thumb-background); + } +} + +body, aside, #menu-toggle .menu, table.pre, code, +.fsdocs-entity-xmldoc > div > pre, div.fsdocs-summary > pre, +dialog ul, div.fsdocs-tip, .fsdocs-xmldoc > pre { + @media screen and (min-width: 768px) { + &::-webkit-scrollbar { + height: var(--spacing-200); + width: var(--spacing-300); + } + } +} + +table.pre, code, pre.fssnip { + border-radius: var(--radius); +} + +/* Code coloring */ +.param-name, +.return-name, +.param { + font-weight: 900; + font-size: var(--font-100); + font-family: var(--monospace-font); + font-variant-ligatures: none; +} + +.fssnip { + /* strings --- and stlyes for other string related formats */ + + & span.s { + color: var(--code-strings-color); + } + + /* printf formatters */ + + & span.pf { + color: var(--code-printf-color); + } + + /* escaped chars */ + + & span.e { + color: var(--code-escaped-color); + } + + /* identifiers --- and styles for more specific identifier types */ + + & span.id { + color: var(--code-identifiers-color);; + } + + /* module */ + + & span.m { + color: var(--code-module-color); + } + + /* reference type */ + + & span.rt { + color: var(--code-reference-color); + } + + /* value type */ + + & span.vt { + color: var(--code-value-color); + } + + /* interface */ + + & span.if { + color: var(--code-interface-color); + } + + /* type argument */ + + & span.ta { + color: var(--code-typearg-color); + } + + /* disposable */ + + & span.d { + color: var(--code-disposable-color); + } + + /* property */ + + & span.prop { + color: var(--code-property-color); + } + + /* punctuation */ + + & span.p { + color: var(--code-punctuation-color); + } + + & span.pn { + color: var(--code-punctuation2-color); + } + + /* function */ + + & span.f { + color: var(--code-function-color); + } + + & span.fn { + color: var(--code-function2-color); + } + + /* active pattern */ + + & span.pat { + color: var(--code-activepattern-color); + } + + /* union case */ + + & span.u { + color: var(--code-unioncase-color); + } + + /* enumeration */ + + & span.e { + color: var(--code-enumeration-color); + } + + /* keywords */ + + & span.k { + color: var(--code-keywords-color); + } + + /* comment */ + + & span.c { + color: var(--code-comment-color); + font-weight: 400; + font-style: italic; + } + + /* operators */ + + & span.o { + color: var(--code-operators-color); + } + + /* numbers */ + + & span.n { + color: var(--code-numbers-color); + } + + /* line number */ + + & span.l { + color: var(--code-linenumbers-color); + } + + /* mutable var or ref cell */ + + & span.v { + color: var(--code-mutable-color); + font-weight: bold; + } + + /* inactive code */ + + & span.inactive { + color: var(--code-inactive-color); + } + + /* preprocessor */ + + & span.prep { + color: var(--code-preprocessor-color); + } + + /* fsi output */ + + & span.fsi { + color: var(--code-fsioutput-color); + } +} + +/* tooltips */ +div.fsdocs-tip { + z-index: 1000; + display: none; + background-color: var(--doc-tip-background); + border-radius: var(--radius); + border: 1px solid var(--header-border); + padding: var(--spacing-200); + font-family: var(--monospace-font); + font-variant-ligatures: none; + color: var(--code-color); + box-shadow: 0 1px 1px var(--shadow-color); + + & code { + color: var(--code-color); + } +} + +span[onmouseout] { + cursor: pointer; +} + +/* API docs */ +#content > div > h2:first-child { + margin-top: 0; +} + +.fsdocs-member-list-header { + display: flex; + flex-direction: row; + justify-content: space-between; + align-items: flex-start; +} + +.fsdocs-xmldoc { + & pre { + overflow-x: auto; + } +} + +.table { + width: 100%; + table-layout: fixed; + + & thead tr td { + font-weight: bold; + padding: var(--spacing-400) 0; + } + + & tr { + display: flex; + flex-flow: row wrap; + column-gap: var(--spacing-300); + + & td:first-of-type { + flex: 25 0 0; + min-width: var(--api-docs-first-column-min-width); + overflow-x: hidden; + text-overflow: ellipsis; + overflow-wrap: break-word; + + & p { + margin: unset; + } + } + + & td:nth-of-type(2) { + flex: 75 0 0; + min-width: var(--api-docs-second-column-min-width); + } + } + + & tbody td { + border-top: 1px solid var(--header-border); + padding: var(--spacing-300) 0; + } + + .fsdocs-entity-xmldoc { + > div { + display: flex; + flex-direction: row; + justify-content: space-between; + align-items: flex-start; + + & p.fsdocs-summary { + margin: 0; + flex-grow: 1; + } + + & pre { + margin-bottom: var(--spacing-200); + padding: var(--spacing-50); + flex-grow: 1; + overflow-x: auto; + } + } + } + + .fsdocs-summary-contents { + display: flex; + flex-direction: column; + justify-content: flex-start; + align-items: flex-start; + } + + .fsdocs-member-xmldoc-column { + width: 100%; + display: flex; + flex-direction: column; + justify-content: flex-start; + + > * { + margin: var(--spacing-200) 0 var(--spacing-200) var(--spacing-300); + + &:first-child:is(.icon-button-row) { + margin-block: 0; + } + + &:nth-child(2) { + margin-top: 0; + } + + &:last-child { + margin-bottom: 0; + } + } + } + + .icon-button-row { + display: flex; + flex-direction: row; + justify-content: flex-end; + align-items: flex-start; + height: calc(-1 * var(--spacing-200)); + } + + .fsdocs-member-xmldoc { + & summary { + display: list-item; + counter-increment: list-item 0; + list-style: disclosure-closed outside; + cursor: pointer; + + > .fsdocs-summary { + display: flex; + flex-direction: row; + justify-content: space-between; + align-items: flex-start; + + & p.fsdocs-summary { + margin: 0; + flex-grow: 1; + } + + & pre { + margin-bottom: var(--spacing-200); + padding: var(--spacing-50); + flex-grow: 1; + overflow-x: auto; + } + } + } + + & details[open] summary { + list-style-type: disclosure-open; + margin-bottom: var(--spacing-200); + } + + & details > * { + margin: var(--spacing-200) 0 var(--spacing-200) var(--spacing-300); + + &:is(summary) { + margin-block: 0; + } + + &:first-child { + margin-top: 0; + } + + &:last-child { + margin-bottom: 0; + } + } + + .fsdocs-return-name, .fsdocs-param-name { + font-weight: 500; + } + + .fsdocs-param-docs p { + margin: var(--spacing-200) 0; + } + + .fsdocs-example-header { + font-size: var(--font-200); + } + + > div.fsdocs-summary { + display: flex; + flex-direction: row; + justify-content: space-between; + align-items: flex-start; + margin: 0 0 0 var(--spacing-300); + + & p { + margin: 0; + } + } + } +} + +.fsdocs-source-link { + display: none; + padding: 0 var(--spacing-100); + color: var(--text-color); + cursor: pointer; + height: var(--font-500); + width: var(--font-500); + margin: 0 var(--spacing-50); + + &:hover { + color: var(--primary); + } +} + +@media screen and (min-width: 768px) { + .fsdocs-source-link { + display: block; + } +} + +/* Search */ +::backdrop { + background-color: #020202; + opacity: 0.5; +} + +dialog { + background-color: var(--dialog-background-color); + margin: var(--spacing-700) auto; + padding: var(--spacing-100); + border: none; + opacity: 0; + visibility: hidden; + transition: all 0.2s ease-in-out; + border-radius: var(--radius); + width: var(--dialog-width); + + &[open] { + opacity: 1; + visibility: visible; + } + + & input[type=search] { + margin: 0; + display: block; + width: 100%; + padding: var(--spacing-200); + outline: 1px solid var(--primary); + border-radius: var(--radius); + border: none; + + &::placeholder { + font-size: var(--font-400); + } + } + + .empty { + color: var(--dialog-empty-color); + text-align: center; + font-size: var(--font-100); + margin: var(--spacing-100); + margin-bottom: 0; + } + + & ul { + overflow-y: auto; + max-height: calc(50vh - var(--spacing-700) - var(--spacing-700)); + list-style: none; + padding: 0; + + & li { + margin: 0; + border-bottom: 1px solid var(--header-border); + + &:hover { + & a, & a iconify-icon { + background-color: var(--dialog-link-hover-background-color); + color: var(--dialog-link-hover-color); + } + } + + & a { + display: flex; + padding: var(--spacing-300); + overflow-x: hidden; + color: var(--dialog-link-color); + + & iconify-icon { + color: var(--dialog-icon-color); + width: 24px; + margin-right: var(--spacing-200); + } + } + } + } +} + +/* Variables don't seem to work on ::backdrop */ +[data-theme=dark] { + ::backdrop { + opacity: 0.75; + } +} diff --git a/content/fsdocs-details-set-expanded.js b/content/fsdocs-details-set-expanded.js new file mode 100755 index 00000000..f1518cd1 --- /dev/null +++ b/content/fsdocs-details-set-expanded.js @@ -0,0 +1,9 @@ +const expandDetails = !!JSON.parse(localStorage.getItem('details-expanded')); + +addEventListener('load', _ => { + if (expandDetails) { + for (const details of document.getElementsByTagName('details')) { + details.setAttribute('open', 'true'); + } + } +}); diff --git a/content/fsdocs-details-toggle.js b/content/fsdocs-details-toggle.js new file mode 100755 index 00000000..b8a3f67b --- /dev/null +++ b/content/fsdocs-details-toggle.js @@ -0,0 +1,46 @@ +import { LitElement, html, css } from 'https://cdn.jsdelivr.net/gh/lit/dist@3/core/lit-core.min.js'; + +const detailsExpanded = !!JSON.parse(localStorage.getItem('details-expanded')); + +export class DetailsToggle extends LitElement { + static properties = { + _detailsExpanded: { state: true, type: Boolean }, + }; + + constructor() { + super(); + this._detailsExpanded = detailsExpanded; + document.addEventListener('detailstoggled', e => this._detailsExpanded = !!e?.detail?.expanding); + } + + static styles = css` + :host { + cursor: pointer; + } + `; + + toggleDetails() { + this._detailsExpanded = !this._detailsExpanded; + localStorage.setItem('details-expanded', JSON.stringify(this._detailsExpanded)); + if (this._detailsExpanded) { + for (const details of document.getElementsByTagName('details')) { + details.setAttribute('open', 'true'); + } + } else { + for (const details of document.getElementsByTagName('details')) { + details.removeAttribute('open'); + } + } + document.dispatchEvent(new CustomEvent('detailstoggled', { detail: { expanding: this._detailsExpanded } })); + } + + render() { + const icon = this._detailsExpanded ? 'carbon:collapse-categories' : 'carbon:expand-categories'; + const title = this._detailsExpanded ? 'Collapse details' : 'Expand details'; + return html` + + `; + } +} + +customElements.define('fsdocs-details-toggle', DetailsToggle); diff --git a/content/fsdocs-search.js b/content/fsdocs-search.js new file mode 100755 index 00000000..9e4c21de --- /dev/null +++ b/content/fsdocs-search.js @@ -0,0 +1,126 @@ +import Fuse from "https://esm.sh/fuse.js@7.0.0"; + +const searchBtn = document.querySelector("#search-btn"); + +function hideSearchBtn() { + // Hide search icon if we can't search in the first place. + searchBtn.style.display = 'none'; +} + +function debounce(mainFunction, delay) { + // Declare a variable called 'timer' to store the timer ID + let timer; + + // Return an anonymous function that takes in any number of arguments + return function (...args) { + // Clear the previous timer to prevent the execution of 'mainFunction' + clearTimeout(timer); + + // Set a new timer that will execute 'mainFunction' after the specified delay + timer = setTimeout(() => { + mainFunction(...args); + }, delay); + }; +} + +const root = document.documentElement.getAttribute("data-root"); +if (root && searchBtn) { + let fuse = null; + const searchIndexUrl = `${root}/index.json`; + fetch(searchIndexUrl, {}) + .then(response => response.json()) + .then(index => { + fuse = new Fuse(index, { + includeScore: true, + keys: ['uri', 'title', 'content', 'headings'], + includeMatches: true, + limit: 20, + ignoreLocation: true, + threshold: 0.6, + minMatchCharLength: 2, + ignoreFieldNorm: true, + shouldSort: true + }); + }) + .catch(() => { + hideSearchBtn(); + }) + + const searchDialog = document.querySelector("dialog"); + const empty = document.querySelector("dialog .empty"); + const resultsElement = document.querySelector("dialog ul"); + const searchBox = document.querySelector("dialog input[type=search]"); + + searchBtn.addEventListener("click", () => { + searchDialog.showModal(); + }) + + searchDialog.addEventListener("click", ev => { + if (ev.target.tagName === "DIALOG") { + searchBox.value = ''; + searchDialog.close() + } + }) + + function searchAux(searchTerm) { + if (!fuse) return; + + const results = fuse.search(searchTerm); + if (results.length === 0) { + clearResults(); + empty.textContent = "No results were found"; + } else { + if (location.hostname === 'localhost'){ + console.table(results); + } + + empty.style.display = 'none'; + const newResultNodes = + results + .map(result => { + const item = result.item; + const li = document.createElement("li"); + const a = document.createElement("a"); + a.setAttribute("href", item.uri); + const icon = document.createElement("iconify-icon"); + icon.setAttribute("width", "24"); + icon.setAttribute("height", "24"); + icon.setAttribute("icon", item.type === "content" ? "iconoir:page" : "bxs:file-doc") + a.append(icon, item.title); + li.appendChild(a); + return li; + }); + resultsElement.replaceChildren(...newResultNodes); + } + } + + const search = debounce(searchAux, 250); + + function clearResults() { + empty.style.display = 'block'; + resultsElement.replaceChildren(); + } + + searchBox.addEventListener('keyup', ev => { + ev.stopPropagation(); + const searchTerm = ev.target.value; + if (!searchTerm) { + empty.textContent = "Type something to start searching."; + clearResults(); + } else { + search(searchTerm); + } + }); + + window.addEventListener('keyup', ev => { + if (ev.key === 'Escape' && searchDialog.open) { + searchDialog.close(); + } + + if (ev.key === '/' && !searchDialog.open) { + searchDialog.showModal(); + } + }) +} else { + hideSearchBtn(); +} diff --git a/content/fsdocs-theme-set-dark.js b/content/fsdocs-theme-set-dark.js new file mode 100755 index 00000000..b6eeaba3 --- /dev/null +++ b/content/fsdocs-theme-set-dark.js @@ -0,0 +1,5 @@ +const prefersDark = window.matchMedia("@media (prefers-color-scheme: dark)").matches; +let currentTheme = localStorage.getItem('theme') ?? (prefersDark ? 'dark' : 'light'); +if (currentTheme === 'dark') { + window.document.documentElement.setAttribute("data-theme", 'dark'); +} diff --git a/content/fsdocs-theme-toggle.js b/content/fsdocs-theme-toggle.js new file mode 100755 index 00000000..5e32f9e3 --- /dev/null +++ b/content/fsdocs-theme-toggle.js @@ -0,0 +1,38 @@ +import {LitElement, html, css} from 'https://cdn.jsdelivr.net/gh/lit/dist@3/core/lit-core.min.js'; + +const prefersDark = window.matchMedia("@media (prefers-color-scheme: dark)").matches; +let currentTheme = localStorage.getItem('theme') ?? (prefersDark ? 'dark' : 'light'); + +export class ThemeToggle extends LitElement { + static properties = { + _theme: {state: true, type: String}, + }; + + constructor() { + super(); + this._theme = currentTheme; + } + + static styles = css` + :host { + cursor: pointer; + box-sizing: border-box; + transform: translateY(3px); + } + `; + + changeTheme() { + this._theme = this._theme === 'light' ? 'dark' : 'light'; + localStorage.setItem('theme', this._theme); + window.document.documentElement.setAttribute("data-theme", this._theme); + } + + render() { + const icon = this._theme === 'light' ? 'basil:moon-solid' : 'basil:sun-solid'; + return html` + + `; + } +} + +customElements.define('fsdocs-theme-toggle', ThemeToggle); diff --git a/content/fsdocs-theme.css b/content/fsdocs-theme.css new file mode 100755 index 00000000..cd0e6a97 --- /dev/null +++ b/content/fsdocs-theme.css @@ -0,0 +1 @@ +/* Override any variables here */ \ No newline at end of file diff --git a/content/fsdocs-theme.js b/content/fsdocs-theme.js new file mode 100755 index 00000000..eea7d521 --- /dev/null +++ b/content/fsdocs-theme.js @@ -0,0 +1,35 @@ +// Automatically scroll to the active aside menu item. +const mainMenu = document.getElementById('fsdocs-main-menu'); +function scrollToActiveItem(activeItem) { + const halfMainMenuHeight = mainMenu.offsetHeight / 2 + if(activeItem.offsetTop > halfMainMenuHeight){ + mainMenu.scrollTop = (activeItem.offsetTop - halfMainMenuHeight) - (activeItem.offsetHeight / 2); + } +} + +const activeItem = document.querySelector("aside .nav-item.active"); +if (activeItem && mainMenu) { + scrollToActiveItem(activeItem); +} + +function scrollToAndExpandSelectedMember() { + if (location.hash) { + const details = document.querySelector(`tr > td.fsdocs-member-usage:has(a[href='${location.hash}']) ~ td.fsdocs-member-xmldoc > details`); + details?.setAttribute('open', 'true'); + const header = document.querySelector(`a[href='${location.hash}']`); + header?.scrollIntoView({ behavior: 'instant'}); + } +} + +scrollToAndExpandSelectedMember(); +addEventListener('hashchange', scrollToAndExpandSelectedMember); + +if(location.pathname.startsWith('/reference/')) { + // Scroll to API Reference header + const navHeaders = document.querySelectorAll(".nav-header"); + for (const navHeader of navHeaders) { + if (navHeader.textContent && navHeader.textContent.trim() === 'API Reference') { + scrollToActiveItem(navHeader); + } + } +} \ No newline at end of file diff --git a/content/fsdocs-tips.js b/content/fsdocs-tips.js new file mode 100755 index 00000000..787e183f --- /dev/null +++ b/content/fsdocs-tips.js @@ -0,0 +1,59 @@ +let currentTip = null; +let currentTipElement = null; + +function hideTip(evt, name, unique) { + const el = document.getElementById(name); + el.style.display = "none"; + currentTip = null; +} + +function hideUsingEsc(e) { + hideTip(e, currentTipElement, currentTip); +} + +function showTip(evt, name, unique, owner) { + document.onkeydown = hideUsingEsc; + if (currentTip === unique) return; + currentTip = unique; + currentTipElement = name; + + const offset = 20; + let x = evt.clientX; + let y = evt.clientY + offset; + + const el = document.getElementById(name); + el.style.position = "absolute"; + el.style.display = "block"; + el.style.left = `${x}px`; + el.style.top = `${y}px`; + const maxWidth = document.documentElement.clientWidth - x - 16; + el.style.maxWidth = `${maxWidth}px`; + + const rect = el.getBoundingClientRect(); + // Move tooltip if it is out of sight + if(rect.bottom > window.innerHeight) { + y = y - el.clientHeight - offset; + el.style.top = `${y}px`; + } + + if (rect.right > window.innerWidth) { + x = y - el.clientWidth - offset; + el.style.left = `${x}px`; + const maxWidth = document.documentElement.clientWidth - x - 16; + el.style.maxWidth = `${maxWidth}px`; + } +} + +function Clipboard_CopyTo(value) { + const tempInput = document.createElement("input"); + tempInput.value = value; + document.body.appendChild(tempInput); + tempInput.select(); + document.execCommand("copy"); + document.body.removeChild(tempInput); +} + +window.showTip = showTip; +window.hideTip = hideTip; +// Used by API documentation +window.Clipboard_CopyTo = Clipboard_CopyTo; \ No newline at end of file diff --git a/content/img/github-pages-settings.png b/content/img/github-pages-settings.png new file mode 100755 index 0000000000000000000000000000000000000000..a7657705daa724182a7158891b44660fd41f9a39 GIT binary patch literal 33534 zcmeFYcT|(#*Dr_#QE4h7B0_A4f`Ed6)PMyYv!(X=a0z~7I2=j&)#S6eRlag5n7rmtY@#BWnf@n zRek>SB?H4r2m`~hzSF1ZBikx{DEhCH4oVtI3=9=9%w#J@`u}HMKR5DZU|{=s^mB~! z&WpG7!3$o`483%~_FleL9(D{W9(Hzap0B`O=6a{;w*&{PK2_57GvAt~q;QTjV@PBt zYPjrcmT{Z8zWG?sXP6n2?fnd!XkReSbSbT*Ji#>L{JE)YlhX>vZzrRamry+MDzx?~_VSEz!*J*8O;b6dDr@v=hLbCtY-P*dE zALqjV>+U;(`OmOV{{3+6i%CN_2s!_L_?^gZ$Ma;Zzn;HT{eMBe#QZ#&Y~OX3Th=kH zAZ4s2S(@!H@)z}t%y#Ei_HMe~#`-%^f8J;Kjj@YT`)dNvk}Ohg5eAXb%)X}M3t`j1 zg)^QbF+9|H3m{wg-`8m`8N@IFWrp41-fOWcG~YdFQ>OHk-ZMC~#wE$2WA+{`sMC`B z{_AqnLw0!A?@aCm@0u2}I`uWCS8ORXrZQaTFShpM*9Yf1rbqM2b_cCuN{i7AI6VcK z&B0c)bBPk>h0$)YOyMlaLSR3wJS*<5)RX}9)!kk5 z4xhs%+U0vv^37(NlkR^>@=Jit{wr*5NJjBFm2g?&I&9I^yus`A*ZiHbvx0_T`MW1h z&D>M-bzl+7HMY1~^bH^+)I2A!A^-PcwrI_A-^Z%@3)v|8CN(yrLS?rj`GPoOAwR09 zCW!p-HFun|d=xMycpoXg8*_pQr4a*8vazsdG4S3L?e9#axhK`LZl=-P;pF9J@ns5} zkKK)x*||q;*Qq_QBon=qLd0~ynf6@#RkwA^Fs8L;lJbyr(_CuHE}%VZZ^YYUMQwNW zd1FspOt&-2OHslQa+vHoHY2gS3S>_a+J6(yk^&>k!sGs0DDR#9Oi!>YhA!Vw>Fu*w zw&e@J&56**ZiZ_zH#PdF-F~JVGnf%Uyzy7L#~^b!n&2_?Bgf+afr%Z>g>^ZLD|f!V ze$eHtGJ@r>=N4n0wS!&xKmoSf-Ij zzEW2u%TSFYLb8Oz4u9F7j(CwFEA9Il&LLS;Nu!1_4XC*$b!~8SZpAY&N$Xuv(%efpPPYnzo|R?p?;{{;9lf_9a9w*_IgtGPu350^$9 zDm`$P+}J9K-|MA>dIL%jj#+xyK;=Hf_au-y0(2u(q+lekgDPi1kje*j8ZL`3CpMZv ze@Sa3iP+cuK%R@dYO(tJSPYx5S8Oh=Xclz^#6Gr^b*R(F2`mu>3bHFu;+tx_sEMQ@ zcvliJRbgAdG^}EM|Fl0gbgR;UNg)u9>NZjfao8E3KXJ-jAf|;J_mE=OSZ&{8V1)H_ z!@N9526w8*(1*GCzCv7?4`p{LX3_RhANR!JpWNL9=;>g(Dn`fN zjR8MA7Q+p(4ks@Q;FF8Gc!CdfFnX8C-^Yk4zqTb&O)nt3ShdPMiJ+n}t;40p00Lc@ zP0o9I9zz6&#ghJzwZ9iuxSOac$+p3@H=U8U zFC=<*g#gTmg@A+C4!$)Y$cx!-?<(@ab>x0mI{A(!V{~!9FBvHV3 z1_Ehx$@`S~uy=UUfMz>;6oxS{DEhAB=T<&02&m8P;esu~kHtdR|2e@hU1Smr;N7fy z-4QC^cS0QY(121m57?soB6Bee@JOgl|3He(MeF^xpFNWQfUmARVK67Uu|zFgj)*|d z%(#WOhc~WwZ&_&6tUrAU`{bv`CH!sdmGfnR6He({LJajDIZyDerXms?%H5q-gT901 z&dS}ZXJWb{YZ~*mf_cYQ6V1GD+KvAxvYnjtA(^Mv_Mcg{Xg`P`L5ll)t?9neC##_0 zh4PGoUb4%SC~pPi#L+zT^jINNu4Y6*055*EyP-tQVkx(kPkxF~$!Ni@N`R#+0pR`e zVN1?WjsiYK?1@Dk70>2R?5$Zj9@9}b?Qp$HW>UYJVJsGrCxMwvc?DL{>Mg!zK0o47 zb1Q<}j-;O9eS=Vnq|2tDBR~0waS>y^5CHF@ZRjJJsX+tUE%4s&{|qIRVFS4KxB2IS z0oS0$2B7$Pne5AAFV@eRX8xY2wU87}6IAP_5CBH}3m+Np)w4jBpC<$fcv-`XFUt;B zLl=Ke<28x= zhLGo%Z{5Ahml69^K%MA)ktOw-!1;?3Be#>6dei5aI^&od?FRRWq$fd4SF164%*dF0 zGs#aQtqD1DM+9DYn_w48*9UWA*aELo;LO2ir?2R1DPtEjUz0g*P|V3b_j&Pk9H)KT zVz|#?%WicWhOvRC$S;_rxs}e-d0@^o0VG(hH`+fn8v`qy{b_@d?POFiT7q(!d0`hG zV;)<*$eG`n%eOg@DM)|)g>*07vRFX?{o#6$FLIcRh*>E|%9NqSUrw1FHCC+ulRtXnS zk;&qlY3?s`;U>Mh++aRkvq$4cZZ_ZrTy9GGFx%cY2_%LaJgbo)e6zZO{Pr0PXB)+F zhmZU@q3DKye!(>XPG$Et_E?bi{mS_pA`8zMfziyd90pgzOtCsjdJ=?s{3&k#h1SaX zw?Sw}^bOD6Eif?lne1jDKPNjxhG*sTIhXO`_WSBiCbBA*>`aY@D+bL≪zkbrk9J zl3LqEQi2?|()GjB5dNA8rHco95mL4dY(Zh)AAEX8AMc-9;a`3^po$Bd_)6163KRDhCi$|W6x4x zqZg1d^4ITPyqXt$wYhkB>+(sUBDK!)>wxb^X7LM21hRz}R(vyTb)}yBW4q~Vt?Dx87gU$oaD~_63POJG~>LeW2NO~o2fpE z?A~WbMQ(K!If+d=kOckJUaMEkbwGdkyqipXGddXR*k9n=-Ymr*d#kYWOD5Gm_?`6cL_f>dFJ^*a)^PXw+88r~TUU4WE|IHC z*oZE~BJPwyucqrm`%Pqsa~5FA-eBm}Z0Eq|5g2|#(T>S*LdNGFdvM`9sm}PAt#mq> zAN;>>BH0-h+e$<6`HdZ=@uSxLo@?I7m;i(_0{F1mr8m?#G#K_S_w3A{Wxhny(IhQp zJ0vJ)e^6$Yh3_8kh7{K+)(8ljg63?kLs?J6etrNnnbJkAgy!5c*@%2#PkmM<^N)2i z(8=ij`Ke?iE_s?YY?@GBJQ3&4*&V9s7({unm#}EZ1QcPpdr@EaI$;p#?zZgSvFrD0 zsYGXfPNf9n%4}y~?cEAf9@`S}=G6V}Y(W0>U6t%K{!UNKe|*3To7?VGID+VtFjSsF zh;RUDT&lr>ej?3#Vy9pEg z9O<&iRyjvzP|Op#n#jr?#d4g<>`7QYv==q3#cc*asDFD+-%KRA@3oe43rOrOcjCBb zN_6y2Ll%G1&8^ur9dg>e_s!mhp-mWTa-4WF>dTjYLP3f|jnrpvUU9qVd%w3DdrLQB zdS~J?UC#2w-UwVkB;p$Rf2z4|Dn^ zZ_G1Fj+}-(tog)RlkgL!1n}v-liE^jBqNfz^LmAux3X-$;+otbrofvQc(j+9a_g9e zB4b8J@2GwI6u;3^3x;q2b}Xbmu}rcoT4$wHt1s^du@!&_>{DSCz~OaEVy z?>ybj5;I5niQICGkh@3Mbe^Y2I>T6u319{N};@aVoN$0G;tDt{-lYh}}G zJB9Ut3D^ZACLKxUTKH*t`LKS0?+dToTVvYUR4RY@s#Whl&fktkK8ha(e2<9j=I>>@ znBYIFHyY741JB_v6758e?(aXk|LEfpId|lh=tKGcXG4OQ$X7{!Zavf16=6QQns~GH z|87e0R_qOKZRJ0+{QZP(j{h&@AO&t`A#9!9YeTl1@@jc&JpTlBbjAX74^9FDuPkP* z^>-%><#%}kCJ&AnrVBK;fuAt3_eVW-xBJ-PV$y^d{?J|;Jo_*4DfSmYuzS6HMq;kD z#bk9#5H@CaPJVw^)8YPeSyGp>(fz&aM@2^U3~Hc%{!KpwrTJ7Up&`uYau>q=%XSy-AWJ! z({n57nY&Z+;&wZv{3YG+5=3e8-Gp^J=lo_tfu<{WtV`!A=CwLc0>$lAKVN9e1UBi6 zie`!)s0TcURP1|UXSz;QdiU<_X0yFDp9IewMu^w z2zbh{dI~H$Bb1`?!NAq?{^lx?;xSSDp)R=M>vHl1l{ABPAbZOF_n zZrH-}6F+ay02@Ff3JVV!fW!mplssk9Hx&b}0hu;nup;9M0!CioRRWnG6P!Op=JKSzQ8_E}EeYE%Vd=kk^teyV-H;7+CNJREU=tRF!fn*vm?9q(u}Gb{MJ!#8#F)ByB+0C|zv)~X?}!q*2;1cwS2ksxq;C@{_qB4{&uC zxMrm?8KO#?GlE}#AP2#&v9%;@c^-R#k4T9-s}+yZiFb{zSO}z-H(T*cTN-@DDOIl4 zl;rqL41s`*cssl7hsayW{0x&f!mhwB-n-chd|#G8S*9l?vVpE2U@kR9lnz)7f|Ud1 zz9(4M|9z~+?X#{v^vce0IW86{7qr0I*FHaBSRahaz2KiymoO zKg+6CJHZw+c_9jr@sYHp5A7&@8qrde@X{dQ`+oBqtp=cI|2l~4^|$k^wz$Cpbd zyWGlVM-3ZU<)bpq;Z>IDa@2Pw1t**Z+{+yZOb$j&P61b{#CA@+fI)wxc#B;GUc2Xh zKXXu7zB$!l`JHV$`AwIj*vk3hbZ8|<*X8B@n?)dsWU6}=Iz>iHGqM*AR`Cg>93Cy= z?W$?_)UCa5YGCJP7I^8}mbGTB*r?RrNtw}>3ncZIE<7pYzzi|`M_s6`rp_Dx3h!RS z@RzO3uB7MIhXs=D`JxjCd6R}(KC(7JhAuqDd3YpFPSDhCRC2hrx2}!UpbJcN34Gku zvV%4*oCbb`RddC2lWp-1axR0eBL-hCch#oV9>U)Jp?pr90EbP(DRU~KvMjEq&|8xk zg9f3snI=B`NRUVKAFGd|xq$ef{8h=iH5xHk;WAvY1-36|zS4OI!P?b| zx`e|;ZwVSI`|x-J(|3N_Ibg(hw)Ee?9^f_%Wh2$o^FC2-i~v%HZl$Db=f4J`J}cA$ zlCNz0kqoqEc5Nu%4=HBKvnlAX#NVV>KD0K@S*E06y0}ZJvZKDWJ=i}a%>u}s37=>E zH)~C0AvuniD~qmNP#J^yre=zWGyt^50YNi$6}gai$kd0phoSg-mj(bC9aV|mTuylP z@e;b9W1%gK@vN)t7>0|3ysFSUBl??SnY>cwYfah5>SA*bP7H+|r=%Iqz6R{UwXM_n z4?=pD+DD}VCrT|460OWopSLZ+^mx7d<)cSy5=aoY0ohhqNpF)&`ov%=`WSx^di`0QZelf0biVZUzB$@OyhQ zvae+tTH2TcD$Dr9$S0)seZ3g;=ibsK{exO=IaR!({Iwv&vP_&DvNt?SRjM_!_tG+2 zw=`xK9e~L8fML=FcYUm3GOO^7O|W4z`B#L}tz4kZo;tjX*D_^N5`y5gW&6{Sr)m0< zlCcT@CBwKN5SH@jKKr*FQY}I353Y_{?KIuIg8h{YUQW0yRSUSilIJ%hKzcAEMXlyW zi(O<9s*`GtHfbOOoRnx=!Q7s3~3TKeINGrvzqJXh96 zsY3XMH*kIdhIBKK59)Ft|N1uAO4&)+SQi>(zw1QkFMW=Ys-R5u4%Le8bKhy&`V++2 zBXC935HsGA;PP=B$kmru=QEKKh5&tK41!g#w`G;-uI?34`v`r)LWDuo-34yon$O0; z2*M!3ssSMiXCFO9yg*;A@6XS5)}d2_cOS>te)tmwxEh|wL%t(v`5^=*aRm+xZKuYwX=?#gL=$N)$@Tfwp|QQ9Y)!g- z(BVhx(H2;oX|QuSF|D#T-{mvWedXI|vn3+E)?u^1jo9*vXTRwJnm=b%A?*R?Ydp#F zoxg7F6oHy>6{sKz4r+CUO*7fmOs9j*O892chzqT~zTWqA?+m-un0Z~Br+cQ3C9^fF z4mIJ9?oALPlbe)LrVF(F08Kf`**h!TA9nKvj{EzfL385xib;u%i&+SS4LZ?1{K&`* zJ3quoyuQQx2Lo!5PjT3MQo;X=DB5Da%nh8s4^FprtFmnR9uz@Qi^A|Nn!2Q?NeZ;c zdP6zL*`h~HN!{;;9}=OVY?a#47X&n>J2Ou%g~?2;;VAxe81Vw10riVt!eK#?P&P+!2ZhA|@zsefd0RLJ73k6*zd;@{aCkwRG1dOQ{!$ zw?t$GaBE+%yEHZ5{nJR$UCGs*17BiMVIiD709_bfJJ?p!JRxV(HVc0VCtN!qYGOHp zT147L3KV^>6OO$V`xU~zZoO`C2~gX7gaONLJSxr{eHJg$LzknEqUQhOA$rr`@D)a2 z_eYO_-R4)vXB%sbh-6nV7_M_v8K+Z|)s-N)=k(EAn!44vM>5y`)fQGfptrDcLo#3D z9tD_cgexYQ9vjw`H9W~D-Hn%aB3KqQerAr0E{@-6OV-xwed$}VwPoeXx?uZ* zx9Dqc%Mo~uUV0zmXNP#r>2z@_$`H7r9gnzY2i#_NYUn*SulvIvLtuQYNrkOAe|zW& z%235Z{^CNvLJB*OsID-+clSThRzcOc2h9q#V;uzlBUpg&VZ&uEvaPxMmoj|4P4w`z z5>`j!B=EbWuiC5Y0fyiv-s-)Ly=6dX@)OtHrHQgdG#F9y-sSEr+q&HF5m)w7Vgzdy92%;Jc42yi+|qaRGkYSI5m9>Ug(lc7u+Ypd zJcgbX;~IAkL$B-E%L=-dWx{k166)g(O{pku<$kq9+ z;n){xPh+hgvjabz4pTusIp_Bj`H}g7DMK9HN@>@sKQQqIqz;lV?19X7hHCK28*XSG zW>2}LzJ72*>g|BchCeFoqP65-IFa!#(+*px3m8v4<-e?OK=ln{4#GhLd4ksRsfZ)W z47+N8y_K!nvcgk9;wXz5@#!|bqrKUP^n8O0ERFBS4Px}JlHVH?-kObJx?3>tcrWCm z;RmZjtEZzSMgdoNyy}XKA|q;Yo?>+>n zC6u(eLBlT(s0?)>T25Z1Q&xnm*-)Fz_H{<)ROqdxfk6TAwn4*GmuaQKBq@Ts)LWRa zbAl1rgnbh3$8di4XJpS@JG;17r&Z|()kIc>$`F`kJ(aM;2+Tv97-5In4(~R=roEnp zz>cH(W;8Xwn0=F10_IIdPIVQwg8Y;RO$U^71)oYJt%fx zPbr`&5;`Kpa^36I1C`NV!J&TNW6ugdZ&V;V-+d@$Nafgca`8c&FELQj0Q?O`IHGlpw(GMwD@=!DtqTa@2Fs?; zWKqj_`Vq&!f3`iHW8om*dYgq^{X+sDAGr@I%(>ok7w(|zT+ znZ03Nx4MC2pb!hB+GBZaE+(NaSYQ*-I5oWMLeQ}!enEnYG2*qX18PV9l!1YA0tw=* z`_W;>{a)?v&F9BsAJfxny1B8R1nPZh1@MyV!W9=@(w$xRQNI1J6P?__fb6UEVm4g| zXmlU}1LfR5-fjSRRM-bT{r80o1ML6uesn7A47ex%%WsL@qAUC2(20`Dl?6&ADK}`C zUvQchAiKIXs3%_`Tr}9Xt^6PJBgRVsS5I&JO5u9xU47H6L`7C--yJofTLWu}E!@}0 zf9Z`Qj1{amVOz0g-dE~zlc)gpggk#wkAQ-J@v{;^MYOFFUC z8yG0b%4_R?Syl$EKL?1q`yE<=+LYD*?)Hc=&!~%YLO!y*Ow3F=%c)kD` z+23b8EZl3#$QAKl+j_mcY2dMF*f^oEw7%wAkdl+4=O`O^_8$e%JKP0UzG!E^dhh1C z4_Yd5n%Qpg2aj#s!D!w+9)idV4E*5u&+%m4Tl&a@%rul}j)InM{*Q>!v z{CwnF=wTh>G0mi%G10`^B$>QVb1PL+3JKakFug?RyfqxHU%x>G*=k6PIv5m@r{7a{ z(INPnov1hEUNBR9=gLW7#0`4=@R(K*QIa>v`-6gizf48Gi0c|wpe`UEM^hSFSSQ_CyRud$lT_;?mFW8P#Sl75aI5?wl5HiH%w5@`S-l6(6L4#)VCb@05oRT_NF zfn`%QJ8HqOr{~FZ>-pXSQgDvLF9?W(mJ4RI1vE1y(FGUfqxqzq`Q){iYO4hPHJut! z8V9%&cRj@J&6CE?cS~aSb9ao~f3P__C-UnkcX>Mz-oAUX)PUwokN`A3|86!ql{15| zNvfXko#K3IZyw2fZ?uV6{>caReEn52KZjfFyo@EcA01^;(>7(j%p{L|)8v7YYqS{c zDc|A|Gi~qjdt%Hy)t$rwG9FX7ZBxqav@ErGrKS&nKK39&2+}0!-6W$&p@fVlX(Izm zX~SonLrjzheABHBTKzP?E1V|zm$M++qMS+NCGfFidJIrZc`PY9BWmy+A)4M~u`C76 zJC&8pS>?65F!INT=cK>HM(kBRRFOn0da){sX>qx09n*Nw{W;IoW1XityKE_h3*Ti& zUvqY{ZTa4Jx$JL&xUI4+o_A$4M0E|QqGXZ#8OUk+!QdrDc{?*?k%f|r%MVb=)JCg- z^XZ|H(a?cy(okPk;>O&{IF|q&jp$*-Rg`8yEm2eMdh5LMe7ZPC>`Se5-Q;?gDB4}o60rCaIdSc5*yOI z?I9IHZ~A;XTlj5;Hy%`4!>^P*slgsKoAql}h?bMJyePZfb2Y`G69?bhf?;%Hc<<&w zadVU%6luJ|m&}jueRYQ33te+btatLi`EzN)yP{v&NpFFT$1kL3+D}U+dNY~xTM4}j ztq*)Srq)|&?$(6>6!ehPT7l@Ms*k|56n z>Rjdm#-T<6kt0thko^Twu#+gU`PjX@;(}=*C>+PU=cL^_SPq%>yP;RslvJ8R%azxQ zX~FszCX<(*7D5h|xe5Z@rsH%ejvcAG%|!jcLUSUDtH8KI+6=S#D6>$-Tp_uTGl2NC z`L~~#8B`&yut4;i^IAJzw;9`Bp-VZW=oCy+)>3tQjUkWpjL=)`=;(YWrPdr>O2A%( zZppOQJv|ejOwADsg-5A{6GAaxov0gI1p$F$UAnGQkQ;i9Y|uij&Kl&y8K9Yy}Qo&p1=3YUGGR{$R!m6-JsF({`WH5 zlBK(D`;|!0W^xI~E}Cg1Fb0sEi_ff^%jpxDJChnNgGo4S41V}wE}VWaDf-?dtnoa< z4oT3R^8mZv0Sd_bXEQAyto{z+wZxq91anD=_N6FZk=9|aBhY|aT1et|T`Wh_ z=pINPzx&6v0&c}RgfZi{u`d>S{n4;uPGuseH6yOl8qwT~k{9a2KhYT z$=@Dw2so)UXmL=6ep$qAI{U; z7pt=w3A;A#n8Io^@^CwnYs-==7_jobnYTMkATJm;7YXCB9mKP(4Zsycm!?A&yIfFo zga(@M`ID|IU)8;hV{-h#up`)AO~9nR=h92BP|)kP{?5?eh+6OG4uY04cZA#qgAiJ2 zxGgtcq62=xb!%sCB{la8jLr7VUT6;j)O>)8BZQ>0l8Vf_!e!8oxF?ys!GNQKVLFQ5 za=M5Fjr|kc3{N9t0#`k8pJ2*H*1@R-m0dGz_HHFt{6f^hCN@Mz>SUqI!RiPFz(8c{N1!kqBzsL>r2J9PTntHZ)1wuq#ai zq0dm%GXpsEz3&pVjZ;49QY1BdTM=75)HmcZox+cfMIgj_A`f; zfq}T!D~%(88!@QCT8`aGW>T*>B$!D`AZy14S|hZtwE}1FT*Bw{u_4)yjVY_ zBDidpt>wCe)H+tBWZ`GF@B_P(K#$cAa<36=P<%Jk$R5_=xy^i7Luo4$%96Rj2+({P%p%{zW?GM;9>A&u=W!1|KLV(i(= zzT%tZG~Aj3>o>__fquT1{!`}@;i6F7DWiVE-CNWmvz&zRB@xV#UVxhZ*&@E4RU0;ywEfvhfw2 z1%1S6NJAJsSt4E!2IyKaB4Z9mO6m3r477u8{!i0dTrC%H{w%^pq^D9s(8^$#r!ed8 zkWg5+FhX{&8EQH@Ev0*Ey1^8GxS((BGXo4N_&q0J7FAOyZ_vX}*omCW4?K#vxKBg0 zf|5*kbhv|Ie*Y1vWu1kP2RfP!9^I0;huT(uFNc>byU*g}7%NNl`A+uAYyOi@kvH-? z(Ac#YeiTxAS!Aq#@?OU@ zRu}GABl{=BJvLjHc5~^{iGegeiRP6T5$K;htS4f}JW8%mhh{euM{~oMC`sbB^JrxG z9fGu|06GS>QH9&M;&0ZwGJZy)FXF%!{~>3$xiJ|<67H~@-H`C0a2lW%z1v_7Sf$^! zX1)Fkn!EXZ)}HwO|_ zi7SI9v7L`b6?Q$b8(8%AD7LAR+l9}j>=ZQ%ImE*Q)=Y}G8#G&dLtEsXzucSR`()yd z9r9Q9DJhOKp_+%wv@RucJKI^%F$Y+gT=I{?k9s9@Dqz6$LDy>)IwJpsjQl#YEApj~lk7!Dig}41wLOlKZwAG$QcS?@ zcYU*syY$D*Ixk!G&X*fvJq`7Rzo)bZ$-I)jwqZ}E0~=QcWH`vCvNk1~PLsEz!khfp zC(T8x3@}NfxgB{m1?CXrdxX?{0E4{tGNRc)vgkMP0c}VqynFvZlpX!M&ZBe~47!)g z{FidlnR^=GeIz4u*!d}u{Z1IDBb*-aE>s?_0Z_AM1s%=CR5!1vduUEmJ31VESZ)?d z)jXWt7dC_fHAeYEU_q>6kYBH>)c1-^nW;ya$h!CT(3st1uMAlm^+uAQSC-ItWif6L zDeSO3*0!A`R2Gif4xsaY)ImO~I|R+H4e{i9>k3 zB@rKDr3Adw?jw4Oc~;Zk?e|N^%Cd$+N0Maf9)YsEit7@ynLJrf!ly6ROCO*-K|sNN zibwKrU)Bu`OtW1_X%?IdBb-aqL`51Q`^(29(eMoRl(Z95+1*>=S+o808V!i^qb5z|%iDoreDEJ|W^B`5mF|)6Zt;*6aG|B5)Q3nmz=o+JV zu)%6|Ot0a;94*XkR09d>=o0;kpLgG#TZG0PR$-C^wh=niB>>I0pq><7iH(DG>%?fp ztt|H@PKa+OckpH20m=KryfS30^0%))3x<8p<*_?OUym))8vzvM4_Iq@t6SEA-d zMA`FRs1lT^dky7jU?thLou~NX#TGC{?qeyZAx$P(!PGOvKlSV(71gagS(^J@7E~Nl zJ5;-)#-oP#fum3Z9K_Bs;7M2QeZ*}>Qye`Bmm}<2X z)PtGT+Qf@Pq4<0~4EO^aUNFO|qo@Ctkzuu$4q;OMM@vE6np@L%nC%rVUY(lWi|z5V zLu9~PyY1Lsh_=1UktX!YJlJT|3?ir)9nQFu&MF$%u7Df2Ir10Q=JWbsN+t_s{HZH}5=d1P>hkx}M4XIpi3os)8d}%~Tw?OH5 zI-sT|ney!0ZH@3~8M;trRFnck6a@&f+|h?Y$pLOLe-51e4aj~QnTcdy)JgG)1!asQe9UJoM_xtMLRkkzOLyhEs^`trGXu)e3q4Q=(4|T@Y``>=g*sZhg8|@ zmTQ=Mkmt7*NTt|x3B@sba$(c5H#Kq&Ql4YpQPyyW4oX*Z-F$HoXnFc^_UiftGo{$` z%-28p-MPpzbWCM8GO>7vT%J21Ccdn9pZtO8qOrZ7_MGH*e}tdqx#3Y^%x-}D0+ z!FZ9;jsHd1m5FznJ97eO6{nzEfvKn-KZF{6BZISvPC*l#vOZsz@Z?JoSnf|@RMYPy z=aqH-F`(W9QRwdw__Uom>=mL}{e-P-q;!{YiNwyziL2IgZzh@cXVgsf~wWUn(CXedu)fC@kd0`IB8LH^~FM%tI zyuM7o>rYfd=3P?1(=hX`{iyi1nu@vnBcSes5e>MpkJtFIEFD=MTl@+9r7Ds=Dp(k= zI36a7m>syLv#ry*ohpoY-MX0ZrZPt%fYz3`Yxyqw+fsjjcStR(O@84aWj`Z8>e1O58vyTFAiJ7yU5=TpY@Ymts-S5Ck2X}T=3b9 z`$CuvWsp872 z<2nt?O(1RhpCp^aKID}ozysRAsvce+=7Cl1O|?qz0e-9JTG{WAcdF?di&X!5M6$MD zYJhpyPGu`Q?>WM;r#Cw9=Y&GOY507=qAV1Ife3KC-2ElK!>!+3OR07ni(G0_oy?-( zcstgOr3t$-6m!u`Z2mIkg_9Fs+{(JsV&1H1rH%?2GVo<=%^No+%mVScyclX$(Q@xH zdDYcS`H?lA8!SfxXRYP_DklgVAjxA~r+clhYu}ln-M&^y)9=79{6fg@EKRPx+&jg9 z<6r5wxNqQiRbe#QUkqe6=|mxyPbdV)Cj9}Uve=-4jt-z3gu6e14C;;7WRv?6E7zR{`a>W`Q+PvL8q4 z`la%-c)Y0C>yFY~oAyXofZ?S!Bgk#3s|rqYPL11Ep+rF!3(^h^@AHekO& zU!PC+ge%q)6jbH7BHIAMaq2p=7f@wx745%Sabeq`K2v&JNYbFM zGXXLhQFZ3>X30~Icy?d5;B2h^O&arqS*f#&-Xu0l`*OoC-O2 znUf8o3tPnqpt*KpZ>$d8dHo^qaOqV2h66ATFoOf_rt>2b1Yl5Ydj)XhSHw}{OQKdAx(wbQWWxaM&B%bt&HnjDD%ZwqL^L-IPh`Ea6 z4B4X6p3BA3j$;PY*XXf4QQpbbt?aVwLG&{)%%k45Ab(_Ub(`V&Y}ja$5B_2>?1rYR zzvNkym-x;9lB@N?d8k=N&c0_ zdr{67R*RB;u0_`5k4u&dFqtFL#wu!$Qw(NW$U$9Nxv0qL%3)WW zuPNTQ)`v{s@;D#>x=LsmnlQqcP+ULaj7Jm&xTW@FR4LjI_s|_G^#$Fz3X76S;*~h~ z-V#b&Z6o_lV& z+9hozn6u>5T!%##E5sh*-b8Kv^1DO5uA&$9T33&xAxvV9Lo0p zAJ$zWin>)os9QC%7TK4nBuPxll5CMZgA}sNOt%)dC9;PYAv1xkdSqZA-lm? zXU440HM)P_=kq&$fBc@~c)rK)kLP&&<(N6oxz6jl-sgF~m)Glc&VPp)+W+duPdWQ! zEEPe6D_53%fW2YVHgc=lb7(m!C3c{nZBtzuHftY1d*nNRbHdF9zD}y~zJI}##p;~2 zLQVH{*|%bv z+4%xrQYB<%DywP>$6BwvUq#E~^+o2oz2BZAP*R3nD0)k^f)2MToD1%T+v5JjgcQwY z%vv61zPs(#s;;%&!>ct|IKP-5f0LFe182LNfrYhv@0BkuZgDPp$ z4cO7QHyW&5U3Id}&LG(#1>v|J)l{(@w9(&hxDgGKig)~;d0HpPLVhdKCz3R(e;&C* z{lcN<3yka9TRxcpVlcf(;3WV{Vb-DTK7+ShmV)EBh+Wwe_S>e)iXr`bw9{!Sl5Ljg)TS z@(U5?%n(*q=@HlDj{$kQXSupX^N)KCHfAJHfCKr@d)69N#gO`nRmEAT)q^|z1$oev0y7ItY_ z0OgCDB;aP9fL7UvQ~&K<^qC8)I~2Sxpb!B31?R=>Y*!+(o@&vw5bW^xjN-d3x{PB0 zS1T@sz1l~-qPGYjZZvRQw9Z?{e*qEgt#M{p{xI37r9&UF(IHE6?;mzTjBy{-8C-nQ zWvRu7aM&^ubc_%DQvayoc78w6SkDl|fod^~xYxXVS(-Gz;w4>{GigM;A0O}w!0`l} zFDdY0EHUX#I}w*Tjy%nFSv$K(0Os|Y2%9|3aB^aI2$wqNgpney7hrA6s= zH@|6*0{xZ_?Fu*CkO4GSFePPzJ^-S6s%F8)gE<)r@XgJb$LFJ#Aiu{!QnO}S9Az@WakzA#EcpfjH_X~u zzW@}5U+QkchiJeprT)GpOFdfsyKm|4P2Ouy7}5TpnuC5pRGv&e*y-ezKGX40witYj zJBU+dc%SX!ysb<2LU3*LR}rVRfpeVoWo#FO?d0JnKa!03);-9`U9?4iRSmL}u`YH3 z)KxO8>YU;Mni{Kmwy(_DXreTc0nbMLC9W{ce2}96r&?$(=e|yxYC)x3>tXRsiYa{ z?KR?y%h=alux&*0w9T|HY&>RDQ1ZtmeMM`blX4KI zRzvta&R+RznRfTZ*53K5IUzOd0o2zc8q9@|;LC@Qv;^^0Ua*nb$dn`n`yV&eGuf#( zzC&P{^XHc2ng(7{NJyLZNw78Ahk05*IseHds2IBf$P6(dj$1z4Ax3bgPKeb7X43LK z{kw4gk8t02%$X0?Gctgh*^=77FPhOyTVKkh+Zsmb^m-GNjf85u)-{^t;oU@o7g)k2 z@>t0;raXK#*ifj@b9>7P2zl@NPY$N}C#J80wkI}U$VN5f{r)MO7}<N1jL7F0har-ps zOPM!GFET?_=53nkc0=9eiE6gnEB6_$p=|>jA~4eMSJ7uTR1Igdx&3%N0UeW&pxUku z5F1?I#gw!5YaHs83Na5n*(08sQ`lm~ZS=ebeiRUeOP>EdDy~3Wa`f;2fz%>rWghwR zLmXS@Jjo?GN48jl3s~bhrMSCBwe8af)Q^nkTb8i*$8#j#oXI1W4cP1GoPkiv2Fht7=cjLV7?I^ii%i zzV2qqPe2o)?J3VCrQ>53dt2k;CJW{zfjTRwYpYhYngIN=UlF%tQ!l`Kg6{>@NMRgG zECjeM(yfr*yDOtV>LR8w z_+T>0C-l}(*tloJeFq&pS}DnM*zu!-aEjA#OhS4s-^z{0ZY`KYsZJp+2Cs25V~YJD z*;SJT{o5pu809D3NgBd1Q2Zlc@fv&`#g4*n1<0Z~l|NSZ;m>TK&Yx&;@;uVL;HKIOB}WHuObErh93k z6(N6w;idD&{@r~IgE)*waZJ6Nhj+8K%8&_l3M1L*+7n|Qs8^m4FS6u1e_kiO-$J6) zvFR5>0eEioU1p~Bbs(KzVUrRgDc9CfE@1Z4fFQzrTI^|5yd#8##g>ka$l}pH@oKdX zU1-}H@2EHdc=rY>VZFA*B{A5l&p!>`oUXp}{x8*u6KS?OX622r58gkfee6L2m_>-Pkp89N-fNT0B*l5hIew)lFo;BL?6{QwoDK-$l` zM+N(>o03GBmr#kvx=KRz%TxOrn&q41gKz1mrUV5>|6JhtHKB1PM%|kjV}XOX?QLB0 zxv+U&jA_vTSNdlYUz!OpW4!d~X(mdW{Pa7`)&sJRqty3+{>se8-+=ziluWuxIMR>B zeEwCt?&i4?_6hTOH^19f%rybAH54g_-KVsiV%T605I%uAyqLnnlw}OrBeUOv@uIth zd{4)?nT#1M%NRrcN%%3UX>@(zF=r{Hbw7Bo?^|ASN9bt+U;3ET_!6++{g~gKl*?U+ zr@UW|+f;kR-onnxiCu8X>n1EA=YkB@a?NIXj5$J#v7is;bH%gC$CxexV-gt?`@v5n zR!FyZ0alD$%c*03mC1J$J_dE|C(C8Lh0y}Kcs_gv1cOxWypguon|@SmK0Q%+Gj_CF zW&syp^|{yjeXNGdYaz|gJm)2u`*7)JP*TFm$VkuPLF@7ERC`Lm;e|5*i*~-^?_8Jm zJ&gMYIwTT>pc7%Yn!)$HCT^9!UonBHng2*&RsC|SEmuY7?LCiopSErYZS!8sMcbPA zs|E5|pKr&g?Uvc3xG<6W@nh$TM5X{NW*=rvcUf=vBb{3f)LHm?&?jm^x6W2wAwxNu zD}JF7SJV5}_!hFy4D@XOt)J?f^toB5!$QQNcM)75?3!TvA2B~8L;S8fJR2|H4>tTP_$0wmj<%ST zA1u@JOO%|50e`jdfK_>s3U*{SFV&ejZ0 zz@p$u2Lx{J2ls6D7$hY2uJrXL8SClRhff;Cl@vhuZlZm+D(>t7RwwuHuucz&r;YFOSblhVClwaLPqV>juU7oeSb(Nme4e2_riaip5sNMUQs5EmS!kxr( z3tEss_)$9vl5g4v43hYJ{{s=aB6J`FU}^m|xiqvke2##=&-q!$-tlGJU68Qu8poF> zq>BmjftHf@gZs}n&hcX3s`+1Kf(DF+zZ(;alRs9Q&!r>xA#P+kMI4_%uYjLitN#<2w1x>?S zPJ$9U9nR)TSApZo=b9HNCEZ(z)^v>`0BIA&UZj;+NL0bU>yc8w)(pAkS~!xBInrn4 z^-bCpEf2tF05D}5a$5TQz;Q!N81!Dgv~J7o^v_4+55a%Zz>QaXg5E3ik?`4cMN$;k ziQMu6ssOi@Li@`gUvmK|7_)aW5`mpa!k-ICutRZO?;eHAJG{16H9M|WEJBL8{IO}$ z=U7|z}v%WrCR39XoN0F9$S?qY>_-^MEWhGCcJ2c57=7q zBB)DQ=q*`@GiCXRZ^c<90bW^c<-y&JIa~=R7%yO)r>Ip1HBt{=NV9Iw$BgghBm#lQ z@O-?{qBRc49o`5Q&gMq_4cx;1DXNn3+C%A8-5jO$AMU`X*?e5z$sYxJfkY3d;>4+w z3y%g>n%xg^-B7(Zz^r>4swd7Yl>(&-iz~GG2H#RoW`7Lk_O$)&b^RZ9CV?yeAHL${ zdhI}5y4XXPnTl4G2ie6=8ehlXNCuwb4rEK8YjLr=B7WM-VlvS~>fg|1Z>j(}#GhqQ zj10HUWimH=G^_a=%C6=cIHtkr(5fYOY6U#Mps{D ziL=V^JmTP9ao0YsC{r+Je;V2YbJ&FYPS>~_YubJ2Db)vGZ=|6M&BvN}3ZF1eifQ>3 z#-w4a0wq0CVG{GW6Kbm!m86+>-#xzx!T007j$L1@*z~d0b9kM$Q(nDkFZ(Ec@Od@B z25ZjZ`0t_$HT2z5z%0uwEnqF;ImKm$By097$h*Y|lvmZWokpMD#*QjUbQBL`6jG0e zUW^^83`_v12X`FC3nmnFXlZg8pO@V*3Ut&`GXs-XKI3UyR*-o{!fZq%&p@3}GIk*_ z6F{VMAKi1nEE|4(mAI2@kQPdOE99A?4Lf@qT3xRuUjvJ+4|i{EOx_26l6U@D(e-;E z>cNJ;)ZYwPl%y226}S*8e~TSm=H~Aj3XA3h0I#BDSuUi#SJMV|uXz-0b`D@1;yc`ikSDq-dEFNtqaBgonUvSx8*d+ojJ~U{a(fC2cWmL^59A6NV?=oe}mo$ z2VL5c(b~1^+Y^>5ElTS#NEuT1mJHcZ$&~Nu!js$S;&WdG^tehda zvMsq~{6Iua+)}|u40b|zi_N{cEi3M9%12@Kea*J0u#n4US=x%3^UAkbbuGHo&BrVh5waYwtKC2wW}VjP`Ko%oL)m)8uE?*d-~P7{>tG#%Urw$L&Jro{ia z-v73NpE&@rYpdGX@!ZHg(&qZ(n1Q9eA|hxrbK_@5=Zh)OMB)y(`L3HU^Dn)!63l$M zr#m+DBqgicip<&iXb?#iw7kI19;2$fPA-gvZhTE{V2QZem~^ZOcoA^}Gl+?1yTHsI zsR?T?lJ0*z%n!KM-bm_9Q9LK&V8e#?jwkd*6MIg5lsTtega}L5t)lx~FvDr@EGApy zAdZ1kJ$r1_w$19{t)c!yJq4osz#xsGui4TQ^3w=S3!fdr-`$T@N?3Yn2x^(ij%#B} zrhDGw3DXS?8Ti>Zl97)Y&yppXmjE!72<3Wh9YLtD1t>u$o0A}TYq8Jhny+|DnOCHu zt>S!RwNO{zq~+jAdo0$L0Zh7V6nE`Zd8$a$QX;K3-e=E!i>z86D4lvGC*U3eS$kq< zMc9PZQ${nZNEpnwU1)3Cw5x^5i}7_#@f&&jwM3#Eh<5Rc;a@z#p|I_}M+%;;4Jg%$ zP;gN)6xZb4oy{(U`+i?5@q!sCI7RD&$?K@2^{-5zVUnA{W(JrX%MpL6mRBW1+Jl1Sz!%gxF(LH&L9|&_~jN zSZjCAF|?K*S~spT9WXjSHqOpcXkwh(QFaq+o2A=$jrvUJ-J9J9K8yNPRF#9%@xO6B zpehk&bqtm?02CmMY|QdiHz{#I3a8@YH~`dj0i!e6z)KPlgnyTM>l$P)iKMVI zEHZo(3ed=lo5Dj=UiIr!`-6#(HfI9pTE_Hma%upU(S^`5?e9%g4_;ai=wBMM%5$*W ziCRRJ(pe_T?q+vO8$#M43+|n81GowVq~g*z4$uExmg@UgM>ud|Uu7FyWJr z`Xg#04wB)MpZh>AqrR;Vwbx8 z^ejya?UVlH1+uMb*-Y84uKF}Th&kCABT9%(ZW?^V^xaYoXBMZfvukGegA<2?t-mZM z)1`~4t8zzEPQInvMtq}sVIs)Q*h!?zkK`w_Wy&vxTN@_i1cP=4M!(e!${%NXbCScz zQ6;nS8ok#@q3Zmp`+G(dKrQ|xKUAsq(raHq1|T52?@C|2v$gWsCDBdfMc7=b(95b0 zMN8mqrwd-_|NGWqyK7`Vls(U{@c0XdFP^^nv?N7rH9|_;yUQ*%8PGlAhvj@~#~v$< zL7z>Lv^ByX2P>%TNs%5?h|Pz5@7+q%Sn1o2xYd|D3G#qk;x1nvyK|s?AGlS~++a2y zj6{<&<6-z0KsuW}MQuFFv>;n4bHu>vZ~a${Q|yJoCk`xm1-m?{@OiVjwPNif7Abdx zS<|9xZkoaTSW#%I=(IN73$B!kKzA`4%T=xSz{q2fRep`E_8JwOFrq=6z96STJFxG{ zE9votQ*KW;hU6vRja-ls&^ieYi{!f)D|8F+N1onGth;|*dEgegBOq1UGbC&<%NJ*Z zc8Hrv*0dp!Xi#~TERu-m!JQs%?TNcTe>7>0Yw>CyXJ4`whtS%Da8;Frqs(_D?ytYe zNaU8dtAke~&IL}Ws^g4xbekIHT834T(IR#PRnsL6hPAk2Y8Tx`UsXMAXWvv$+()=$ z2tB&~*L)~i7>M%9V^@H^>RX6(qCjZW~0%(2L)>jDE`d zy~GR%dzGJ|UEJ)w-{O$(>E3Z+5G}(i^{2fG?IM)&N9IqJCb+Sw1V7&HfhITb{5@aq ztmTph_SZigxh=Lu4f?j6oMGxwwG^Z}b6hh0=mB_^N*hAacV+b48#<-P{{@mV>{=DV zYVN}(n1%}D$_Lf_n}u#9wDtmJpc-N`h;biSTRMFYy-1}sS=RHo4XJCzpBTCqTFdM? zHsE647y`3Uw65I=)#!ao*JyTUE<6@4OVnXg82&3U0aYc&WxW6cTx7q?su)^mN-0BqiR1-W26xV<+F>SdW1o}{UqaOq;Ag;p!%u*dSYT<}?w!!5LFUC*|JJFRhUf1J=L6UUf0 zD}ia|-Juh@&KSQ%+iIp$duo|uXE@TPRT;K3eXVyU5(V%C6(iB3Yn^W%qE;iRkrE&n zUW{u~Tt~zeID6t-k^k@V^e#^nU@a8>s|5PnxB7cBLhiR9=np(MPqo{i*kbMOX6JOD zs#l>;S*`T@%4Q)TU5DjH6=MH|&2&NL*e$ZSalnGz(R^1iEA`-%Tnqyu>&F^!$;rd(H1i?1S<-&9G9%%{=51age^_RE=2pkM6hJzrR-l zQR&~LeHb}gs>m&%hPlfr}gsj2cm18Q|=+Ty_OM^lw z>xWh-mc0YG;T8H&%c?56Hy%g6cNR)Ej4RVp`HHvTjlmv2`e0O0boRqZSG<75Z`b8nxIt3$tDcXK2!_L4phG&4diu@UcO zB3ypHZ1%Ug$CzzzYt8=GbL3MFu_%Ij16r1ah_?OvIkABzSRS5(+@Q&%W6v@mf!UIp zdC-38RIxXpd%R_Q)#`-xEr24l1=sS6y)>F?KSfu+e-*MHY`k)(#LU@xB=H`Q0}=f= zZp^yho7u7mJd=J5IWiM=V^D9re96;H-x*i^>YCwW& z35`!}-q#9w4Co60AokOMcuAEmFStk1fAr;XPlXMqg)(4UN*Ll$i;G!*@chH|HL8O7 zD!V4HM)2%?VKQX8!-o|}Rzd5IqUGG;Y- zN_X%&A>Tu*D;uYv@xB1;;CDe(O3UPKlBauqI}wm;#u#ZP+Dm%L*(YLmde}2$Z&( z5l8jKHanld9#Q*Nyue~Jug^l>i;ya+?v)m_y`YU1d~T$dLua$*6Y`kI_JY2dxG9_ z>bIzI&bXnUew(achcp;I7wkjAdZdrXkn4C_iK*M}-?pACss4iH8#G9U1dpx+>}lj2 zxP()IQqHts>>ZCmk;gc(rtqP^ieRz^QZkavMEVI->2k8&dWpRsvH+y_PbCo2e0rJ zGGiqsOlGU=1}g)^Ccau5(5ZACO^os&&6Gl(X)V(^eIN}Tj2l9=iKsa`i>*G#`%a(I zkX9>S+N&WvuwMhBmMOhZQzTNqRh9JR8KC2+-k@I6(kO3No-;Sk4kS6eb$AUf(>Y-B zQW1`&gU&1YMbT9?NBJE|fyDv*;m8LLaH1$F)z9W!)A=DGjI!a~{h(-viqxbrVtDWu z`Zx0Q!7kRf+KcyzGrFonrynO9oZ&ainXBVDCqujFJ(fKcvY^0@ZfIKCo~}R#^mWSi)_rbnLJ??zQfeaj3IHr8*udGSHF;M zv~Np%+!(h%G>+gl5vZ}JSTbvD4$vsutY^l){=zP$+*MwF!a#T5(+@}xc?{a;^UcM!A3CrZB^{;{ z;=sOAy937fNdBaMVM9uL9l?58(&(c(oq~`P2~CN-YUDFT1AZvVCr zP1BBnEQh8@duX0}R&;?DNm!bN+;vz>9It6Ni`^@>sTlIBtOL2wq1ib*L#@3U|e^0jD`h$L8CI_hEE_6LOTr4NLSL-+49MM6lESEhuWZg zo%-|Fb9&N{2OK-tQnnFam?{*`Kk3%Mi5<+H9o*xmp;cqH-kj*81dOHQ`0Q9Yqn#Od z2t#O^Ee^PaaA%OL3JG3y^>;3eB10rZh2Z_1!1Hi03GG&kSIE7M*mIe~bwG|qA?;ix zm*v=zuQ(V>o3&hC+=24X=fku@nGZ%Y&Y2fcyr!6b9FW>Lg2*?r5D8Rs{ zDz^TH%Lf1HME{CJYLsbo`(kXV-ad_A7(c<47X~_0JmpVj9bqn@>jLrYeo)RR^f8p* zVP{j2KESkTlAKWa>ntU8hV3?g1nea5=j>X)9hveVb%n_I`8#)aHZhFYeMZKY6h)aJmZf-FCABO#7&5yePiD{+J)%sem#e&dKO=7bswz=||4 z#{|f)!NgY#UL89GZ=x&)E^hNP9H`Y$_lBNyEI|cbiBS@qFvV2(ttF}{pG6aLphs)* zuX`K-W8K4DV&3XF1x8e+fqu|=1~X+{-@8~yF|T#6h)uNCAwDO2o2-i@oWTpR5bn)8 zalRf_d{Yh#XVBj_KP1X-!u=j(<;)$~4=!5F-Ak{VJoC9M&X#&LyoKM^bAkG~g#YII zlP-XGeFGlbCSs0-9E5HBDl@9f3ejuYRvZ%2c!PaZ2Upaf8E^Y$kF>;(qf{`)RmxFY zAA1QKM;m{2I`s7yplFe=tkcE8zzPD%uyeamrsEmMd!xM$-|xJ_f0WbY{{9w-dZ<>i zCo;%Cl#bVaABW+LPOU%hU*))g6>GiKni3{~p7bWet(sRaj(z;({#U}bWYRr8wYW+3 zpI_#+3=g4bQOKF9=n6()WuM6k{t8bnc77#fA>b|x?}GlDMZHFrDAFIs_tdKOfnTo} zF}y2i7ck?clc15*Xm(@qzUeRcvWU*HLp&F_{_54$=a+Ol`#@(Z6JJj9Xlk$h0!~$%nlKKRzHtWf<1QaAAKGqq^H=xQQl3m;c%B34g=f&6`IN%WlKMnoFcUVbJ+0CC8w!{EvrXqm3}*Jz~jVM7jaKD?I}DOm2jjzD-W5?-$+>EMi`#u~R7?l;_W8Dj$230CP#Fvd|pBX7}&Y9b{=f-w8 zQug+N1)l3Y;3LeiVPT~Ang!FU_*Bz+s)S&r^Hf5P1EcpyKZsZ<^0c~Jmi8F>Pk8Rv zzHLQ^9}gLA#N)Aq^1i)6Ffq_v5zG+Ud1XnpfKoZ~tP;91H?4f88QH)B)54POqs1M7 z>e0L?=cHk`JCR6CgqoEF-Ko%DCu?oP-qLj)g8Ne5x`YLul_PcH1W z83oV#(5=dhM$R?s{d~0Tu)$E?kraJ(#YeJR(1eL# z{E%Mwm?O=)SwXVm9sa#{#T{LmxiiMD_Qpenq{``XYUlaGd0$38xi&Y>%Dn^3M6z4M z4%M!>;o{x0x{q)O!YNL*QP!|am6i)8Ghm4>W?8J2x3u@|`toiW?Nr_;hED#(H_%5K z$Qd@E%{{#-%bhzw)iRo5ZtX+A_xwQ~{v_;r(>(vHW%fii80EtjL#ACt&c9p>{Yo)5 zTzO*Yohx4iGa^$11JAyY#;3wL?yG!V`f<>>80a#+Z#!-gP>S9?-VRFLNf5(q4J|Nh_UE+#Fmw1@7}dXLEk-M8u!~HFRKhj<4?=OZG)3I-1#(6| zy*hyJ->Uh!aAY(cy zONf9K(9dW#xt@7^L0aN?w@lsT&snAAm{d-N$o`-|N+1FP-O3$Vx|bSl`RybI86t$O zu96eXU{Hj6t?}l(b)Iz19TNT|bC@8Nq-&!AVn!}XitfKA`mQdx7~F=J^)5oY2iaaQ zy~Hsn5~-M664r%qJf-{Hf`b zL8z;2sp?i)eimpq%yx!J&u@pCPdtM&o{mydfwMnZ%IjJ`HU;skDI!F4`&g<&IX32t z`x*3`h7M`3Hg=i)eG|>djBC^j%nFx-L*6HV@$E$%t|Y6Mcq$Vcmwm!!%Yz z)V3U&i?>Qcn#kmWRrFD_%Mm^{<~rf>-w_(AHbm3Kmhbm{tEKW$OxEdz-a-V6{e9sPa013|=Ip z2oj?QOeMA@kVue6V-n3mW?_GVG(~b<8xva=@|51W*F#N!zy?b+MPDhyX1ub^cN#J( zdlB@92O2^fQzB+*x|KslQoGQ6(~XIY(%IK5>Y&nzno79UI6ON)j{XhM(C$Wuz@)8< zk(pn#^UWSWIg4nwWFiVcceGaD?UpEl$)Dc|R)>-23g#rsFxZ}>&2|XMrWTLcW39gpZ@*R(%Y0 z+cUUvl(n+`Cb?cZge7(mh!XjtrkIJySMO*Ww~+LKCFr6)!%ZKK|C8lP*^AJTr|aRd z>n%eGr1Zg*t0YNsZ#Fa%=Hq+;It7TAZn<+a-1)RU0cTh(`ZwZ`-Pe{|;me$_8GEcc zLg&7y!2dk4K3`x602MMIS4`-H&L#u=P%MqL?BcD{2`#ybGyy~pR*XJU4LH6AWWLJ49oXA^ z{GYWZZ!iwqA2ob2SQqI02>Q(mA_dlK2TeVha^IR0Ftts2@nBerg{hYt@Qs#4`8fis z_O2fG-MPr;dJp0wFCGy?eu0@2eLPS$+Mai4-qlk3z0^l6$Md-u1#F5x3c50s$ zmh+G`e-t?4BAjuxrc3~#^n$IvV!8Q`8?sWm!@+i5&EPz!O`1`q5o9B%3|O(0YDoN&X# zJ0L&y9{5m~VMi#t>-tT=fJU=MA`^oCI2LJkN+lIl5SjV&nE5)L&PvxCS9Fwzg)bs+ zx!$OSTqN(199`(8>}V*mpF~2%%?&xCGJrElFn92ZqrU8#bSZ~tjb|A}O=!CF%4R+L zf}mNq#*p>j9(uoiZCbCaTm?>C&K%@>m6D-`Ds7=GPF0pX7TB_RKe1m7R_?l7&;SN> zQ6AENZktB3ddUa^BGPpq&UC9fv2x`krYr~keL^bTCeE+XvPC+dqC=P)ac?8PIOwDI zQ40pqw9mg~V%p$hAj*;;vXs+U7stLqW~-J4x2ibdB;I)Zz9NYUmb{9p|`OePK8*WzPFnF0KumqT= z*}1_3cFqzRo`k>w+&05>ooa-6pB35>cO2S#&#|60sGwO1c3sB3(zmYM?p=0AIDYdm zaVFlBqXnC7n^q`bQSv}zquTTJWEZM$4p{`J+0b&fPk-2f5%htadXK}0TVtHsvH7PO zcCx&{$7n4E`3q^HM)*Z@Zvl>3%iqRiNP+Ih(cm8n1Bzv77fB!Vec|_V#_}9H=N=7p z`Px>noe=FqZ5tCf2Vn$!eYl7vS2>YB>Tap?knze!6hkavXzw%wju4U?k=&wZ21;|EK51SO+4wrhX~i$#uynQX&SEF6oXhAuXP7uS29 z1ricSQ(uN0Rgrr!2e*U&$$XZI@!b(nw2r2}7>f{@eoe~8Q395|-rutg7)77aH+q%g zy8vD7FjZ=k&X-$qL~u-~u%*T`ec$`BORiK)jW-xFjd5k;i5N+_HjLAX1NK+8w#$kr zaQ0lF6#Eid+8OroEL{uT?94zWKkF?ETGP5ofi|F`%P>x3(^O=Z(GMl6RTZk510emk zGyu!vNisn`I}4#G-S0RMa%@55GUw%CLg#h>(mnkAX8_f)!3B!|5L1J-#0Gk{cz5!i z_VV$|gCi|Mi0duA0)Kq%p6B1g^IV^cjC<~HsY<(OZEdj_cu+*2hIw|F{#0Ucc-J}+ z#e#&mj;Q`C#wI4(^WrY)>4W zT|H&*?05FuVRL;dd&gW%S6J6u+0n&SBh=T?I8@KXA=KSL>ggSMIWn1GY489KNB_rc z!5+^%{iK6s@BH^%Y4CU4e+%7V`|l(E?y`3*bPd>)y?hntQ9B_$;!d|&APeF5+Z0lyGW|Hr`so_=?6 zkNDp+R2=;rd|kc$UA;WnaL;`F#4EsG_Rbw4+#o{#XB6p^I4u!9875;F&Eh19#ap7W&5xF*dW1cZb?+>-c{gcJ^#jVi#j!C_< ztAkrvt2Jk18gqGhY5Au+s(90J>?6K7U-*5kKSc50*A|9=aO^d2Y z`9n&NAB5t8ZJ`&R4Ak!JgpI)Tklel6vP0(uFZG_~^NIcMr(H8pab7h3r5Nh&WFYHA z+r81q6bRT+mnQ9sGv`meqvgB#sYllI*EAtuh7ab3VRv59~(Rz;(o$8}^`!%s&RaeLqW@qwFoP{JjPV>rlwM^$9 zfyu=afq`zd-Tq-JJ5O>s+hikJ@QCzX&Hx?EzOBICpKW)%2O30HmMIqC3|9i~ZbbFa_!-TA}Ex2BtCAg?ciOuXn2Vg(%uV z8)l_5FWV#ck>*a&907!l@o&FfJOA!Q*EO`xWjD=D4Lmj#{LB_BqB??_N0$eBNM@rO zs^4k9K`)wAue|L=Fxy2<`^PNEqw?Lc6Z_xMcfjjNC7$xi6Um6W>L85Rw-GI>UeIo^ zZ+vbtvh0WH9eBc=fA{^)&D(6Rgl04<&{bVw)=oHyT_P)(Ti< zeC*}CB8)itsjf30Ud;ld(d8F`#+Q@+du$h!&VeL_W1zSE3YIQ8!Kh~)Ea=XG`gCm* ziPtpEt%{YgJ)W^2dboGPx(U%AaNp&fr0?DO{KW>nqh465i#JBx?KtPTZS(nsmYi_x zS551tHHrj$EzYVP^#o}>t8Ize7BMWkBqb6Uj(_@;jwL zAS#QyCK7KHA2AP)sa3h^X@f}I{@%2hQFwAy;mqh(*<;mXbMxA}z7#4J$Yv+iwOlOD=?h#*`7M<}~^;zs;Jx)BkAC^CT zj{5S5QbCpxUF6#7AevQ8O>uvdFU(M#c`C_4MPQBwa*E&WHMjT2+Rm#R7je=e9;f%< zotT85b9Q3y%a+bqNiRAMW|GTy!?WQNea@qQa>(EHY|+B5>0>Jr=jKroZ>~4HrNStB z!Ev#XE%B1m*96gWE3@T75=ri|55LR&RI4)wcg(M!`R*n6tu1f=f zxft?c2I*8h=2Txy!RZ<)L?fa?)WA&Kz+(6r9$(S2szx^`evVp_`lN?wkKca87jN0j z8h8cAH%QK(Oe8gwpX||hdi3j#o4cWA@15Njnb#3oy;n}Byhkx0m=JGWJE>FyPPA*3 z=wI`X`qm1i;zk5dnFCMB>y^-*54Y5{HHn|A`bF0J9^PEsf%1(E?>7WD|~pkE-5 z#yut8wKI}*0m5;6lj`L;=}WgT1$nnxgT=OJxZgQnYy&+q5o~)`xsc$%f^H5($DGic zt2q6YG~;ZMK&5Q6Qn~vVSufnOP-M1*MIyP_4pi(u)Ci5(V18A;uk>UYHIhb`fG0fC zB2L89oW+Cp)w`6{q`+d&nHp@7PLqM-Sr_Eu3?K()f;1_Cx2)K_oo6QbA=93}x#Da= zCymlJCG-Qzqc^V9{{v5atN@HD{IsnrP%AG<4@oo`CLa1N0K=jOC@p%ePn+AZHl*2C+nGdrKq;{-opeR|W8|JHM8mB07O$qVWLvtJXNWnERwYB(H&MnJx3=3nUBjARA4+=@D!;5ApoWnWaUH zC9U#D4d#|}4!nO(3o($DG!x)v(b=WBY-mf}?BW0!<>r^L^<@Igeelipc(>3Gqc(#R zeS8LGF|^pLSa{6yF^EpTUBhepN85Wd#2`T_FLF;pzMQ|ODJ}#Dg20+s<^lNXQh9Vw zw?s()Ws(1fmPf-zCi93R-|Td1(igD9kOTW?Y}!6`LD?-~XV0q(48QC1vXgOi^PV~) z7fMBb7MopCl(_28QdDRW*XvZLF1_Hrb@?8=GkwctD`brNH9sfgEe+-qHDvhFJ>VXUjB6*IiFwa}eX!Tj^{do?1~gP4XGr8t0V3%YEC_%8FzdZVVLqPB_V-9e!962q zS6`DQzqg0evabDdl-3(kW|{r(x3$1Iq!~y%tRu+Jd!QzEOVdN%Qs=RT;|Qge`WuN* zE~N$a*_krWiM5)hQ|h#^zzT{Bew5O9Lo`ddi9{nI+rWbr$L{1}a!lHN%*%$2YZz*C zb!N>@S^*V@2Y<*sBtI}l9vjSk*u*Q4@MzUszI+9uESH@UvyX3^EeW?a+f_Rb+xo(= zoIp8IuT1)`o@n|9$we4yrhIz5ji7D1$;M;+_nlObv@Sv)qOu3-2S-(nLX#w@@T2KQ zNM7zBDh=Wv#Y;DPJl_%gyEB$TV13Qnd9JQy(!da$#Q|5H`73T@0WI-+Et8pK@yq_o z+tI%xF6pGi1Zb4*x_Pkwb-$c8X=@{o40kiECpTzyVv_%TGesGuGyuN&5E+wze@!{y z#*XXoQ+d(VS%P&NVqrZ!@lf6;MfYyT+U&-TWKcKLJBKYwN-K_R_>eRcW3lAHHJcW3 zzS+~c;0*{sIZTA7lp{9-Q&m`IPS%|u&fT;OCvzf%|~MKb2p{TKn+s^i^1s_~Lu_~qOZUzb#dAe(7GGVux(LJMHyY|=K3Uyye z*)hG6QkssF;;%J5XuKJCN!$1;Tt`7|exi8a^qg6=)6f|Y!(HL( z$VCdXFaXDf4Q0dTV=T|O&CU3(SW+q8Uv0|V8IMbE>*cQcA|*ONZ*o|L44OdL-?Vs9 zlz*8TgS9Uph-6oBGSq&tJt$I4>EZJs0tdXt$6PJ5z?r8f0GSf9toZ4A1)bn7r-ex7 za%n8}kuol?)&(xY|I4ea??B|q4^JQ#`bF&Y~(4LZzb~dLe zb;6hdK9a9^|*0VE7J)!Nn@z<5U>sFQyzu4h>*@ABeAl!k}DDOM4 zUQ72qf~cGS_Hg~*)K^ri{(|~Qh1s^8$7WFop$o$ZW zAGsTko1e$cm%OaqDpqn`c+dNq7B|-(R9}EP{rzG2?g>N!k4l4yHlW$r_2^zK^+yLr zbafnQ#>uu?8f-kfr)gC2I-gPB!=olv5B3+ zmylJo=Hk~xqT8Y0euv9&wgXe=N=lfUhkLTbyt>>bXFt4t5~xUR zC@ojSe3BUzXM4YWe`w~Cr#|G{c||6J&b$Y-8;>KuCW*dz#f#;xTjiRB2zzXNTI+sE zmtW-Ehmk0Wus3v5;c~|jQ14p`Z{fLY z{Se^|+Q*ZJAWmNNIK{(1)%JDVhOv%gohbk8u@IT9Uol?jbK1Y%m4i%SQoL*PDR76baA&iRr(QTfy zc2GWIuxJt|SLp1HXT)F0U@lrds7NZ*X+q4fPx#)OjnF6JZ*+e&x-!Rp+YgESa{qJR z7pXBV5<~a0D|Prnv#7_cSno&Kp{nW2WA`hH7hk_w{UnMs&FI{U#tz)G6i;@Kkymis z@obK@ICW4`iVr2l_y1SjY1h|+TnfVP2DqX%i*W1HI$#c_0qBL-Wmu1x?ZP>#~ zq$*-Vp7td0cm1vCl(j>p2h|fr4sIht6Hfmmpy`_ybF{Idpj&d`1<->A?Y#o|53|me zcnlg!g5%eRMSM3uD}Ez>8Bj7B)UQb5Q$O);)uiQ_zSY&mZB+1h!<(rUF-|D8E;y77 zkOD0hVbe&f<=B$o=(p+fEl+fEvyWTjEqMXbj+dsN@_wQeFLP6!dqqHDw-1ZO6a2@r zgR-{MpQcbX7WOzbLZ)`$8i@^Z%wvs_je{m+q%6vpO@qnaB;3+-UTw=j_x3f=tWgKF zR%?}=-(RPKdV+Q{vaTL9KRhy%fdwSbDMw$W^@N64Zq}|O+~E!SJ0MvuKy@CD+{$+d zX9>RcHupG=JxyT#-oBi{d#N6IVrtEuT#Ge&q!gYLFNj7{+Zs zN-=7=jOe}CIF$A!Qn&%~>n213lE6IQHw)=&@Bprdg)FPweIl$O~SjQg@WS^O>{3(zH-O#aDW^~)Ey;=rV{cPL-zPZ zTB4Srx$-tB;&|*?2~6lux8~MYQp>I|r+|+N@g4C7e8$FD(z^jjk8SytWR*1E^s%y! zZ&n-e*vLSJmM88e=cwBu2F2?2nCnF~yH*%g<@(uE;;5bjmYvASZgXpjgWBGlW_&)! zDdoc2_3jrj#bMa-n|6u+un#eQgEz4ka?6|FJ>vhohW>QLa`x}!VS18umN#EZeRo;- z7da-ms{IRdOZ4&<_vld*)){ele7~Cu_U>Sx>-gA6#X}$#Kan(D!tRNkUxdQQ?)(HL zNoT%;Y)Fd`2u+?FlYv-*0F;O8M5g_RWYEM$q*lF~=qst3Rd1y2ZO?bO^5%rN|{rD-_kkeEdOJZhq#S0K|~7e7BC+Q<3(vzwFcK&C6t# z3g3#BjUYPHb$7Ks)?UAwYSI{j+@-z{Vtg^-#M-Z|; zb@l5~)AS}ZsKxdOA$BG=sO@7hu2p2ceuQ{YG`7XEtDFN;T(qJ@zYLw`N+J!D{^m-_~9l*y}!Qpb2W(wt6OQkG=RY zC=dAE6q%Y1#e0;O0iz6;2l%`>gOhvv5sYnJ(?Yva)1|JRLU<7rUHD&DADG6^4QHNX zHL>C1b{YFpkv*IEu;lxBJZ{~mSNw2f!5qnV{M+Eo>$1B81$wfmA7!=7Q!HGQkpw{a zmtH`>%Mo28sZv1r=78oRygJG`?2YNn$awi~I_xpR&2Cg4Av?x0Yidsy2dSq4r&r}Mp516wQ8v##4^J+ zryip52kJ#CQa=M8#&<38&c=~wl@Bi^CUp*p4MR*JKOJW(r-paDa&pEIC#J~XVEQL! zRm?^YpU~;wFl_fDE-T^oFNwG&^Tm(<-Z;048=kPd<26i=s_fYeCpxAE63+r=7VY-e zF9OunTDr)7i}b^c7sl<*L6#4fmhqEMS+sN5Ng7}r`Jtl4F6A!>a-x0Q?o(psjud;K zV@E92b+xiNf3Isl;F}B_>5ar=;7&@gv;r-4c|b33=^@%y>mudhaj`VohPq&aL5YXl zjSz>-)>{xrtTv)Ca`7TmVwtsQr{4M$^2B zU6#_-Tm$UI5VT;mTYZWcwhy`??4|RR|Hc&=OvFcP@o0t^TTpoWM$<)nGeC{-3JGZ7 zin+EAYTsqVOHIs3I`mHMM>~j&Slv&djhlc?qxs_qB1Q5Y)|a4~AmcND3P>4jwE{~~47egO+$_H2GQB&PkcumI7qHOoO^fBP z?s|9R%Xcw^Rc}=1guLXvs{toqhJ7Sf8`6nqpKH)3Uv>jc1tSMXEqk&F6Aw=22Eet1 zsQdxw%P7D?!8`BvXimlZ_yUB#O6}r~?i%!~8DAIUe#Z(jI-Vy%hbZP9CwSYaWAL`x zdXQ~fuIh-_wA`-0-ZNeHkjqT_@$WAF4ox9YK)iSD9LJYSk?e&;?g~HFclPwFqH~z2 zXmpj?)xFXiZ;-RtnGyGBeKxn}=tHOa6XG+nontt1A^MYe;mO>d-E@SRuF%2g(+68* zFrUk(>D<_T2t&x50GSF`U0eYa1qBfAxt7GBovcn90RK0q-m)6}%C&6YAw#ssW#9K` zjpi-Hd_+$YKoWq)IRLF|Bvs6P&z6G|uqWY| z8X-1VEd{d1>1n-=m(VA@?KWg5aT(Wr{IY1Q?N2Jq6UhZiU&qTy4<}Mmg|UyBWgumT zBEL0bax?irLs;`gJ8PL>E_INg|B7HFV@;xxsp{FH?iTDM@QwN{y@TwQ`IwH||27v+ z_sy0*O2v=cJil$TT6H20h|NO(!Q`jBq<==<6UfvMO?m|Ch7t8jhAI(a4VW)`UR9AA z!I4ylkMB6$>z;pp_bvJ!1HYY;u*@X>JM{1L zyCY%Y*a}&?IYeKNsiec~jgr*wp~sA9_m`v>P0qF*Fy>X$rWZB$S|M8M`ac>&!Yol( zGVcU{Lh)6S0AZXdG8w3g=nh)xh>&c{1mre2ECx8l{;=66oRt@yJaZVJJAVrjK~zJW zGJIDH&p;hOZK0}iY*X>HR!dzPIAl&d0;GQkJOP@_%^D9}a_Jx_^j{-L8?DsG*x?Bt zvuK9}z~6z+Mid+ZOC|jC+#kYwLFv{MGdyu%7J~_r5 zI)1>SJ%3d}0;ZQWpbu|_@TCrd?ha*6wb&|QNejZ&pxvQ!Pnnw_e@|*U2)A{whJ|2` zE_H_aYBVruuxP*FEmMjr}P*+4p9@g&yLk5&TJf(hQx+YPp!5>vH+6TLAe(d${nP@|JOJ&v73% zwKp;Q9va6QgMLO3X$8OdGxZ=#nT#DZ*6vQIHhJyZ&g6hgl8w_aaugr9n4M_NLc8Pa!E&G zeUN4O4q`Ug&l?vA`gUQU@}Q+VcwKIJ0Np~Vois8j`t5MJ&uim3<&FX(Tf31A@Q9+` z)2~ZA;oUE6X=}_=rnzrEZ#94aoX)xy$ zlVT?l!Jj`sX&}deoYCY90;Mp<^yAH*Q}#653OO)UGaj zR9u%kIR$%$40!C z&*60;G+b&gILwdfV4sgt4+E$TUxpT-6%sT-GbzTH1DeS`8OTsH<}btZKW@9_Ab>x* zK}WN93Q*{>75CPQey2gSFDSvXn9qF(!oxnWiw2451M*8B)(&RQNtw+XHJ2Z3RrLdO zeuhik`Vwo9s`hc&=1^Twfan7>;OTvKW)LSHxyeISwuZ3?gkeo}P2a5j9CYA5>MS_G zRnFxPy@Kn05jd^8y*V2-@yNLU>jf}I5d#9>E#fda!A>9zURR(@iXh^wKr6$taG}zOFpM)VJ85qdU~^ebKTAus+lZ>n zPUg;A8b=p_Bcl%70{mb$8jDoW^q{}`on+Ul>acNcC&ju7G%!L?%HyCjMXq5?uPIB@ z?g-Qg7dJXS93=HPUh={df~(HdwSD-W1b5O5$xnGt2Xh7cJJV}!D0Wn_UT>*4Yrfjj zO+f=R-7Qnpe)%rf%n46=M;+Muza?FF#n3$qpjSt%5$1r_;V2h07cY3DvKisgMHp-8 zf+^MizlLo2lhtV0w*>iS?plgEZY7ogp|cmk(9|!5zLCaDQ)%tIk847`IV%8dwOZ%ES9=NL=- z>qx8x^{N7dD;kR%4H^NtlsY5E-uu$snhvDMnUd@aj+P1Xm*3$M_;%shSCJr~c;TI$~i0H5_R zbDV$b5}efMLO_D?SH6Qh1KdgIw9tJjkc6oKx+iKQ9F23BU5@Fwk8P=F2Awh6E=4!9 z>9TzDCv&FBKw?+{bmwPo$=7eucF_39+YP_u1(RpD}kj0MM%U1#R?MENx*8oWj^RKYMS=F=K}KkdkOO$7DZ-e z0JBem=KMg$qqLq$mQh;cRHS@jQh#EK#_TsytKI>?Edd=!8k zw#dE@a_@|I2`4KwA4TVkE2lud-vuB@Ss<|vFy=U7_oiF${Nyj*TQcd>?K>Q9#4l3}Wn z!g_7zWOO7%rXR3i&L?@BLSUmnmv&*;7pV;Nh>8+w*>UG;|9=E&4}<=^BGu?U}7fLM(OKx*}^DA6tN#Yd(uwmIwo?TrEjQ$bJ z&WLFKFB$IrbS}X4Fl^^z?KqMWq!}uyhK&3$ZAq!AP0yI(6v9N%`)&>O49k4jd)p@} z*Rh}JP4K9R;gQ6Gx`0|~MtU&{JhNI>Bgr^%(!^W3)>Q)0RPYUd^PZ#7_f$|TtXU$e z3U1n0Kj!9iWPM#8siJm}|0kf=jyuWqg!}IQ`t#cM@%3h&->#qw$CD=rHB=3H<)X+5 z0kn*e_Ia_}&O%~T``(P~=P{g*mSxD|{k#7KU}W*XtWiM{!lW9WND-UMWH2Q?t&8S9>}?52C^G>RwY%e2=m? zAi6w)2N$19>(y%y8eQB|1ryb-rwKe1e&e2V@tirJz`Rr9?avt3{8Ob=jKN1R>J~gL zZ|f!z=KOl`m>T`lXM&F-lRGfgr>DIa%x?)exFC@x*IanftQr&;K+5fuXODW`c2B30 zJs1)%{8d8vGDCd7(IqxCl~t;a`B)VB4J5n_Vy9lkU9s_YI|a&(V={oalL_V2C-z&R zIG4hnOpfpv)$f%2Hnr%$+3F~&ja-7#dWgz(a6F8py-iNTx&8w;d6s&fa;XG`Qi~-Q zPaJplnjn@I>j$!~UcOYvTr+`?Y|`fvZz#P-GXw=NqfD0W`3`ogoIf94d| z1^0%%jE;2LN*`*|pjzR2(IG%TC9tnr-BjG&{7i}ja=T~k@!E!{CM5gqrbQ1#u0WFQ zHT>C9{xoO3H{hOK)4E!Uw=XJAPIHsm_+~%y1kwl#nM3}QTqzzTrAO1nfK+#;%Uc5W zq3QDURukqh5C|@>e7e5&$obqu{c}sGCy;wG=XqP?P6($^Jba-cW2O%|CUUqeFYR~@nU_st+HpS2~R zz<|Q|NK4qFtEGEA@1k;{nYLsbe>7TK)TT_a48gq8;V)2XP#1K7@t7Gh-$X$ZYa6w?SRnhZp%86<}H#FUi{DJnijF<`>p`x*qD6#)&ITi zPRQbDH5~+~yT#HMoF}^!>BrZv9dAlhz8(&vG+OH3@3za->OP)9FbP^Oq;Zl4-}6?@ zONFf|!)Pn~BlmdRR8d1>1wZlFNfl@lsrqcltSgz#aY%Y1ls)#7jVpI&9E=szdGq7^ zM6miqw+a5LrqKwz3Q2_wj8=ORsevY3JM81X&T$)8?Db)*Q`0_vPbV8bD zGq@*^Ws7V`{}6e;u75q1wrMeM7)~#PxV5V0evVt(hlZQx7@QhD`RHrQ6yVH3ggB@% zE3fZf@OVwu(?77BozDVGdmEKy$qhYF)|u}48PnT-py(o^4k{Y0k62eELDQ%1k%y-h zf;QsTWjes~XBgD!iMWH52Ii&8Q-7HuY1nov%8$v8udtF9))sqg{^Pj*58%wqyIQ6O z4^mCUD*{V%%>Z8nlwaPZgp|qHPkHDa(iU-3MyZ;|#QL`MT?U-jRB&|KmL4F@lh2OgjXB#q-Ua3mRyR;!WC zv`+vI{y#^@t$SXG@P?*+VQ}id^G1Euo}EnS@q8da8q9@~nhbPrzm=8_`KwHbU7kjX zF?2ooG@_ylViStkS{%^N29U>OkM|_*I&fQcTnEM{j118>Y+`vPOgi7eG^zs6{AU|S z;XN>2_;CR6`8+8*;<*ai4SqdUfHu}{lEAY+*{-FXN zI96!9?|GY2q(T;@V4r&L0^6-klCAatXcsF$;if`LDXdhOZS@*97u=+mBn4E=R6mH* zNwsdErM1pVkk*k_!_Bs3=?!E$r1)I5nXuq_~~|G0$nSO6*v*qQRVbB3VFmR}j^+kAW6XWt09p>F~xyhXB=O9mTAEj^cC71^1BMd*xi3#CDsAjB7} zBZCXFHVSqDy@}0PJ*6kjKIm8Z4%@V_Bg}_w^uzs2(fS+^oSnt{$*0VFk%=93Ca3C} zfJBd$zL~eFrC?kO0NaHY@^ApU-d4MRXLoA+Qn$HenxVLzG$NJ z4wmTctS0bumfpwwd-a^cbSYeTq`9gdGX9T6`-0RKXN6-z^A^fBSlkT?d($i(HW3>aXdfBiD(nsKA0y_X?FKmhJOE1*Kw^Y_ z>n)2ywEJ&8@R*Sd7gI%K)Ij*DeM(**8K^!ecVv;*1p4bB!_u*_#2n zANIl>WQRI#26I$NKl&u!mAxVhq#oKIrtk;XO#fAS_sI(u)KX!3@CCKVF%Y20l9`%? zs!uRFG*+46=^E*m%s;bJkB;olUg=jss98(xuplbuTyN4= zz!$n}e~hFQY7IE?JPw6=r@D4la+7TG3hEr%BW%_~J^#{UaAV(%5-R#thcXw^?_BwX zGoF<-=PgEu9*$eDN-Xt9FnWX0`>7CFuzxQtC};z|%tOyPkav2;Jj|`WY2Q%(Ew7{E z0kYn5sqDMlToZkc^L~8_hLeEmZO8K+Eh>CZF^{0arK5yXK30-v6%l1IqWH^#CFU&=jPw+3$=}aM%tt#P%#-~l7AGe^7#f=Ll z`d-KuUJr8Xf{se1+WW)2?R_Frhv8j2kpFs|lagrc;(tPOAYL*g#eFueNIKF08Tc7U zSN!|!Lxn9!vX-H{dfcSFctCZ?gQvmfQwM?jOF%oHM~U?EsiFBpU;uWFV;IMa0G!`k z=r|CiuX=y=*2AyF`jonzb?0qjw*R(rxaxd(PTF@kAS9vVy3anmn$Y>AQ14KF(2w7% zuAVL*FTC@TR{$FcRs=piN98Cxgq0zHAo)BnU=%XF zUbE&q3;ho!+a}K>CvHAx3QqU57M3>nnwEMGl==O42OF_p$6u$@u8QYNu=ho_q(f#v zPDxSIU-PdJ(8jR&7{IHF(w+W+lCG}1O)CM9<&gWew10HL!IAILg zM?!nh!k`5F`+8bwfq(LMbdS%o=;2$Hc~|-7^+>AIlk{Lg)b+)-!;??0gb5%Mxr{Ut z22rAF(LriA26W_g#t2^pJ#TGi?4<+bP1R3YDZr(uN0A$nF8wQxA5PzOohfA!bgP61 ze$Jay{%X^k1k^y2{j-6xm}MAm!owMkLTXZluGlLv#MF?hs?F}BI=786Ngv+5zZDdi z`d8YnGo}kxE2g~B-OWmY#o#5l~jKDZ&Yg2Su=m-$TY(6akyy$4f#4 zeqU4Z8`VeKUpL1jr7F{_kLh-o{z^^vY>HL1p_Al3Gw>&5kD1U=Z>7TG-c8h5uQ`|R zkJ&+b>W5V5;iq8n2i5df{C&0-DvHiqxT|n|$WruX%)#$3@1sTOOw>PGw>ZiSbufL% z41f6hr5XYaK~=!GffbIv+36l*>O+T#@rmhE{6C=#h$z?2dZMK?$wKSl35t)@peb!8 ztk~bq)c!0mG5Y7$w$wBMiUV=W*^oISr{&^JXlp|rfc?)AOKaTztGuUw^*SFe26N&^ zE|UCC@mz#gdSqFfJq2T557=1Y5f!?%@L@R>9rP~-E( zW`oxW#!U{ScdupR!GI{{FHODn8U}*vQ9Q8Uk1}h5F-yQ@8$!tFKP=KUSGZ#(#aQ)G60TR`U|nZW8AT^vuMv0 zBZlWs!4GMIeQqnV?-`@;?ZvX0&KrLC)mYEO03AziyZii~)=O#cM@>qG#;s=m%*`W- za6Vnnp}*kAWK|>vz8_1|M#vuBmr4MK#|19*IY2;)+fvDE?5Cul+Y$AHfOSRF1-Et& zcgv{s5CQAC>OGa6PdCse)(Yjq0L7Uj(>g@TKE>gDgu9*r{e;R_Kw$tyn+m;RZJFZ) z62Gm<_44JE2xYdJYjaIDpMpi-`^i4XI?hJD_Qyc#f}OJ##ukNqa)) zmDS-pzSm^M8-z!d$oy~ZbJOBcRDH?W1%K#NkLb-*xwLs>*1w(v`HaiLG=xSUD-znE z!wylWZp4EXJ|mr?t&{mdxK5GKC_gF`PXJNw_B?pg=mB?#HgR$lP4&4F9|eQp?&zVP zBx@U}Asx&8ujJW;@Vb=_#ron|r18L^p*Fdn!g6UYAoLU^8Lk}@d4~y74GJ9#cR+!J2Z`mYa zV6C`6;&M{ckMmL8ebGr3Q4Tzlk7&}DAq)c}#{qP#1OYH}@8vWYLj76gU2{Y)#Lj1;i_1 z9ms6A0$Pk0g;S=*n|{A`pskXr=~i0sfO8KW$ZXu0;S6Suygc2(|8%@v<21Jyii}fO zaUClrs=j6=Jrv~!T8T$`#$d0Aq03O33@yOK5;#;k8@=kMa{1LHuBJp_wA&edlw@k%sMLUbQHCV&(Zc{|!HoUro#i8+4As}8$}+=CGo|po0n9#b;&WQ zyN-`c|&ICmu2HS?L~U%~DFo||wtsk~(U;d{}tl967U z3Jf{gTL|?cCf6HolT&^*tR)-i7BoL3f!7G~)BLe}8_p{I(X6yqt(G9d1-P4zGE+A# z3RKga@|%t78cGB1Jxo4-E4Qz?w6FE8DqVU!{bbr{YjD>`9+4WkBCgfe z#1N@^P(Qll4mc?JO6KD*L@M_4rLfoic8~6%iXnNuVcAV@*ZK}^TNLfuu{{onm-~=3 z>5s^(9ybahnE5fioi{D=fydd{@kvQb`X!e*`Cz46dcQ8Qp}v&-xP#t-+#v;A@Fo61 z(Y$5&{%yqL+8$sH7u@4@a_(`U-Igs8lFe~n2TiF&;kGn~+9@u2O%LWcxXFO;#%oBj zYB8jPA~<%_qS8@cRb(wtnlA!hj%Buv*&Nuu(&vr#-;ZhIz~#sf=aSH0r<)IIbyk#3 zsfb%RlSK4Pr_zd2=VFv87@C{mDJ{Em*3DGMe!)*~`@J%^y#3PBc1kXK6sR=2@R;&% zeLcY3t_zL94wzWkd7vV7$NC~Ec(b%9G2uRjO;4@@xX6KtFR+vlD*!*Dqq)q{*z1V~ zthajJ?MT2yAdJARLF=!0caNQPa*KiENr3eH*0zFW(ULddy;TIlx%N`kfopBBp$Re{ z9P!ri+tH2f^uZawY|~M|yGK_=MH&LPo*&Ky|DyBTs_}SEreYM3J4IPZC$U3I(gvFh~Z5+MY;RD>!n|KpBt=}IShUJjGJx|Z3 zf^@sjdAhmw$p9Y}l^Z7#n=;54QD_$OFRJ-~*RhIuaN?C&GZb9b%h-5OogL4o8$oY_ z^71kzHc6zvF5~O0<+c{u;xBmLa|cohSF zf=CX}MdAfe)N;yM0|hEMk31Mt=RW-zg-h5Anol;qqDotgbqf^z6%(bW~dOL!{vRmr)s_g5Xq5s@dMd-I=V;XSm7z=QsEZQl-J#G%3xdDs|R2$ zUUuyI|DWp!S1v~gnFK(^QECyt*;dPL7CHaYl5{p@vgtnXh?AS*9UCUZTvMKUZ?}*(-{r&^ zJv@zIIx58bo3j!){DOv?M{fn@o3;IjP^RFznu&O_@dT^N#qI5vI)Y)^IM<251vX?N zvpB!#N9DrD#0lHo=^ZHY9q4rhEAAyoyZ)nxK`&*iMxQDp=^k)Q=@POfdHnOSYS8SD+>w?ubw`(7~J_sO)@y`nDl`HFSn zZP5*L;G#qr_D@WpDgJRHW&e=nFjCiOby;@Xs|e6lF`H8dxD_n}*Vl-5R0~ocI<$qIGacm0tW}9*W|FJkyXLWV~yI29w3gNER$)s5x{=c~C+X`0VZRu^Hl%;tzXKW8BBRk{7#nU}^A z1Y75G=B~cUT_&U{3H$Kmt^J4KYJv4d;(K0`b#*LCX?dgTY?js!wk(k=r6Pvz&)qAU zXUppJGm63wO=!!Q{jyWO8VX()@8-TxMWppS1ue(=p^{wE4I{=XUK{l$?vmt^#?$?E z(aL8l9LS{JhyJV4ecejpg;K^_Uwv>nIj!tUz+3V56tnL9VmuJ5-ag=BwAB)}?lMik zR?W+8U}gQyT*sX!BDkF?*bPK!S@EzsL)ZA1t^3a&pW!sa4%~ssosz|g9PIG#Au1Ar z;NouF+gIR5@1M`{pp7k)<~DeAIVv^E3rH?I{4P5QHL-Z!h+Y5H+1M&wR+m)RykTFp zXWHaSN|QX^V9MZ)X5#SwZu~qmcT6icC%nB6O!y(+x#e1YIZ-uW9sYN#N2VMs0S+vG zw32vQ74zh<&*ta9?UQ%lQr{;QG~2y2%zqaAxa{q^XGKptxdO<78-eZjyQ^6i;L~VK zT>lI#4|!|0p5MBMZh7m2bGWqtuf(4=I?4LmswOK_Ev&_4D!P0Crf2`Wp#!d9@a7B! zSlw$UDnoY-)Ac6O5StEfZ$G7#ZF_3*I03d9{3gH@xTqJ zsXvkjkk_RYVL+fS7;}&-Zg9ig1Hi@-LDxg=kn{d;K{dhj$HlPu$*#JTj$l*K;M8xTSJy;_{cZoseEfPg41a)9hrW z)&#u(T0a+*@E*5ADqs_lNIo0r!^*<%I8O3qz&&~Fe{v*E^f{R9Aw26LU7vv?V*LT< zPkXVe8-RhkgETKCzyefe>Q_d9wFE8^(CsFr4&$s&<#l6g0=8Mfc-axBWp}ws18K(# z{C;!ReOQ#we|HV)(~vzM5F8+0ac=7WUwdEq7iHJAJu{>rAT1yv(v2V~rJ&Lc($do1 zHNd5GgLFtYC|xp$fV7g*BPrb>HP0UJ|KR=n`bmCs&be#Fv5vLYo;i38#_S(bp53BZ zixSJsNMbM52d^t>v|*Bfmc$1T!|KqZpf9gHR(ViFC}Az)({HWQ-ieZL|GKd0r81|( ziOP(y4C6)O{w1!PY+apv>;epy;yyY?q2nJA){44F_y4;(K>L93Ly5YuR%3~g<_#;L zqvNNuWci2wx&VB@T>3&X?q_FWaHs1`i2e2)+nR$P+y0b}I!5yl*fVg_=vuTcM2xf< z3u!~sZ;-eS>}g>5QeEa`L7GQsY?OUE*Q+?03n3wGDXr43k|o>S|4#I_C4i>)zeee0 zO1SmfubF+1(jwGm&st*l;<{c77i|oY&U?^0Aq0?8#(1)9@X%%g1CQVlr$$K7#O$-v zN`TeeD542SK&_zA&Z9%^_Gc02J)<%WwAml{0WrP{_|6KDMAjJqgj<145$Jf(1_YGg zVAE5FTrts$CY{K1hIbFSGn+vFh7)vjnE#?Pu^!p!*29&G?182&t&R3^` zPGL%xx6W`ZG}o4dZsk_mm*0H;%Y^n~J8L(fQeP7ky#Su&md0D8eDHTY&=)PoxeuPd zst*-hAV0mt1>td-jTKe#_x&(h1GW@ELj3h%<1Cs2qrKnPK+Y9}`xHb4hL78t6_>+2 z%&(t3f47qo|4k%NW3uqaQuzgg?PjO5Lxr5ARXf(b>F(Qm2Z{Bc)UCz4e%PqyY5J+D zUk9n6P=`Un#aFWvxym=z*0(;xxtZ&Bz3C=b1^nQHyZIw>pniK;`$(W;QMi;fxQToh z@LCH`5MJ;}bfsY=p7(AKZ?8s+wQx~K8F}y$R=Z1U?mOU`p{Se-)+k>I?m6wrr99u^ zjWLSHl6SB41asfX?V@K%yi|@`Z*3v@e)g7g!p~^c?gg3$l_>3HAu1nr&v@0MgjOr&R+wxz6b!7cMN-S}qQ-oiPR4zpTmb5Fj;b+0OE~O$cXJTw((&IY^KC@p zN0m~_+EA;tJtG@Xiwq4)dRb-x@_@PT#jN9-Nw#YA7qtvhscN(WvAxxe=Q#75ty-}T z)R`_gWuym-9c*a-;xWITdRc3xH(MJd>u`r`>&xr;z0=>)uE(imp_a-A0(V~Ed=?aI zz1#e_S}qQ7Gt%UW89AUDnU)R;i%cd+VF0-53WnG8_M{_!xf`dwmu?| zWlbWC&1rJV0_TFdoM{)-@PCEfW_+v{z$QpAy|Urm>PMYDT?Yle=ITMI5q{qPnxB_F z>Mn_BcH?CcJ*> zKiUqs8!<>0&NU!??`zCVJdjFynw@8I&d>&&G%mI;ZpWUk=_K?JyVm4no0db@B(KHPwI&*AYAJwW0FdBCOiAhB>|D} zK)aHQKLPLkWoEf>1pg+ufW+_7L4CWUcKAB~_;YwwX~m<|eD)tC`072%#kX$jsGPmr z;gg{0Wxt_SzZ@dN=G?Fx-nKoN&>pOZr$<6KAV_Q}u7dXG$@KBE0@aUV5c}EA8z< z6`tYkcm;#HQSIwcenzi4-_`I@jFW_Wf>Di5hMb2<2iC#Xe|n!NBGU6ED>akg+iKaE z4U+~(6euNdjX@dBM$PLNBCp#^Rt2c~SSD_E?{*M^(xD4ZO(G9KV*4_F3C+2udmDW6@F?(P|J<^3UZv4(`I#N{}6pEnr2gYW0PcVe3hcb6p&Ie%!q3H4TO zgb#j}->agmuA%nCI9Sb>Q2r*B6bI#<0+15tv(^iH5s;hEeq`d7A&%|^5c9xi^#Zx; zdi&WA9}w;6^1ls!&?M zQ9w8xEtZ2IB=`w*Rb`WVZmeIlfzQboE{n$Tmh@w7SHxLfuc6qj?{ z5h=)aMql^Q2zLlzt{=Y z0iZ^LY|G>yMxL^dSuC50Iz^z8*zRwQYMd1DJ?2@trF1qmW;U<}&T=}5f1py@9@^s`ZAc^&^l|}3W=)IWN{w~X*4)iT+R{cl_osHJO zSHy*aT6)?FC5+2 z+*HghZxY2JU2tPr{;t{Lgy_df46dK};q>tBtmR&DH5L8OoV7XFQvhDR_3Ay#DwAJ? z_JHQ%3N__Kk|)EO);o)yZ6G1pRLb1XE`u-Ec*(lI!GJZV_(ra~ER97a*r(ng~_!}UEQG{2hrErxLolU;XU}Yog()!38 z(9n~cm)PBE@*L#FARe*;5<*dWjJaV+a{A5@)0R zfnB`x@vLAwkep?Y$OZqv8o0TUGcFv%s7G^4hddLXQN>wS%?JdpZ(ZUwwX2vZYm$H1arI>2Xs3W52|*C>lfJCwxPMccZ2G@6$@_X=&XfZ$Nqk zd^A3Zq&SE17|I;N7)6NLrl_poGd~#e!r3&^E0c^9RmS95H}_6FN6N1HG^ud@_>OEA zs(NUjpWke(rk?Dl^ox$x^=5zL1X(v7O_Y zxBA;OzDl;emf7?U!*+=?7!BOR$kF>|Dkv4r`_=uz&(~OKwk~aQaUk-5_GG?1e-#Zt41)nby zwNVv5t;&>_AcqQ+ozj;Gy_Gl?h3j3@@4NE^-mgJq@n0Oar@8Aj>0NW4pvJ}B$n5%KbIE{?rJ%_<6%y3%MaYcl@44#9}Q~HklX|`!M?{w6qF4HylowFLtDQc`8gulGzyX``cLV~pf zbA-6oD2pbI7vt9MyK~{~^%J*0pPK%ggvgdByH+f5>t{&}Bojz?dtu|1s(0O1UKgrK zbKmyV*7AYCcd*WxYjHa`PpLxUglL(m-ICW?reCqGMXP3D^#yKxd1}iuZXldg{as=i zVr7348h9V|T1KydyRFI@Bi=7@woLfX?80<8>M~?CI(B83{_PW%%M^Js|6(v4DLrT@ zVd7=k9iTw%RjZT;Slhl-)u5>*EX}|+&XVn-#0N_x221oEn{wMT^077>AcJa>`=AWn z(idAJ))ltl2yMj14d0iK|63#RP&zzln7~%>&+K@ZfJQm{ciOeAY{8_Pot2M4%n>1- zyJ)d&LzqClHn4r3)LrlncerbcHJF!_p6ZQiPw=;K=5n$z>se?)$hhogT`-CRHlnlo zZQ2*OYvxkIwl$VMN355xHI|YiZUXNwX{hNqDCWPxJ&s%-Y>|m!G4i|8KQ%YGmlaXw z`CjHmg#>FV;g{P(n&wkSq;`u;L&i*mzD{<}l0;yJe$A<&9I3Y+305u#81O$W$WSN~ z9^sovc!v-Fh?Wkf*4n*{ZM9CvN5hj-HXeg;zZX1)&BpaJj}_e}YaJ2Q=_Y zxGpCn7)@R1>Bfs8*^cx{nsrZUZNiVDgr{~qB`qvXGjwTt;q-(0EU5}4SftYM7F(e@ zGJ!(N@3Z9%`qVQPQdhB>(Rx{tZ}ktw5t*(*lOAb{pFd4PCp28bULF!QW=&nS0;y~b z_m>5GSjXBCbZhJQqviSAvriRkzeOf$zGSV>M%k;=ImglW@^Z3OG+Gwe1yLW@XAb)L z$It$Z9c|rgw^Eq?5|~vt#ds`(++)HM3zX|2S`mhJrqUqOrj^TXkTzw_C4C2k4}>zW z{w}7;cA>c0n1Ntg#w#ne5q$65$dvfl^2i#0a63dqtG?JvW?BN2(=2KmZCM<2ll7?n+6ElnZMz&1Gfb2oWh8%cH__Vg52cRtM=kiC*+e!G{AN6W-->EG`fZg<^g*<*>1OtewUmnJGFC}!A-xG zZ9`ehPU$#V%0!n>=^Q-L4j~6wOn8+Nwi_Yzy*04guN0b{mq$7{N{T&Hv?X@?(iO&d zLD9P&VXts(sNdYNycvAULhHf&WQ}Z(_vrZ)PG}t)$B+CD;{O?=bG- zmNUjJ-D=(&)`}Pu`a|vo+YozR_3V zd16sP=-!PW(AyY@J?g$-MyN1&*_+%94C-eyvy*S^Fd4<2%5={v{+2-SrXDUebJ0zv zr?h;(yE{8$*c8xL5=?*?KU$vGEGW#;O>g_LIY8%ZG%qmK9W4ws+HTzU_I^7(67tw? z^hb5Ji3#{ZAoAU6`!l!R66ao4n`&ddRz?J^Sd4X$Hb3@!j%=5(SauW;T8QNP7UIVR zz3YlLv!n4~rIP6qe+?*6M39=vW!~c|!zGm?iO-UM_P;)OF*y0lpFL)<{8&y;Txfno z{1}CCtwYtx2CN7FdjAuzBPBO&qSI}m5QEqPp}hm##lUTe6ZWCtP8@OcSWOtYT_^vg zshf|tdXB^!qk`^8pzUS$@sWN3!)`GMZOyc|3NYRtNBCkS}Ix6!~^HJ zT-ztsbVEXd`~S>1K2ITiFJZRU&!QT=y@ zPMCY$_3v}k&AaufY08hCX412I{VFM~2U;(J9$b_$`m%@D7d(h#F*_|x`qOD0RY7pK z;W)5EFk@Rsv(q-9qIMd(KkWHT0oeAd;0;)d?&GYVF2|C;77aQJ!2j9D zU!Yj3HJ||H1lLV<*`6R;u?DwNwy;i)SuRX8IWq1J1S~8Nk6bVr0e71H0(A-y&HmCT zu~c*}p+B(zo$m|ntEO$G$>Ahap-13X3#wWuj)`$JWHPDpb5q@=j4A5IFvES~t}hiBAlwo`K(vTRwf^ra(!R zz*z(X?@M86K3Lk*$51n!VaO&jYZ=iy6W?4KmXLVg z)Md)$A`AI^0~myHbE=hb`Mn(j|x4^cxJOZCGfrz z79Ex=k)Pmn<-l!>=i?;NiSI1#vwiMC1kKzLAy^{9`V^7n{;Nzcr(Uhmae0+xR_N9r zyBksOrB?>|j<*U0(0RK|Nw#QR^DX|z4r^Qk4!#(DPU$PR1Tn?w4{Ye^Z)}vHlRtIY z_4rSi-*CSA9t9oUAmPjrAd zwVs_calq)h>_2^QHYSZlJiNM6TN(S@d0)wnOVKOj0S$ z@y241I;)(eGvDUKf0Q@R63nN`f=m7=7%kNjRCDXQiB@R%_WRs6iar$aE4O9Uk-AGv zEtNNHO~W@nxC~Abt!Sr-BZXJ7fpgv#8f*V^Z9VUY6Nk*Hoszy&+!^#TR|!BZGB8#y zrDnsklZZQ6)|KW-=jOM8RaF#n1BHya(l#$iuuNc%SSo8h$shTL?F%Io(-#}5o^Jn& zq=(X-bbC9<*fem@rF+w@^IQy#xjo7m-S29j@~fO&4#FK@>Kuf9Z7B5 zL#eT?h5?Ax;XXGTXM(6^f@=QI3!(nqnKWJ$mFP;6cbmZ(4{wb73|bqLcs@};mvEjY zc7*bzRN~L8n!WE@Jt8DrrW;&9{3UEC=$;@npx;u3j>_l1F=_M3A(D#LH5(CIRjE?) zYfWF&&(>8foI&AVRS&5TEeGZ0Rm!ew$w|gMHUMhPy58Zomz0}sJQXFN-P-FbppeS* z@yl+cPWDMP&X?ruXS^vpvkRk;Aj_y@-#87Lr#3fr^Q0wZr+OvqIX&)qSL^o2Ss-jm zH6O{oerv4MTA8_7mHAO8dvj&+qs)BL)HKKQw2DAK5J6asltEr2KJ%8)z(WD>T&O+QjZ2aQ zm;liK^*^=`qwgK$6IRVhp-kd2dKR!!aqP0+8+Taz-8RIUWI&?JllAxfSahMSi^o-psv=7f2#|mxgZEFB|Mj zw4zZ>sM@L?w|~(2Zy4bQoW6Gf(FZp;G8^0D*)kBOl!R?1fY9!M-mhkg%J3?~FiMueOX+axXlT*!mm52jq}DO7x_Svccmt57r*)IM2}%CF?N6a=t* zLaYX~Hr!%*RWeSLU#c#{E)u@xHlN?9xkWIZF}av}BVsjpwuC=mt23Li*X)b6_s6?p zJF_zdfJ)H3`2{#(x&zap;9jaCBjdA-Vt0W|*GWPmb@41e7wk6=#_g6BK|nj^!U3U3 z-)WuNsC_V-aZJ&Wt>g5gp{Y|l=qxF%q$!A-tpdFaZN!xbYTDIFF&`N;WU8>#O=M09 zDn=vQ()yNXlK3x->>U4wl{EK)?~?(l}zdffk;QB|DNS7*1?=x=1;Gq?qATwP|L%2it@dhi46ajkSKD!sIU?ib zanJDDA4h~_g9Cib3v|F$o=nMfQ6h*m*#Lpig0$PPg24m{!x=!f=$!^iOAA_p4w7z@g4gCln2-bhUUj&)TveM zEM@p9#olp5jnt`g5aR?8Vv+;Nut1qiVQ9*ez2>bL{W|P?{yXo{0zfOE_b89EQkraEXbrvoQ>m=a)As6{OiS3woCTs{!Oq zD3+zRLg4*Q?D04T-J6UL;+#dx(XrzVC7s$hJxeP2NTR3#`NF&90w15_@z>k2q7gT) z8{TDcyNK5+S7E%4DgH11?2|0t?kTSCP~&FDtJp`++dKn15IYLMH>P6j_Z_`a>%4T$ zNUh}HDZ^ilRt7q?wv567vupsf9C#)UNgM9WKcsk-XX=o9tui##dAb1q{;ZG|(*LC1 zZX7Q`7fRdZho=$n(WXdi9tU;@j|4$C@n z;z*ySi1mp{*gx}_^O^|r+`SG98Oxvq@Qx@vc>YsBirC2=k)(0&xYOUia9D2$)?0Ha zg7oSKP!8Nh$gsnOG~VI){7)@b%%>H+HL}DIHJYdLXcDYe3KD4jkcUi9_?sWU1hJJ? zS$7UxK)Y{lAxgktlb-OiWmB~u@L`)XquKsijZ!(s_Fx5cM8 zcEC*?6dJ@}pgQ;!zY($ZMDsNXHO(|d>I9Z+@%DOukl6smnI4i^4}&W~u8MkTOoJLs zo&G}PgXxoD?ZGmWCg{BFNxExX?pMHh;1eB`AZob(V`Rt-zrbQR=P@zAp{CB9B2S%o zS1$a=x01-(e~jW(P6ZSt?q+hT9OD}#mg3okVBY6X&spG&pZ3V4{;!VZZ{7g;xQ zC=}7Cq_ss%4pFAweiLSJ8iNv9XY$!3N&@UG?Ey3L2;kTSB!lwd838h7I!^c@bny(QM`gKn2QKZjj5kn3Of z7mLkOqGXU1+_#KX;3!3t0yYgh(n8*YfiAl0iE}#wSH& zbE{uljqv`8f?LCK&%3>iS=WKP;$K%=*95R;O>u5!hAl-O0;oGK&C0T7h!iG+jo@$Vklo2p{a9d$SV z(D4O~J_Mu@asay9cHHoIQ8t0Csv-W=0zVyM9536Yi^h{(r6a<@T7dct1G$2|_Ot;& zMYonU@xTHh-rtB;=Kapy`iWNPhEl%m`tWa#F;8$##NR2ab@L-0)g8ww`(@8OE!ckJJSF{h0yC!80axXEIGpe@@=s z^sJFc_~tT68^p?`BgB1^#NgLt8Y8l`<$5OYz8@kiSp4|-cxc&asf>;MeB!M*M!GRT zRT6Tmk3PqPH+{8`m~q0s1xB9?8bHng`z+^~-hlfn+K1Np#_(E6D%uW#6Wr!{ymeIS zFn#0SIeX{?d({zx*Y5#9J)HN);^<2wfg z8Fb0(q0}H6^eH0u<{4^Updq<9DR7%v4%TPS0Fl`ST&BfGAeHaXM0PXQMH4z)g?ghy zXO>+(+o)DDH*sXy#_^+TK2Nw5j&U}PmYXu&U}ev%G7<9?_g&hzPuzZ=C$f3_0Sb`| zn*(BD40Z^niMcA|8qL8XHeE;jcbXQFXq{K z@s9j=sy%{{Mw`$d@|i@hUJLSS6A%g{7Y`bL3u$w~Kt!AK)I7=-!i(_%Mqi6HRnwBS zo}ulQYEtrq8qfz}Zd0w*Qh4(K_syVRFach`ZYhTdKnNV0Y1CNhAI`QNq`bsK$DJR? z8%y0@F1r!^nX1uOb=#G5%g}%MB*T4ovzscjRxSXmSt0_qEff(xL`x3Q(4UFE0y#a` z(2<3X8nqRg{U7S{D1G}As!)mwL0Ppvb0uXOO&`OJfZJHXaM;KoLlj z-9LaKf6wRn8tkVk7Jd4wLA^a)Pv2>?;6qMu%%Xfq_@Gz9yaUz(`b+Hyxc~R9^Fl^s z7x+qdyLGh&ajgw)3_)sr>|Cvh+}5bbSJtJFc!lpO@0acj z{o=zZwIZ%H;OwN9eYE``_ zjmlLl$0-WCfA|`{m@geJfhqp@RqvSdSWL>{f%8+sr{WPIg+P&*!tfwv4*(4S%Z21* z0)=~QT=afLNkiO)dfUdRN7WbRkBSM@gk`u#UqbE2J2?vbnouSGQ zIce=l?DwU#qNey%T@Nm<^npQrg)fG|kdiFhg?aDICFW3N2ezPVFh~a&aNn*VjvFqb zlB2-Tm6ayfity1@>}*chj@Qq%r<1V+n%h#2_~~Cy&QM_?8YBrqKnD~CBjIg)q^nj_ zZ^s&%EQQ6=nZ5o9HY}Pq#)~=YE`q|!bQ55|j}qC^V1XoVe9l%ejrwB>ne(L92XyrH z?*xO}lGwg4WfLd(6v3n^{;S0O6)bvRr0(o;Oc5VVaj$S+owoz08%L247oJ5=4*C3s zNu7`2S}?xzAd3_BLeS;R|9|P7;0fw8ML@tPgEfBl0V;*Bpo2M2uroyPzd*Hu@r}-W zLY?;&HbX=8t&>tdQbKNxiE%>}3(h5ij=EAY&R4OYWCFCMjalDMMcX$w=Xw|fj((qu zgO#|2512<8u(i4n`hEi2;$mEp0!BnHRc4-@layd)V{H=@RRIppg0Pe{kLzvV{b@MS z8&6EDb+L(>xmRwJNBLvrcdh*stNSkV7Hi+#upijTll@Y~4u4e!&J2r}6Lw2~AkZQc z`#c~j63*%d%$Mi+@-IqMC(O8_$E45~7{dH`a_ByWaXQVag*cS54A+^ZE&}@ zCGTF_gOnwnjO>6sSP($gZE37ix*OPKxQO)f%$^|ES&B0kWXb0`3PueXuoU(FNC1kZ zQfXHI7hax5em&yAw{DF+e@#E~Etz{q64|47%uHOywg8Kl0~|fefj*MgEp&{`31teh zB=6R=@lLT9b8dB_P|wqDZ}qR`II4w~?u3&$fB?oF1U~1`RH#%I|mD|n$3w24KX z&rnT=Q3C=brWDw;8-y(|)F8d{XhsDA7N{0BQH{oiI)zkV^hpl#^tmgngmK8ut$_%4rJXTtkpgnnKXJnx@ciR+E~2L`A* zu(@M~GZ>2H>X;KC4x_pM`CV35))}e^Jp-RYn6w499`OO+x`1nUw2X~{gZDS3dxp#8 z8B6vpXrvW4`>Z!uJdy1}0j)Go!3HNj;shkQCm)}3SvK{P?$Fi&J%#^n+0@ z#h=w%$4{3@1_#$b{?6~}qm9vZ&?A7M$WxNS(RM09h*@0?#~6D)m2yQ%Wkq5N=k$e3 zM1U6|siwEzW!}&FcQ=7Rf!TlpvjgM7SO=gknKR{qvvITlzntziR`a8*GMi(Lug36e zs)IHF6d9ST# z#m!sn^Anw+z$|%A-(-~pfRsqVN@FQbFeR{XKhv3H3vJ!8rB`9#FU)y7bo8Pc_nTH^ zY)fqMue>HYJ;r@&(j$2JbD5V>73h&`Fpy-}JnUqx2Yq63L?gRIDqZ5vnCC-j+*<}| z6rBZbSKV@jTVNJL!JuHlG!j0qy(r;=y&vB|kE%o$8-=~Je|QxtA&j5Bfv~4P2WO7&O=wlW7j648 ztcrMd^aUmrK zg#OcL$f$BYL;5K_4`URFB@zf<<-egkAeG+hxdwsMd{PSy)>5~G%X?6VaoUCHY)yiN z8at!sV2t{Jepo&qDWf!pobMF}rBPW4^D!Z;Xa@l(<&hc;FCf5w?2pO*E$tN!_)8Dz z_-1{o%?4BvK<%!KL7o`kxcH?P3|MGBtb_7HRX7(52SgTK9u#Nx;?8L0&u?>cQs5^9 zfvx-(+fLnd0x&K?nN=Fj#nJFrMcRV@{%pf>CZMp=5bgxmbSecA;*V916SYy3kDF%- z?VN%teoHz5QcQK@sVTAEK|Kb8Mi#EO(;}~!HS56{N_X(hK9XT1t-)^}oJ9D#kQ}id z7dSLBric(SZwY4;<7hwM~%fmPON9QicVYjUOa4yCSY&H!(Ac}8Ta3y!2qQZl) z9hLI)PEVo42@k*u)`RJLw}WdSx+6zTXRuMQsj;m15#P-UbRmq#3R$He&m|NX!2z~m_k`drnOmGC~47X9`, +along with [a comprehensive `TaskSeq` module](https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html). + +An **task sequence** is an asynchronous sequence in which individual elements are **awaited**: +the next element is not necessarily available immediately. +Under the hood each `taskSeq { ... }` is an `IAsyncEnumerable<'T>` — the .NET standard +interface used by C# `await foreach`, Entity Framework Core, gRPC streaming, and many other +libraries in the ecosystem. + +## Quick Start + +Add the [NuGet package `FSharp.Control.TaskSeq`](https://www.nuget.org/packages/FSharp.Control.TaskSeq) +to your project and open the namespace: + +```fsharp +// #r "nuget: FSharp.Control.TaskSeq" + +open FSharp.Control +``` + +A `TaskSeq<'T>` can be created with the `taskSeq { ... }` computation expression: + +```fsharp +let oneThenTwo = taskSeq { + yield 1 + do! Task.Delay 1000 // non-blocking sleep + yield 2 +} +``` + +When iterated, the sequence above yields `1` immediately and `2` after one second. Consumers +must **await** each step. + +Use `await foreach` in C#, or any `TaskSeq` consumer in F#: + +```fsharp +// Iterate with a for loop inside a task { ... } +task { + for item in oneThenTwo do + printfn "Got %d" item +} |> Task.Run |> ignore + +// Or use TaskSeq.iter +do! oneThenTwo |> TaskSeq.iter (printfn "Got %d") +``` + +## Topics + +* [Generating sequences](TaskSeqGenerating.fsx) — `taskSeq { }`, `init`, `unfold`, `ofArray`, … + +* [Transforming sequences](TaskSeqTransforming.fsx) — `map`, `filter`, `choose`, `collect`, … + +* [Consuming sequences](TaskSeqConsuming.fsx) — `iter`, `fold`, `find`, `toArray`, `sum`, … + +* [Combining sequences](TaskSeqCombining.fsx) — `append`, `zip`, `take`, `skip`, `chunkBySize`, … + +* [Advanced operations](TaskSeqAdvanced.fsx) — `groupBy`, `mapFold`, `distinct`, `partition`, … + +## Comparison with FSharp.Control.AsyncSeq + +[FSharp.Control.AsyncSeq](https://github.com/fsprojects/FSharp.Control.AsyncSeq/) is the +predecessor library, oriented towards `Async<'T>`. +Both libraries implement `IAsyncEnumerable<'T>` so they are interoperable. +The main differences are: + +`TaskSeq` | `AsyncSeq` +--- | --- | --- +Async model | `Task` / `ValueTask` | `Async` +Performance | Higher (resumable state machines) | Good +.NET interop | Native `IAsyncEnumerable<'T>` | Native `IAsyncEnumerable<'T>` +Cancellation | `CancellationToken` via `withCancellation` | Built in to `Async` + + +## Related links + +* [NuGet package](https://www.nuget.org/packages/FSharp.Control.TaskSeq) + +* [GitHub repository](https://github.com/fsprojects/FSharp.Control.TaskSeq) + +* [Release notes](https://github.com/fsprojects/FSharp.Control.TaskSeq/blob/main/release-notes.txt) + +* [API reference](reference/index.html) + +*) + diff --git a/index.html b/index.html new file mode 100644 index 00000000..199defcd --- /dev/null +++ b/index.html @@ -0,0 +1,292 @@ + + + + + + + + + + + + + + + + + + FSharp.Control.TaskSeq + | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
            +
            + + + Header menu logo + FSharp.Control.TaskSeq + +
            +
            + + + + + +
            +
            + +
            +
            +

            FSharp.Control.TaskSeq

            +

            FSharp.Control.TaskSeq provides a taskSeq computation expression for IAsyncEnumerable<'T>, +along with a comprehensive TaskSeq module.

            +

            An task sequence is an asynchronous sequence in which individual elements are awaited: +the next element is not necessarily available immediately. +Under the hood each taskSeq { ... } is an IAsyncEnumerable<'T> — the .NET standard +interface used by C# await foreach, Entity Framework Core, gRPC streaming, and many other +libraries in the ecosystem.

            +

            Quick Start

            +

            Add the NuGet package FSharp.Control.TaskSeq +to your project and open the namespace:

            +
            // #r "nuget: FSharp.Control.TaskSeq"
+
+open FSharp.Control
+
            +

            A TaskSeq<'T> can be created with the taskSeq { ... } computation expression:

            +
            let oneThenTwo = taskSeq {
+    yield 1
+    do! Task.Delay 1000   // non-blocking sleep
+    yield 2
+}
+
            +

            When iterated, the sequence above yields 1 immediately and 2 after one second. Consumers +must await each step.

            +

            Use await foreach in C#, or any TaskSeq consumer in F#:

            +
            // Iterate with a for loop inside a task { ... }
+task {
+    for item in oneThenTwo do
+        printfn "Got %d" item
+} |> Task.Run |> ignore
+
+// Or use TaskSeq.iter
+do! oneThenTwo |> TaskSeq.iter (printfn "Got %d")
+
            +

            Topics

            + +

            Comparison with FSharp.Control.AsyncSeq

            +

            FSharp.Control.AsyncSeq is the +predecessor library, oriented towards Async<'T>. +Both libraries implement IAsyncEnumerable<'T> so they are interoperable. +The main differences are:

            + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

            TaskSeq

            AsyncSeq

            Async model

            Task / ValueTask

            Async

            Performance

            Higher (resumable state machines)

            Good

            .NET interop

            Native IAsyncEnumerable<'T>

            Native IAsyncEnumerable<'T>

            Cancellation

            CancellationToken via withCancellation

            Built in to Async

            + +

            Related links

            + + +
            Multiple items
            namespace Microsoft.FSharp

            --------------------
            namespace FSharp
            +
            namespace Microsoft.FSharp.Control
            +
            val oneThenTwo: int seq
            +
            val task: TaskBuilder
            +
            val item: int
            +
            val printfn: format: Printf.TextWriterFormat<'T> -> 'T
            +
            val ignore: value: 'T -> unit
            + +
            +
            + + + +
            +
              +

              Type something to start searching.

              +
              +               + + + + + + + + \ No newline at end of file diff --git a/index.json b/index.json new file mode 100644 index 00000000..e5fec261 --- /dev/null +++ b/index.json @@ -0,0 +1 @@ +[{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control.html","title":"FSharp.Control","content":"Async \nAsyncExtensions \nHighPriority \nInternal \nLowPriority \nMediumPriority \nTask \nTaskExtensions \nTaskSeqBuilder \nTaskSeqDynamicBuilder \nTaskSeqExtensions \nValueTask \nValueTaskExtensions \nDebug \nResumableTSC\u003C\u0027T\u003E \nTaskSeq \nTaskSeq\u003C\u0027T\u003E \nTaskSeq\u003C\u0027Machine, \u0027T\u003E \nTaskSeqBase\u003C\u0027T\u003E \nTaskSeqBuilder \nTaskSeqDynamic\u003C\u0027T\u003E \nTaskSeqDynamicBuilder \nTaskSeqDynamicInfo\u003C\u0027T\u003E \nTaskSeqResumptionDynamicInfo\u003C\u0027T\u003E \nTaskSeqResumptionFunc\u003C\u0027T\u003E \nTaskSeqStateMachine\u003C\u0027T\u003E \nTaskSeqStateMachineData\u003C\u0027T\u003E \ntaskSeq\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html","title":"Async","content":"Async \n \nAsync.ofTask \nofTask \nAsync.ofUnitTask \nofUnitTask \nAsync.toTask \ntoTask \nAsync.ignore \nignore \nAsync.map \nmap \nAsync.bind \nbind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html#ofTask","title":"Async.ofTask","content":"Async.ofTask \nofTask \n Convert an Task\u003C\u0027T\u003E into an Async\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html#ofUnitTask","title":"Async.ofUnitTask","content":"Async.ofUnitTask \nofUnitTask \n Convert a non-generic Task into an Async\u003Cunit\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html#toTask","title":"Async.toTask","content":"Async.toTask \ntoTask \n Starts the \u0060Async\u003C\u0027T\u003E\u0060 computation, returning the associated \u0060Task\u003C\u0027T\u003E\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html#ignore","title":"Async.ignore","content":"Async.ignore \nignore \n Convert an Async\u003C\u0027T\u003E into an Async\u003Cunit\u003E, ignoring the result","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html#map","title":"Async.map","content":"Async.map \nmap \n Map an Async\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html#bind","title":"Async.bind","content":"Async.bind \nbind \n Bind an Async\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-asyncextensions.html","title":"AsyncExtensions","content":"AsyncExtensions \n \nAsyncExtensions.For \nFor","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-asyncextensions.html#For","title":"AsyncExtensions.For","content":"AsyncExtensions.For \nFor \n\n Inside \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/async\u0022\u003Easync\u003C/a\u003E, iterate over all values of a \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-highpriority.html","title":"HighPriority","content":"HighPriority \n\n Contains low priority extension methods for the main builder class for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n The \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-lowpriority.html\u0022\u003ELowPriority\u003C/a\u003E, \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html\u0022\u003EMediumPriority\u003C/a\u003E and \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-highpriority.html\u0022\u003EHighPriority\u003C/a\u003E modules are not meant to be\n accessed directly from user code. They solely serve to disambiguate overload resolution inside the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n \nHighPriority.Bind \nBind \nHighPriority.Bind \nBind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-highpriority.html#Bind","title":"HighPriority.Bind","content":"HighPriority.Bind \nBind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-highpriority.html#Bind","title":"HighPriority.Bind","content":"HighPriority.Bind \nBind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-internal.html","title":"Internal","content":"Internal \n \nInternal.initVerbose \ninitVerbose \nInternal.moveNextRef \nmoveNextRef \nInternal.raiseNotImpl \nraiseNotImpl","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-internal.html#initVerbose","title":"Internal.initVerbose","content":"Internal.initVerbose \ninitVerbose \n\n Setting from environment variable \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq_log_verbose\u0022\u003ETASKSEQ_LOG_VERBOSE\u003C/a\u003E, which,\n when set, enables (very) verbose printing of flow and state\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-internal.html#moveNextRef","title":"Internal.moveNextRef","content":"Internal.moveNextRef \nmoveNextRef \n Call MoveNext on an IAsyncStateMachine by reference","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-internal.html#raiseNotImpl","title":"Internal.raiseNotImpl","content":"Internal.raiseNotImpl \nraiseNotImpl \n F# requires that we implement interfaces even on an abstract class.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-lowpriority.html","title":"LowPriority","content":"LowPriority \n\n Contains low priority extension methods for the main builder class for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n The \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-lowpriority.html\u0022\u003ELowPriority\u003C/a\u003E, \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html\u0022\u003EMediumPriority\u003C/a\u003E and \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-highpriority.html\u0022\u003EHighPriority\u003C/a\u003E modules are not meant to be\n accessed directly from user code. They solely serve to disambiguate overload resolution inside the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n \nLowPriority.Bind \nBind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-lowpriority.html#Bind","title":"LowPriority.Bind","content":"LowPriority.Bind \nBind \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html","title":"MediumPriority","content":"MediumPriority \n\n Contains low priority extension methods for the main builder class for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n The \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-lowpriority.html\u0022\u003ELowPriority\u003C/a\u003E, \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html\u0022\u003EMediumPriority\u003C/a\u003E and \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-highpriority.html\u0022\u003EHighPriority\u003C/a\u003E modules are not meant to be\n accessed directly from user code. They solely serve to disambiguate overload resolution inside the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n \nMediumPriority.Using \nUsing \nMediumPriority.For \nFor \nMediumPriority.YieldFrom \nYieldFrom \nMediumPriority.For \nFor \nMediumPriority.YieldFrom \nYieldFrom","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html#Using","title":"MediumPriority.Using","content":"MediumPriority.Using \nUsing \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html#For","title":"MediumPriority.For","content":"MediumPriority.For \nFor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html#YieldFrom","title":"MediumPriority.YieldFrom","content":"MediumPriority.YieldFrom \nYieldFrom \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html#For","title":"MediumPriority.For","content":"MediumPriority.For \nFor \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-mediumpriority.html#YieldFrom","title":"MediumPriority.YieldFrom","content":"MediumPriority.YieldFrom \nYieldFrom \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html","title":"Task","content":"Task \n \nTask.fromResult \nfromResult \nTask.ofAsync \nofAsync \nTask.ofTask \nofTask \nTask.apply \napply \nTask.toAsync \ntoAsync \nTask.toValueTask \ntoValueTask \nTask.ofValueTask \nofValueTask \nTask.ignore \nignore \nTask.map \nmap \nTask.bind \nbind","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#fromResult","title":"Task.fromResult","content":"Task.fromResult \nfromResult \n Creates a Task\u003C\u0027U\u003E that\u0027s completed successfully with the specified result.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#ofAsync","title":"Task.ofAsync","content":"Task.ofAsync \nofAsync \n Starts the \u0060Async\u003C\u0027T\u003E\u0060 computation, returning the associated \u0060Task\u003C\u0027T\u003E\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#ofTask","title":"Task.ofTask","content":"Task.ofTask \nofTask \n Convert a non-generic Task into a Task\u003Cunit\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#apply","title":"Task.apply","content":"Task.apply \napply \n Convert a plain function into a task-returning function","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#toAsync","title":"Task.toAsync","content":"Task.toAsync \ntoAsync \n Convert a Task\u003C\u0027T\u003E into an Async\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#toValueTask","title":"Task.toValueTask","content":"Task.toValueTask \ntoValueTask \n Convert a Task\u003C\u0027T\u003E into a ValueTask\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#ofValueTask","title":"Task.ofValueTask","content":"Task.ofValueTask \nofValueTask \n\n Convert a ValueTask\u003C\u0027T\u003E to a Task\u003C\u0027T\u003E. For a non-generic ValueTask,\n consider: \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EmyValueTask |\u0026gt; Task.ofValueTask |\u0026gt; Task.ofTask\u003C/span\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#ignore","title":"Task.ignore","content":"Task.ignore \nignore \n Convert a Task\u003C\u0027T\u003E into a non-generic Task, ignoring the result","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#map","title":"Task.map","content":"Task.map \nmap \n Map a Task\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html#bind","title":"Task.bind","content":"Task.bind \nbind \n Bind a Task\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskextensions.html","title":"TaskExtensions","content":"TaskExtensions \n \nTaskExtensions.For \nFor","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskextensions.html#For","title":"TaskExtensions.For","content":"TaskExtensions.For \nFor \n\n Inside \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/task\u0022\u003Etask\u003C/a\u003E, iterate over all values of a \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuildermodule.html","title":"TaskSeqBuilder","content":"TaskSeqBuilder \n \nTaskSeqBuilder.taskSeq \ntaskSeq","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuildermodule.html#taskSeq","title":"TaskSeqBuilder.taskSeq","content":"TaskSeqBuilder.taskSeq \ntaskSeq \n\n Builds an asynchronous task sequence based on \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E using computation expression syntax.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamicbuildermodule.html","title":"TaskSeqDynamicBuilder","content":"TaskSeqDynamicBuilder \n \nTaskSeqDynamicBuilder.taskSeqDynamic \ntaskSeqDynamic","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamicbuildermodule.html#taskSeqDynamic","title":"TaskSeqDynamicBuilder.taskSeqDynamic","content":"TaskSeqDynamicBuilder.taskSeqDynamic \ntaskSeqDynamic \n Builds an asynchronous task sequence, with a dynamic resumable code fallback for scenarios\n where the F# compiler cannot generate static resumable code (e.g., in F# Interactive / FSI).","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions.html","title":"TaskSeqExtensions","content":"TaskSeqExtensions \n \nTaskSeqExtensions.TaskSeq \nTaskSeq","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html","title":"TaskSeq","content":"TaskSeq \n \nTaskSeq.empty \nempty \nTaskSeq.sum \nsum \nTaskSeq.sumBy \nsumBy \nTaskSeq.sumByAsync \nsumByAsync \nTaskSeq.average \naverage \nTaskSeq.averageBy \naverageBy \nTaskSeq.averageByAsync \naverageByAsync","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#empty","title":"TaskSeq.empty","content":"TaskSeq.empty \nempty \n Initialize an empty task sequence.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#sum","title":"TaskSeq.sum","content":"TaskSeq.sum \nsum \n\n Returns the sum of all elements of the task sequence. The elements must support the \u003Ccode\u003E\u002B\u003C/code\u003E operator,\n which is the case for all built-in numeric types. For sequences with a projection, use \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.sumby\u0022\u003EsumBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#sumBy","title":"TaskSeq.sumBy","content":"TaskSeq.sumBy \nsumBy \n\n Returns the sum of the results generated by applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E function to each element\n of the task sequence. The result type must support the \u003Ccode\u003E\u002B\u003C/code\u003E operator, which is the case for all built-in numeric types.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.sumbyasync\u0022\u003EsumByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#sumByAsync","title":"TaskSeq.sumByAsync","content":"TaskSeq.sumByAsync \nsumByAsync \n\n Returns the sum of the results generated by applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E function to\n each element of the task sequence. The result type must support the \u003Ccode\u003E\u002B\u003C/code\u003E operator, which is the case for all\n built-in numeric types.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.sumby\u0022\u003EsumBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#average","title":"TaskSeq.average","content":"TaskSeq.average \naverage \n\n Returns the average of all elements of the task sequence. The elements must support the \u003Ccode\u003E\u002B\u003C/code\u003E operator\n and \u003Ccode\u003EDivideByInt\u003C/code\u003E, which is the case for all built-in F# floating-point types.\n For sequences with a projection, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.averageby\u0022\u003EaverageBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#averageBy","title":"TaskSeq.averageBy","content":"TaskSeq.averageBy \naverageBy \n\n Returns the average of the results generated by applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E function to each element\n of the task sequence. The result type must support the \u003Ccode\u003E\u002B\u003C/code\u003E operator and \u003Ccode\u003EDivideByInt\u003C/code\u003E, which is the case\n for all built-in F# floating-point types.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.averagebyasync\u0022\u003EaverageByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqextensions-taskseq.html#averageByAsync","title":"TaskSeq.averageByAsync","content":"TaskSeq.averageByAsync \naverageByAsync \n\n Returns the average of the results generated by applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E function to\n each element of the task sequence. The result type must support the \u003Ccode\u003E\u002B\u003C/code\u003E operator and \u003Ccode\u003EDivideByInt\u003C/code\u003E, which\n is the case for all built-in F# floating-point types.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.averageby\u0022\u003EaverageBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html","title":"ValueTask","content":"ValueTask \n \nValueTask.False \nFalse \nValueTask.True \nTrue \nValueTask.fromResult \nfromResult \nValueTask.FromResult \nFromResult \nValueTask.ofSource \nofSource \nValueTask.ofIValueTaskSource \nofIValueTaskSource \nValueTask.ofTask \nofTask \nValueTask.ignore \nignore","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#False","title":"ValueTask.False","content":"ValueTask.False \nFalse \n A successfully completed ValueTask of boolean that has the value false.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#True","title":"ValueTask.True","content":"ValueTask.True \nTrue \n A successfully completed ValueTask of boolean that has the value true.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#fromResult","title":"ValueTask.fromResult","content":"ValueTask.fromResult \nfromResult \n Creates a ValueTask with the supplied result of the successful operation.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#FromResult","title":"ValueTask.FromResult","content":"ValueTask.FromResult \nFromResult \n\n The function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EFromResult\u003C/span\u003E is deprecated since version 0.4.0,\n please use \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EfromResult\u003C/span\u003E in its stead. See \u003Ca href=\u0022https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-valuetask-fromresult\u0022\u003EfromResult\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#ofSource","title":"ValueTask.ofSource","content":"ValueTask.ofSource \nofSource \n\n Initializes a new instance of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html\u0022\u003EValueTask\u003C/a\u003E with an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/ivaluetasksource\u0022\u003EIValueTaskSource\u003C/a\u003E\n representing its operation.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#ofIValueTaskSource","title":"ValueTask.ofIValueTaskSource","content":"ValueTask.ofIValueTaskSource \nofIValueTaskSource \n\n The function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EofIValueTaskSource\u003C/span\u003E is deprecated since version 0.4.0,\n please use \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EofSource\u003C/span\u003E in its stead. See \u003Ca href=\u0022https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-valuetask-ofsource\u0022\u003EofSource\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#ofTask","title":"ValueTask.ofTask","content":"ValueTask.ofTask \nofTask \n Creates a ValueTask from a Task\u003C\u0027T\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetask.html#ignore","title":"ValueTask.ignore","content":"ValueTask.ignore \nignore \n Convert a ValueTask\u003C\u0027T\u003E into a non-generic ValueTask, ignoring the result","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetaskextensions.html","title":"ValueTaskExtensions","content":"ValueTaskExtensions \n \nValueTaskExtensions.CompletedTask \nCompletedTask","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-valuetaskextensions.html#CompletedTask","title":"ValueTaskExtensions.CompletedTask","content":"ValueTaskExtensions.CompletedTask \nCompletedTask \n (Extension member) Gets a ValueTask that has already completed successfully.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-debug.html","title":"Debug","content":"Debug \n \nDebug.logInfo \nlogInfo \nDebug.logInfo \nlogInfo \nDebug.verbose \nverbose","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-debug.html#logInfo","title":"Debug.logInfo","content":"Debug.logInfo \nlogInfo \n Log to stdout in DEBUG builds only","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-debug.html#logInfo","title":"Debug.logInfo","content":"Debug.logInfo \nlogInfo \n Log to stdout in DEBUG builds only","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-debug.html#verbose","title":"Debug.verbose","content":"Debug.verbose \nverbose \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-resumabletsc-1.html","title":"ResumableTSC\u003C\u0027T\u003E","content":"ResumableTSC\u003C\u0027T\u003E \n TaskSeqCode type alias of ResumableCode delegate type, specially recognized by the F# compiler","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html","title":"TaskSeq","content":"TaskSeq \n \nTaskSeq.append \nappend \nTaskSeq.appendSeq \nappendSeq \nTaskSeq.box \nbox \nTaskSeq.cast \ncast \nTaskSeq.choose \nchoose \nTaskSeq.chooseAsync \nchooseAsync \nTaskSeq.chooseV \nchooseV \nTaskSeq.chooseVAsync \nchooseVAsync \nTaskSeq.chunkBy \nchunkBy \nTaskSeq.chunkByAsync \nchunkByAsync \nTaskSeq.chunkBySize \nchunkBySize \nTaskSeq.collect \ncollect \nTaskSeq.collectAsync \ncollectAsync \nTaskSeq.collectSeq \ncollectSeq \nTaskSeq.collectSeqAsync \ncollectSeqAsync \nTaskSeq.compareWith \ncompareWith \nTaskSeq.compareWithAsync \ncompareWithAsync \nTaskSeq.concat \nconcat \nTaskSeq.concat \nconcat \nTaskSeq.concat \nconcat \nTaskSeq.concat \nconcat \nTaskSeq.concat \nconcat \nTaskSeq.contains \ncontains \nTaskSeq.countBy \ncountBy \nTaskSeq.countByAsync \ncountByAsync \nTaskSeq.delay \ndelay \nTaskSeq.distinct \ndistinct \nTaskSeq.distinctBy \ndistinctBy \nTaskSeq.distinctByAsync \ndistinctByAsync \nTaskSeq.distinctUntilChanged \ndistinctUntilChanged \nTaskSeq.distinctUntilChangedWith \ndistinctUntilChangedWith \nTaskSeq.distinctUntilChangedWithAsync \ndistinctUntilChangedWithAsync \nTaskSeq.drop \ndrop \nTaskSeq.exactlyOne \nexactlyOne \nTaskSeq.except \nexcept \nTaskSeq.exceptOfSeq \nexceptOfSeq \nTaskSeq.exists \nexists \nTaskSeq.existsAsync \nexistsAsync \nTaskSeq.filter \nfilter \nTaskSeq.filterAsync \nfilterAsync \nTaskSeq.find \nfind \nTaskSeq.findAsync \nfindAsync \nTaskSeq.findIndex \nfindIndex \nTaskSeq.findIndexAsync \nfindIndexAsync \nTaskSeq.firstOrDefault \nfirstOrDefault \nTaskSeq.fold \nfold \nTaskSeq.foldAsync \nfoldAsync \nTaskSeq.foldWhile \nfoldWhile \nTaskSeq.foldWhileAsync \nfoldWhileAsync \nTaskSeq.forall \nforall \nTaskSeq.forallAsync \nforallAsync \nTaskSeq.groupBy \ngroupBy \nTaskSeq.groupByAsync \ngroupByAsync \nTaskSeq.head \nhead \nTaskSeq.indexed \nindexed \nTaskSeq.init \ninit \nTaskSeq.initAsync \ninitAsync \nTaskSeq.initInfinite \ninitInfinite \nTaskSeq.initInfiniteAsync \ninitInfiniteAsync \nTaskSeq.insertAt \ninsertAt \nTaskSeq.insertManyAt \ninsertManyAt \nTaskSeq.isEmpty \nisEmpty \nTaskSeq.item \nitem \nTaskSeq.iter \niter \nTaskSeq.iterAsync \niterAsync \nTaskSeq.iteri \niteri \nTaskSeq.iteriAsync \niteriAsync \nTaskSeq.last \nlast \nTaskSeq.lastOrDefault \nlastOrDefault \nTaskSeq.length \nlength \nTaskSeq.lengthBy \nlengthBy \nTaskSeq.lengthByAsync \nlengthByAsync \nTaskSeq.lengthOrMax \nlengthOrMax \nTaskSeq.map \nmap \nTaskSeq.mapAsync \nmapAsync \nTaskSeq.mapFold \nmapFold \nTaskSeq.mapFoldAsync \nmapFoldAsync \nTaskSeq.mapi \nmapi \nTaskSeq.mapiAsync \nmapiAsync \nTaskSeq.max \nmax \nTaskSeq.maxBy \nmaxBy \nTaskSeq.maxByAsync \nmaxByAsync \nTaskSeq.min \nmin \nTaskSeq.minBy \nminBy \nTaskSeq.minByAsync \nminByAsync \nTaskSeq.ofArray \nofArray \nTaskSeq.ofAsyncArray \nofAsyncArray \nTaskSeq.ofAsyncList \nofAsyncList \nTaskSeq.ofAsyncSeq \nofAsyncSeq \nTaskSeq.ofChannel \nofChannel \nTaskSeq.ofList \nofList \nTaskSeq.ofResizeArray \nofResizeArray \nTaskSeq.ofSeq \nofSeq \nTaskSeq.ofTaskArray \nofTaskArray \nTaskSeq.ofTaskList \nofTaskList \nTaskSeq.ofTaskSeq \nofTaskSeq \nTaskSeq.pairwise \npairwise \nTaskSeq.partition \npartition \nTaskSeq.partitionAsync \npartitionAsync \nTaskSeq.pick \npick \nTaskSeq.pickAsync \npickAsync \nTaskSeq.prependSeq \nprependSeq \nTaskSeq.reduce \nreduce \nTaskSeq.reduceAsync \nreduceAsync \nTaskSeq.removeAt \nremoveAt \nTaskSeq.removeManyAt \nremoveManyAt \nTaskSeq.replicate \nreplicate \nTaskSeq.replicateInfinite \nreplicateInfinite \nTaskSeq.replicateInfiniteAsync \nreplicateInfiniteAsync \nTaskSeq.replicateUntilNoneAsync \nreplicateUntilNoneAsync \nTaskSeq.scan \nscan \nTaskSeq.scanAsync \nscanAsync \nTaskSeq.singleton \nsingleton \nTaskSeq.skip \nskip \nTaskSeq.skipWhile \nskipWhile \nTaskSeq.skipWhileAsync \nskipWhileAsync \nTaskSeq.skipWhileInclusive \nskipWhileInclusive \nTaskSeq.skipWhileInclusiveAsync \nskipWhileInclusiveAsync \nTaskSeq.splitAt \nsplitAt \nTaskSeq.tail \ntail \nTaskSeq.take \ntake \nTaskSeq.takeWhile \ntakeWhile \nTaskSeq.takeWhileAsync \ntakeWhileAsync \nTaskSeq.takeWhileInclusive \ntakeWhileInclusive \nTaskSeq.takeWhileInclusiveAsync \ntakeWhileInclusiveAsync \nTaskSeq.threadState \nthreadState \nTaskSeq.threadStateAsync \nthreadStateAsync \nTaskSeq.toArray \ntoArray \nTaskSeq.toArrayAsync \ntoArrayAsync \nTaskSeq.toChannelAsync \ntoChannelAsync \nTaskSeq.toIListAsync \ntoIListAsync \nTaskSeq.toList \ntoList \nTaskSeq.toListAsync \ntoListAsync \nTaskSeq.toResizeArrayAsync \ntoResizeArrayAsync \nTaskSeq.toSeq \ntoSeq \nTaskSeq.truncate \ntruncate \nTaskSeq.tryExactlyOne \ntryExactlyOne \nTaskSeq.tryFind \ntryFind \nTaskSeq.tryFindAsync \ntryFindAsync \nTaskSeq.tryFindIndex \ntryFindIndex \nTaskSeq.tryFindIndexAsync \ntryFindIndexAsync \nTaskSeq.tryHead \ntryHead \nTaskSeq.tryItem \ntryItem \nTaskSeq.tryLast \ntryLast \nTaskSeq.tryMax \ntryMax \nTaskSeq.tryMin \ntryMin \nTaskSeq.tryPick \ntryPick \nTaskSeq.tryPickAsync \ntryPickAsync \nTaskSeq.tryTail \ntryTail \nTaskSeq.unbox \nunbox \nTaskSeq.unfold \nunfold \nTaskSeq.unfoldAsync \nunfoldAsync \nTaskSeq.updateAt \nupdateAt \nTaskSeq.where \nwhere \nTaskSeq.whereAsync \nwhereAsync \nTaskSeq.windowed \nwindowed \nTaskSeq.withCancellation \nwithCancellation \nTaskSeq.zip \nzip \nTaskSeq.zip3 \nzip3 \nTaskSeq.zipWith \nzipWith \nTaskSeq.zipWith3 \nzipWith3 \nTaskSeq.zipWithAsync \nzipWithAsync \nTaskSeq.zipWithAsync3 \nzipWithAsync3","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#append","title":"TaskSeq.append","content":"TaskSeq.append \nappend \n\n Concatenates task sequences \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource1\u003C/span\u003E and \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource2\u003C/span\u003E in order as a single\n task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#appendSeq","title":"TaskSeq.appendSeq","content":"TaskSeq.appendSeq \nappendSeq \n\n Concatenates a task sequence \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource1\u003C/span\u003E with a (non-async) F# \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/seq\u0022\u003Eseq\u003C/a\u003E in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource2\u003C/span\u003E\n and returns a single task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#box","title":"TaskSeq.box","content":"TaskSeq.box \nbox \n\n Views each item in the input task sequence as \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/obj\u0022\u003Eobj\u003C/a\u003E, boxing value types.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#cast","title":"TaskSeq.cast","content":"TaskSeq.cast \ncast \n\n Casts each item in the untyped input task sequence. If the input sequence contains value types\n it is recommended to consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.unbox\u0022\u003Eunbox\u003C/a\u003E instead.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#choose","title":"TaskSeq.choose","content":"TaskSeq.choose \nchoose \n\n Applies the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to each element of the task sequence. Returns\n a sequence comprised of the results where the function returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome(x)\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.chooseasync\u0022\u003EchooseAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#chooseAsync","title":"TaskSeq.chooseAsync","content":"TaskSeq.chooseAsync \nchooseAsync \n\n Applies the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to each element of the task sequence.\n Returns a sequence comprised of the results where the function returns a \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/task\u0022\u003Etask\u003C/a\u003E result\n of \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome(x)\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.choose\u0022\u003Echoose\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#chooseV","title":"TaskSeq.chooseV","content":"TaskSeq.chooseV \nchooseV \n\n Applies the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to each element of the task sequence. Returns\n a sequence comprised of the results where the function returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/valuesome\u0022\u003EValueSome(x)\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.choosevasync\u0022\u003EchooseVAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#chooseVAsync","title":"TaskSeq.chooseVAsync","content":"TaskSeq.chooseVAsync \nchooseVAsync \n\n Applies the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to each element of the task sequence.\n Returns a sequence comprised of the results where the function returns a \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/task\u0022\u003Etask\u003C/a\u003E result\n of \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/valuesome\u0022\u003EValueSome(x)\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.choosev\u0022\u003EchooseV\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#chunkBy","title":"TaskSeq.chunkBy","content":"TaskSeq.chunkBy \nchunkBy \n\n Groups consecutive elements of the task sequence by a key derived from each element using\n \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E, yielding \u003Ccode\u003E(key, elements[])\u003C/code\u003E pairs. A new group is started\n each time the key changes from one element to the next. Unlike \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.groupby\u0022\u003EgroupBy\u003C/a\u003E,\n only \u003Cem\u003Econsecutive\u003C/em\u003E elements with the same key are merged.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.chunkbyasync\u0022\u003EchunkByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#chunkByAsync","title":"TaskSeq.chunkByAsync","content":"TaskSeq.chunkByAsync \nchunkByAsync \n\n Groups consecutive elements of the task sequence by a key derived from each element using the\n asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E, yielding \u003Ccode\u003E(key, elements[])\u003C/code\u003E pairs.\n A new group is started each time the key changes from one element to the next.\n Unlike \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.groupbyasync\u0022\u003EgroupByAsync\u003C/a\u003E, only \u003Cem\u003Econsecutive\u003C/em\u003E elements with the same key are merged.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E function is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.chunkby\u0022\u003EchunkBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#chunkBySize","title":"TaskSeq.chunkBySize","content":"TaskSeq.chunkBySize \nchunkBySize \n\n Divides the input task sequence into chunks of size at most \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EchunkSize\u003C/span\u003E.\n The last chunk may be smaller than \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EchunkSize\u003C/span\u003E if the source sequence does not divide evenly.\n Returns an empty task sequence when the source is empty.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EchunkSize\u003C/span\u003E is not positive, an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.argumentexception\u0022\u003EArgumentException\u003C/a\u003E is raised immediately\n (before the sequence is evaluated).\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#collect","title":"TaskSeq.collect","content":"TaskSeq.collect \ncollect \n\n Builds a new task sequence whose elements are the results of applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, and concatenating the\n returned task sequences.\n The given function will be applied as elements are pulled using async enumerators retrieved from the\n input task sequence.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.collectasync\u0022\u003EcollectAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#collectAsync","title":"TaskSeq.collectAsync","content":"TaskSeq.collectAsync \ncollectAsync \n\n Builds a new task sequence whose elements are the results of applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, and concatenating the\n returned task sequences.\n The given function will be applied as elements are pulled using async enumerators retrieved from the\n input task sequence.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.collect\u0022\u003Ecollect\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#collectSeq","title":"TaskSeq.collectSeq","content":"TaskSeq.collectSeq \ncollectSeq \n\n Builds a new task sequence whose elements are the results of applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, and concatenating the\n returned regular F# sequences.\n The given function will be applied as elements are pulled using async enumerators retrieved from the\n input task sequence.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.collectseqasync\u0022\u003EcollectSeqAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#collectSeqAsync","title":"TaskSeq.collectSeqAsync","content":"TaskSeq.collectSeqAsync \ncollectSeqAsync \n\n Builds a new task sequence whose elements are the results of applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, and concatenating the\n returned regular F# sequences.\n The given function will be applied as elements are pulled using async enumerators retrieved from the\n input task sequence.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ebinder\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.collectseqasync\u0022\u003EcollectSeqAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#compareWith","title":"TaskSeq.compareWith","content":"TaskSeq.compareWith \ncompareWith \n\n Applies a comparer function to corresponding elements of two task sequences, returning the result of the\n first comparison that is non-zero, or zero if all compared elements are equal. The sequences are compared\n element by element until one of them is exhausted; if one sequence is shorter than the other, it is considered\n less than the longer sequence.\n If the comparer function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecomparer\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.comparewithasync\u0022\u003EcompareWithAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#compareWithAsync","title":"TaskSeq.compareWithAsync","content":"TaskSeq.compareWithAsync \ncompareWithAsync \n\n Applies an asynchronous comparer function to corresponding elements of two task sequences, returning the result of\n the first comparison that is non-zero, or zero if all compared elements are equal. The sequences are compared\n element by element until one of them is exhausted; if one sequence is shorter than the other, it is considered\n less than the longer sequence.\n If the comparer function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecomparer\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.comparewith\u0022\u003EcompareWith\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#concat","title":"TaskSeq.concat","content":"TaskSeq.concat \nconcat \n\n Combines the given task sequence of resizable arrays and concatenates them end-to-end, to form a\n new flattened, single task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#concat","title":"TaskSeq.concat","content":"TaskSeq.concat \nconcat \n\n Combines the given task sequence of lists and concatenates them end-to-end, to form a\n new flattened, single task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#concat","title":"TaskSeq.concat","content":"TaskSeq.concat \nconcat \n\n Combines the given task sequence of arrays and concatenates them end-to-end, to form a\n new flattened, single task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#concat","title":"TaskSeq.concat","content":"TaskSeq.concat \nconcat \n\n Combines the given task sequence of sequences and concatenates them end-to-end, to form a\n new flattened, single task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#concat","title":"TaskSeq.concat","content":"TaskSeq.concat \nconcat \n\n Combines the given task sequence of task sequences and concatenates them end-to-end, to form a\n new flattened, single task sequence, like \u003Cspan class=\u0022fsdocs-param-name\u0022\u003ETaskSeq.collect id\u003C/span\u003E. Each task sequence is\n awaited and consumed in full, before the next one is iterated.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#contains","title":"TaskSeq.contains","content":"TaskSeq.contains \ncontains \n\n Tests if the sequence contains the specified element. Returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E\n if \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E contains the specified element; \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E\n otherwise. The input task sequence is only evaluated until the first element that matches the value.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#countBy","title":"TaskSeq.countBy","content":"TaskSeq.countBy \ncountBy \n\n Applies a key-generating function to each element of a task sequence and returns a task with an array of\n unique keys and their element counts, in order of first occurrence of each key.\n \n\n This function consumes the entire source task sequence before returning.\n If the projection function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is asynchronous, consider using\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.countbyasync\u0022\u003EcountByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#countByAsync","title":"TaskSeq.countByAsync","content":"TaskSeq.countByAsync \ncountByAsync \n\n Applies an asynchronous key-generating function to each element of a task sequence and returns a task with\n an array of unique keys and their element counts, in order of first occurrence of each key.\n \n\n This function consumes the entire source task sequence before returning.\n If the projection function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is synchronous, consider using\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.countby\u0022\u003EcountBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#delay","title":"TaskSeq.delay","content":"TaskSeq.delay \ndelay \n\n Returns a task sequence that is given by the delayed specification of a task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#distinct","title":"TaskSeq.distinct","content":"TaskSeq.distinct \ndistinct \n\n Returns a new task sequence that contains no duplicate entries, using generic hash and equality comparisons.\n If an element occurs multiple times in the sequence, only the first occurrence is returned.\n \n\n This function iterates the whole sequence and buffers all unique elements in a hash set, so it should not\n be used on potentially infinite sequences.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#distinctBy","title":"TaskSeq.distinctBy","content":"TaskSeq.distinctBy \ndistinctBy \n\n Returns a new task sequence that contains no duplicate entries according to the generic hash and equality\n comparisons on the keys returned by the given projection function.\n If two elements have the same projected key, only the first occurrence is returned.\n If the projection function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.distinctbyasync\u0022\u003EdistinctByAsync\u003C/a\u003E.\n \n\n This function iterates the whole sequence and buffers all unique keys in a hash set, so it should not\n be used on potentially infinite sequences.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#distinctByAsync","title":"TaskSeq.distinctByAsync","content":"TaskSeq.distinctByAsync \ndistinctByAsync \n\n Returns a new task sequence that contains no duplicate entries according to the generic hash and equality\n comparisons on the keys returned by the given asynchronous projection function.\n If two elements have the same projected key, only the first occurrence is returned.\n If the projection function is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.distinctby\u0022\u003EdistinctBy\u003C/a\u003E.\n \n\n This function iterates the whole sequence and buffers all unique keys in a hash set, so it should not\n be used on potentially infinite sequences.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#distinctUntilChanged","title":"TaskSeq.distinctUntilChanged","content":"TaskSeq.distinctUntilChanged \ndistinctUntilChanged \n\n Returns a new task sequence without consecutive duplicate elements.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#distinctUntilChangedWith","title":"TaskSeq.distinctUntilChangedWith","content":"TaskSeq.distinctUntilChangedWith \ndistinctUntilChangedWith \n\n Returns a new task sequence without consecutive duplicate elements, using the supplied \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecomparer\u003C/span\u003E\n to determine equality of consecutive elements. The comparer returns if two elements are\n considered equal (and thus the second should be skipped).\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#distinctUntilChangedWithAsync","title":"TaskSeq.distinctUntilChangedWithAsync","content":"TaskSeq.distinctUntilChangedWithAsync \ndistinctUntilChangedWithAsync \n\n Returns a new task sequence without consecutive duplicate elements, using the supplied async \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecomparer\u003C/span\u003E\n to determine equality of consecutive elements. The comparer returns if two elements are\n considered equal (and thus the second should be skipped).\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#drop","title":"TaskSeq.drop","content":"TaskSeq.drop \ndrop \n\n Returns a task sequence that, when iterated, drops at most \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E elements of the\n underlying sequence, and then returns the remainder of the elements, if any.\n See \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skip\u0022\u003Eskip\u003C/a\u003E for a version that raises an exception if there\n are not enough elements. See also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.truncate\u0022\u003Etruncate\u003C/a\u003E for the inverse of this operation.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#exactlyOne","title":"TaskSeq.exactlyOne","content":"TaskSeq.exactlyOne \nexactlyOne \n\n Returns the only element of the task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#except","title":"TaskSeq.except","content":"TaskSeq.except \nexcept \n\n Returns a new task sequence with the distinct elements of the second task sequence which do not appear in the\n \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EitemsToExclude\u003C/span\u003E sequence, using generic hash and equality comparisons to compare values.\n \n\n Note that this function returns a task sequence that digests the whole of the first input task sequence as soon as\n the resulting task sequence first gets awaited or iterated. As a result this function should not be used with\n large or infinite sequences in the first parameter. The function makes no assumption on the ordering of the first input\n sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#exceptOfSeq","title":"TaskSeq.exceptOfSeq","content":"TaskSeq.exceptOfSeq \nexceptOfSeq \n\n Returns a new task sequence with the distinct elements of the second task sequence which do not appear in the\n \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EitemsToExclude\u003C/span\u003E sequence, using generic hash and equality comparisons to compare values.\n \n\n Note that this function returns a task sequence that digests the whole of the first input task sequence as soon as\n the result sequence first gets awaited or iterated. As a result this function should not be used with\n large or infinite sequences in the first parameter. The function makes no assumption on the ordering of the first input\n sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#exists","title":"TaskSeq.exists","content":"TaskSeq.exists \nexists \n\n Tests if any element of the task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E satisfies the given \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E. The function\n is applied to the elements of the input task sequence. If any application returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E then the overall result\n is \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E and no further elements are evaluated and tested.\n Otherwise, \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E is returned.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#existsAsync","title":"TaskSeq.existsAsync","content":"TaskSeq.existsAsync \nexistsAsync \n\n Tests if any element of the task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E satisfies the given asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E.\n The function is applied to the elements of the input task sequence. If any application returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E then the overall result\n is \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E and no further elements are evaluated and tested.\n Otherwise, \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E is returned.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#filter","title":"TaskSeq.filter","content":"TaskSeq.filter \nfilter \n\n Returns a new task sequence containing only the elements of the collection\n for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.filterasync\u0022\u003EfilterAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#filterAsync","title":"TaskSeq.filterAsync","content":"TaskSeq.filterAsync \nfilterAsync \n\n Returns a new task sequence containing only the elements of the input sequence\n for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.filter\u0022\u003Efilter\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#find","title":"TaskSeq.find","content":"TaskSeq.find \nfind \n\n Returns the first element for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n Throws an exception if none is found.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.findasync\u0022\u003EfindAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#findAsync","title":"TaskSeq.findAsync","content":"TaskSeq.findAsync \nfindAsync \n\n Returns the first element for which the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n Throws an exception if none is found.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.find\u0022\u003Efind\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#findIndex","title":"TaskSeq.findIndex","content":"TaskSeq.findIndex \nfindIndex \n\n Returns the index, starting from zero, of the first element for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E\n returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.findindexasync\u0022\u003EfindIndexAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#findIndexAsync","title":"TaskSeq.findIndexAsync","content":"TaskSeq.findIndexAsync \nfindIndexAsync \n\n Returns the index, starting from zero, of the first element for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E\n returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.findindex\u0022\u003EfindIndex\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#firstOrDefault","title":"TaskSeq.firstOrDefault","content":"TaskSeq.firstOrDefault \nfirstOrDefault \n\n Returns the first element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E,\n or \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EdefaultValue\u003C/span\u003E if the sequence is empty.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#fold","title":"TaskSeq.fold","content":"TaskSeq.fold \nfold \n then computes\u003Cparamref name=\u0022f (... (f s i0)...) iN\u0022 /\u003E.\n If the accumulator function \u003Cparamref name=\u0022folder\u0022 /\u003E is asynchronous, consider using \u003Csee cref=\u0022TaskSeq.foldAsync\u0022 /\u003E.\n argument of type \u003Cparamref name=\u0022\u0027State\u0022 /\u003E through the computation. If the input function is \u003Cparamref name=\u0022f\u0022 /\u003E and the elements are \u003Cparamref name=\u0022i0...iN\u0022 /\u003E\n then computes \u003Cparamref name=\u0022f (... (f s i0)...) iN\u0022 /\u003E.\n If the accumulator function \u003Cparamref name=\u0022folder\u0022 /\u003E is asynchronous, consider using \u003Csee cref=\u0022TaskSeq.foldAsync\u0022 /\u003E.\n \u003C/summary\u003E\n\n \u003Cparam name=\u0022folder\u0022\u003EA function that updates the state with each element from the sequence.\u003C/param\u003E\n \u003Cparam name=\u0022state\u0022\u003EThe initial state.\u003C/param\u003E\n \u003Cparam name=\u0022source\u0022\u003EThe input sequence.\u003C/param\u003E\n \u003Creturns\u003EThe state object after the folding function is applied to each element of the sequence.\u003C/returns\u003E\n \u003Cexception cref=\u0022T:ArgumentNullException\u0022\u003EThrown when the input task sequence is null.\u003C/exception\u003E","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#foldAsync","title":"TaskSeq.foldAsync","content":"TaskSeq.foldAsync \nfoldAsync \n\n Applies the asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element in the task sequence, threading an accumulator\n argument of type \u003Cspan class=\u0022fsdocs-param-name\u0022\u003E\u0026#39;State\u003C/span\u003E through the computation. If the input function is \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef\u003C/span\u003E and the elements are \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ei0...iN\u003C/span\u003E\n then computes \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef (... (f s i0)...) iN\u003C/span\u003E.\n If the accumulator function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.fold\u0022\u003Efold\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#foldWhile","title":"TaskSeq.foldWhile","content":"TaskSeq.foldWhile \nfoldWhile \n\n Applies the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element in the task sequence, threading an\n accumulator of type \u003Cspan class=\u0022fsdocs-param-name\u0022\u003E\u0026#39;State\u003C/span\u003E through the computation, for as long as\n \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ccode\u003Etrue\u003C/code\u003E. The predicate is evaluated against the current\n state and next element before that element is folded in; once it returns \u003Ccode\u003Efalse\u003C/code\u003E the element\n is not folded, iteration stops, and no further elements of the input are enumerated.\n If either function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.foldwhileasync\u0022\u003EfoldWhileAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#foldWhileAsync","title":"TaskSeq.foldWhileAsync","content":"TaskSeq.foldWhileAsync \nfoldWhileAsync \n\n Applies the asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element in the task sequence,\n threading an accumulator of type \u003Cspan class=\u0022fsdocs-param-name\u0022\u003E\u0026#39;State\u003C/span\u003E through the computation, for as long as\n the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ccode\u003Etrue\u003C/code\u003E. The predicate is evaluated\n against the current state and next element before that element is folded in; once it returns\n \u003Ccode\u003Efalse\u003C/code\u003E the element is not folded, iteration stops, and no further elements of the input are\n enumerated.\n If both functions are synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.foldwhile\u0022\u003EfoldWhile\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#forall","title":"TaskSeq.forall","content":"TaskSeq.forall \nforall \n\n Tests if all elements of the sequence satisfy the given predicate. Stops evaluating\n as soon as \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.forallasync\u0022\u003EforallAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#forallAsync","title":"TaskSeq.forallAsync","content":"TaskSeq.forallAsync \nforallAsync \n\n Tests if all elements of the sequence satisfy the given asynchronous predicate. Stops evaluating\n as soon as \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.forall\u0022\u003Eforall\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#groupBy","title":"TaskSeq.groupBy","content":"TaskSeq.groupBy \ngroupBy \n\n Applies a key-generating function to each element of a task sequence and yields a sequence of unique keys\n and arrays of all elements that have each key, in order of first occurrence of each key.\n The returned array preserves the original order of elements within each group.\n \n\n This function consumes the entire source task sequence before returning.\n If the projection function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is asynchronous, consider using\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.groupbyasync\u0022\u003EgroupByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#groupByAsync","title":"TaskSeq.groupByAsync","content":"TaskSeq.groupByAsync \ngroupByAsync \n\n Applies an asynchronous key-generating function to each element of a task sequence and yields a sequence of\n unique keys and arrays of all elements that have each key, in order of first occurrence of each key.\n The returned array preserves the original order of elements within each group.\n \n\n This function consumes the entire source task sequence before returning.\n If the projection function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is synchronous, consider using\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.groupby\u0022\u003EgroupBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#head","title":"TaskSeq.head","content":"TaskSeq.head \nhead \n\n Returns the first element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#indexed","title":"TaskSeq.indexed","content":"TaskSeq.indexed \nindexed \n\n Builds a new task sequence whose elements are the corresponding elements of the input task\n sequence \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E paired with the integer index (from 0) of each element.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#init","title":"TaskSeq.init","content":"TaskSeq.init \ninit \n\n Generates a new task sequence which, when iterated, will return successive elements by calling the given function\n with the current zero-based index, up to the given count. Each element is saved after its initialization for successive access to\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerator.current\u0022\u003ECurrent\u003C/a\u003E, which will not re-evaluate the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Einitializer\u003C/span\u003E. However,\n re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may\n be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should\n not be accessed concurrently.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#initAsync","title":"TaskSeq.initAsync","content":"TaskSeq.initAsync \ninitAsync \n\n Generates a new task sequence which, when iterated, will return successive elements by calling the given function\n with the current zero-based index, up to the given count. Each element is saved after its initialization for successive access to\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerator.current\u0022\u003ECurrent\u003C/a\u003E, which will not re-evaluate the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Einitializer\u003C/span\u003E. However,\n re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may\n be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should\n not be accessed concurrently.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#initInfinite","title":"TaskSeq.initInfinite","content":"TaskSeq.initInfinite \ninitInfinite \n\n Generates a new task sequence which, when iterated, will return successive elements by calling the given function\n with the current zero-based index, ad infinitum, or until \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/int32.maxvalue\u0022\u003EMaxValue\u003C/a\u003E is reached.\n Each element is saved after its initialization for successive access to\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerator.current\u0022\u003ECurrent\u003C/a\u003E, which will not re-evaluate the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Einitializer\u003C/span\u003E. However,\n re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may\n be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should\n not be accessed concurrently.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#initInfiniteAsync","title":"TaskSeq.initInfiniteAsync","content":"TaskSeq.initInfiniteAsync \ninitInfiniteAsync \n\n Generates a new task sequence which, when iterated, will return successive elements by calling the given function\n with the current zero-based index, ad infinitum, or until \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/int32.maxvalue\u0022\u003EMaxValue\u003C/a\u003E is reached.\n Each element is saved after its initialization for successive access to\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerator.current\u0022\u003ECurrent\u003C/a\u003E, which will not re-evaluate the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Einitializer\u003C/span\u003E. However,\n re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may\n be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should\n not be accessed concurrently.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#insertAt","title":"TaskSeq.insertAt","content":"TaskSeq.insertAt \ninsertAt \n\n Return a new task sequence with a new item inserted before the given index.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#insertManyAt","title":"TaskSeq.insertManyAt","content":"TaskSeq.insertManyAt \ninsertManyAt \n\n Return a new task sequence with the new items inserted before the given index.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#isEmpty","title":"TaskSeq.isEmpty","content":"TaskSeq.isEmpty \nisEmpty \n\n Returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E if the task sequence contains no elements, \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E otherwise.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#item","title":"TaskSeq.item","content":"TaskSeq.item \nitem \n\n Returns the nth element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E,\n or raises an exception if the sequence does not contain enough elements.\n The index is zero-based, that is, using index 0 returns the first element.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#iter","title":"TaskSeq.iter","content":"TaskSeq.iter \niter \n\n Iterates over the input task sequence, applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eaction\u003C/span\u003E function to each item.\n This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#iterAsync","title":"TaskSeq.iterAsync","content":"TaskSeq.iterAsync \niterAsync \n\n Iterates over the input task sequence, applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eaction\u003C/span\u003E function to each item.\n This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#iteri","title":"TaskSeq.iteri","content":"TaskSeq.iteri \niteri \n\n Iterates over the input task sequence, applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eaction\u003C/span\u003E function to each item,\n supplying the zero-based index as extra parameter for the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eaction\u003C/span\u003E function.\n This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#iteriAsync","title":"TaskSeq.iteriAsync","content":"TaskSeq.iteriAsync \niteriAsync \n\n Iterates over the input task sequence, applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eaction\u003C/span\u003E function to each item,\n supplying the zero-based index as extra parameter for the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eaction\u003C/span\u003E function.\n This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#last","title":"TaskSeq.last","content":"TaskSeq.last \nlast \n\n Returns the last element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#lastOrDefault","title":"TaskSeq.lastOrDefault","content":"TaskSeq.lastOrDefault \nlastOrDefault \n\n Returns the last element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E,\n or \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EdefaultValue\u003C/span\u003E if the sequence is empty.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#length","title":"TaskSeq.length","content":"TaskSeq.length \nlength \n\n Returns the length of the sequence. This operation requires the whole sequence to be evaluated and\n should not be used on potentially infinite sequences, see \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.lengthormax\u0022\u003ElengthOrMax\u003C/a\u003E for an alternative.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#lengthBy","title":"TaskSeq.lengthBy","content":"TaskSeq.lengthBy \nlengthBy \n\n Returns the length of the sequence of all items for which the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns true.\n This operation requires the whole sequence to be evaluated and should not be used on potentially infinite sequences.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.lengthbyasync\u0022\u003ElengthByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#lengthByAsync","title":"TaskSeq.lengthByAsync","content":"TaskSeq.lengthByAsync \nlengthByAsync \n\n Returns the length of the sequence of all items for which the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns true.\n This operation requires the whole sequence to be evaluated and should not be used on potentially infinite sequences.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.lengthby\u0022\u003ElengthBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#lengthOrMax","title":"TaskSeq.lengthOrMax","content":"TaskSeq.lengthOrMax \nlengthOrMax \n\n Returns the length of the sequence, or \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emax\u003C/span\u003E, whichever comes first. This operation requires the task sequence\n to be evaluated ether in full, or until \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emax\u003C/span\u003E items have been processed. Use this method instead of\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.length\u0022\u003Elength\u003C/a\u003E if you need to limit the number of items evaluated, or if the sequence is potentially infinite.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#map","title":"TaskSeq.map","content":"TaskSeq.map \nmap \n\n Builds a new task sequence whose elements are the results of applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n The given function will be applied as elements are pulled using async enumerators retrieved from the\n input task sequence.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.mapasync\u0022\u003EmapAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#mapAsync","title":"TaskSeq.mapAsync","content":"TaskSeq.mapAsync \nmapAsync \n\n Builds a new task sequence whose elements are the results of applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n The given function will be applied as elements are pulled using async enumerators retrieved from the\n input task sequence.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.map\u0022\u003Emap\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#mapFold","title":"TaskSeq.mapFold","content":"TaskSeq.mapFold \nmapFold \n\n Applies the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E to each element of the task sequence, threading an accumulator\n argument through the computation, while also generating a new mapped element for each input element.\n If the input function is \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef\u003C/span\u003E and the elements are \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ei0...iN\u003C/span\u003E, then\n computes both the mapped results \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Er0...rN\u003C/span\u003E and the final state in a single pass.\n The result is a pair of an array of mapped values and the final state.\n If the mapping function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.mapfoldasync\u0022\u003EmapFoldAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#mapFoldAsync","title":"TaskSeq.mapFoldAsync","content":"TaskSeq.mapFoldAsync \nmapFoldAsync \n\n Applies the asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E to each element of the task sequence,\n threading an accumulator argument through the computation, while also generating a new mapped element for each input element.\n If the input function is \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef\u003C/span\u003E and the elements are \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ei0...iN\u003C/span\u003E, then\n computes both the mapped results \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Er0...rN\u003C/span\u003E and the final state in a single pass.\n The result is a pair of an array of mapped values and the final state.\n If the mapping function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.mapfold\u0022\u003EmapFold\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#mapi","title":"TaskSeq.mapi","content":"TaskSeq.mapi \nmapi \n\n Builds a new task sequence whose elements are the results of applying the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, passing\n an extra zero-based index argument to the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E function.\n The given function will be applied as elements are pulled using the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/movenextasync\u0022\u003EMoveNextAsync\u003C/a\u003E\n method on async enumerators retrieved from the input task sequence.\n Does not evaluate the input sequence until requested.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#mapiAsync","title":"TaskSeq.mapiAsync","content":"TaskSeq.mapiAsync \nmapiAsync \n\n Builds a new task sequence whose elements are the results of applying the asynchronous \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E\n function to each of the elements of the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, passing\n an extra zero-based index argument to the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapper\u003C/span\u003E function.\n The given function will be applied as elements are pulled using the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/movenextasync\u0022\u003EMoveNextAsync\u003C/a\u003E\n method on async enumerators retrieved from the input task sequence.\n Does not evaluate the input sequence until requested.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#max","title":"TaskSeq.max","content":"TaskSeq.max \nmax \n\n Returns the greatest of all elements of the sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.max\u0022\u003Emax\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#maxBy","title":"TaskSeq.maxBy","content":"TaskSeq.maxBy \nmaxBy \n\n Returns the greatest of all elements of the task sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.max\u0022\u003Emax\u003C/a\u003E\n on the result of applying the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E to each element.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.maxbyasync\u0022\u003EmaxByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#maxByAsync","title":"TaskSeq.maxByAsync","content":"TaskSeq.maxByAsync \nmaxByAsync \n\n Returns the greatest of all elements of the task sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.max\u0022\u003Emax\u003C/a\u003E\n on the result of applying the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E to each element.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.maxby\u0022\u003EmaxBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#min","title":"TaskSeq.min","content":"TaskSeq.min \nmin \n\n Returns the smallest of all elements of the sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.min\u0022\u003Emin\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#minBy","title":"TaskSeq.minBy","content":"TaskSeq.minBy \nminBy \n\n Returns the smallest of all elements of the task sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.min\u0022\u003Emin\u003C/a\u003E\n on the result of applying the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E to each element.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.minbyasync\u0022\u003EminByAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#minByAsync","title":"TaskSeq.minByAsync","content":"TaskSeq.minByAsync \nminByAsync \n\n Returns the smallest of all elements of the task sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.min\u0022\u003Emin\u003C/a\u003E\n on the result of applying the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E to each element.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eprojection\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.minby\u0022\u003EminBy\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofArray","title":"TaskSeq.ofArray","content":"TaskSeq.ofArray \nofArray \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/array\u0022\u003Earray\u003C/a\u003E as a task sequence, that is, as an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofAsyncArray","title":"TaskSeq.ofAsyncArray","content":"TaskSeq.ofAsyncArray \nofAsyncArray \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/array\u0022\u003Earray\u003C/a\u003E of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html\u0022\u003EAsync\u003C/a\u003Es as a task sequence, that is, as an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. An array of asyncs is not the same as a task sequence.\n Each async computation in an array of asyncs can be run individually or in parallel, potentially\n with overlapping side effects, while a task sequence forces awaiting between the items in the sequence,\n preventing such overlap to happen.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofAsyncList","title":"TaskSeq.ofAsyncList","content":"TaskSeq.ofAsyncList \nofAsyncList \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/list\u0022\u003Elist\u003C/a\u003E of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html\u0022\u003EAsync\u003C/a\u003Es as a task sequence, that is, as an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. A list of asyncs is not the same as a task sequence.\n Each async computation in a list of asyncs can be run individually or in parallel, potentially\n with overlapping side effects, while a task sequence forces awaiting between the items in the sequence,\n preventing such overlap to happen.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofAsyncSeq","title":"TaskSeq.ofAsyncSeq","content":"TaskSeq.ofAsyncSeq \nofAsyncSeq \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/seq\u0022\u003Eseq\u003C/a\u003E of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-async.html\u0022\u003EAsync\u003C/a\u003Es as a task sequence, that is, as an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. A sequence of asyncs is not the same as a task sequence.\n Each async computation in a sequence of asyncs can be run individually or in parallel, potentially\n with overlapping side effects, while a task sequence forces awaiting between the items in the sequence,\n preventing such overlap to happen.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofChannel","title":"TaskSeq.ofChannel","content":"TaskSeq.ofChannel \nofChannel \n\n Views a \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/channelreader\u003C\u0027t\u003E\u0022\u003EChannelReader\u003C\u0027T\u003E\u003C/a\u003E as a task sequence. Elements are yielded as they\n become available; the sequence ends when the channel is completed and all buffered elements\n have been consumed.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofList","title":"TaskSeq.ofList","content":"TaskSeq.ofList \nofList \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/list\u0022\u003Elist\u003C/a\u003E as a task sequence, that is, as an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofResizeArray","title":"TaskSeq.ofResizeArray","content":"TaskSeq.ofResizeArray \nofResizeArray \n\n Views the given resizable array as a task sequence, that is, as an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofSeq","title":"TaskSeq.ofSeq","content":"TaskSeq.ofSeq \nofSeq \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/seq\u0022\u003Eseq\u003C/a\u003E as a task sequence, that is, as an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofTaskArray","title":"TaskSeq.ofTaskArray","content":"TaskSeq.ofTaskArray \nofTaskArray \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/array\u0022\u003Earray\u003C/a\u003E of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html\u0022\u003ETask\u003C/a\u003Es as a task sequence, that is, as an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. An array of tasks will typically already be hot-started,\n as a result, each task can already run and potentially out of order, or with\n overlapping side effects, while a task sequence forces awaiting between the items in the sequence,\n preventing such overlap to happen. Converting an array of tasks into a task sequence is no guarantee\n that overlapping side effects are prevented. Safe for side-effect free tasks.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofTaskList","title":"TaskSeq.ofTaskList","content":"TaskSeq.ofTaskList \nofTaskList \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/list\u0022\u003Elist\u003C/a\u003E of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html\u0022\u003ETask\u003C/a\u003Es as a task sequence, that is, as an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. A list of tasks will typically already be hot-started,\n as a result, each task can already run and potentially out of order, or with\n overlapping side effects, while a task sequence forces awaiting between the items in the sequence,\n preventing such overlap to happen. Converting a list of tasks into a task sequence is no guarantee\n that overlapping side effects are prevented. Safe for side-effect free tasks.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#ofTaskSeq","title":"TaskSeq.ofTaskSeq","content":"TaskSeq.ofTaskSeq \nofTaskSeq \n\n Views the given \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/seq\u0022\u003Eseq\u003C/a\u003E of \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-task.html\u0022\u003ETask\u003C/a\u003Es as a task sequence, that is, as an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. A sequence of tasks is not the same as a task sequence.\n Each task in a sequence of tasks can be run individually and potentially out of order, or with\n overlapping side effects, while a task sequence forces awaiting between the items in the sequence,\n preventing such overlap to happen.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#pairwise","title":"TaskSeq.pairwise","content":"TaskSeq.pairwise \npairwise \n\n Returns a task sequence of each element in the source paired with its successor.\n The sequence is empty if the source has fewer than two elements.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#partition","title":"TaskSeq.partition","content":"TaskSeq.partition \npartition \n\n Splits the task sequence into two arrays: those for which the given predicate returns \u003Ccode\u003Etrue\u003C/code\u003E,\n and those for which it returns \u003Ccode\u003Efalse\u003C/code\u003E. The relative order of elements within each partition is preserved.\n \n\n This function consumes the entire source task sequence before returning.\n If the predicate function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.partitionasync\u0022\u003EpartitionAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#partitionAsync","title":"TaskSeq.partitionAsync","content":"TaskSeq.partitionAsync \npartitionAsync \n\n Splits the task sequence into two arrays using an asynchronous predicate: those for which the predicate returns\n \u003Ccode\u003Etrue\u003C/code\u003E, and those for which it returns \u003Ccode\u003Efalse\u003C/code\u003E. The relative order of elements within each partition\n is preserved.\n \n\n This function consumes the entire source task sequence before returning.\n If the predicate function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.partition\u0022\u003Epartition\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#pick","title":"TaskSeq.pick","content":"TaskSeq.pick \npick \n\n Applies the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to successive elements, returning the first result where\n the function returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome(x)\u003C/a\u003E. Throws an exception if none is found.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.pickasync\u0022\u003EpickAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#pickAsync","title":"TaskSeq.pickAsync","content":"TaskSeq.pickAsync \npickAsync \n\n Applies the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to successive elements, returning the first result where\n the function returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome(x)\u003C/a\u003E. Throws an exception if none is found.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.pick\u0022\u003Epick\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#prependSeq","title":"TaskSeq.prependSeq","content":"TaskSeq.prependSeq \nprependSeq \n\n Concatenates a (non-async) F# \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/seq\u0022\u003Eseq\u003C/a\u003E in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource1\u003C/span\u003E with a task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource2\u003C/span\u003E\n and returns a single task sequence.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#reduce","title":"TaskSeq.reduce","content":"TaskSeq.reduce \nreduce \n\n Applies the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element of the task sequence, threading\n an accumulator argument through the computation. The first element is used as the initial state. If the input\n function is \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef\u003C/span\u003E and the elements are \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ei0...iN\u003C/span\u003E, then computes\n \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef (... (f i0 i1)...) iN\u003C/span\u003E. Raises \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.argumentexception\u0022\u003EArgumentException\u003C/a\u003E when the\n sequence is empty.\n If the accumulator function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.reduceasync\u0022\u003EreduceAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#reduceAsync","title":"TaskSeq.reduceAsync","content":"TaskSeq.reduceAsync \nreduceAsync \n\n Applies the asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element of the task sequence, threading\n an accumulator argument through the computation. The first element is used as the initial state. If the input\n function is \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef\u003C/span\u003E and the elements are \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ei0...iN\u003C/span\u003E, then computes\n \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ef (... (f i0 i1)...) iN\u003C/span\u003E. Raises \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.argumentexception\u0022\u003EArgumentException\u003C/a\u003E when the\n sequence is empty.\n If the accumulator function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.reduce\u0022\u003Ereduce\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#removeAt","title":"TaskSeq.removeAt","content":"TaskSeq.removeAt \nremoveAt \n\n Return a new task sequence with the item at the given index removed.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#removeManyAt","title":"TaskSeq.removeManyAt","content":"TaskSeq.removeManyAt \nremoveManyAt \n\n Return a new task sequence with the number of items starting at a given index removed.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E is negative or zero, no items are removed. If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eindex\u003C/span\u003E\n \u002B \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E is greater than source length, but \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eindex\u003C/span\u003E is not, then\n all items until end of sequence are removed.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#replicate","title":"TaskSeq.replicate","content":"TaskSeq.replicate \nreplicate \n\n Creates a task sequence by replicating \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Evalue\u003C/span\u003E a total of \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E times.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#replicateInfinite","title":"TaskSeq.replicateInfinite","content":"TaskSeq.replicateInfinite \nreplicateInfinite \n\n Creates an infinite task sequence by repeating \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Evalue\u003C/span\u003E indefinitely.\n The sequence never ends; use \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.take\u0022\u003Etake\u003C/a\u003E, \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhile\u0022\u003EtakeWhile\u003C/a\u003E,\n or similar to bound consumption.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#replicateInfiniteAsync","title":"TaskSeq.replicateInfiniteAsync","content":"TaskSeq.replicateInfiniteAsync \nreplicateInfiniteAsync \n\n Creates an infinite task sequence by repeatedly executing \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecomputation\u003C/span\u003E,\n yielding each produced value indefinitely.\n The sequence never ends; use \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.take\u0022\u003Etake\u003C/a\u003E, \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhile\u0022\u003EtakeWhile\u003C/a\u003E,\n or similar to bound consumption.\n If the computation is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.replicateinfinite\u0022\u003EreplicateInfinite\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#replicateUntilNoneAsync","title":"TaskSeq.replicateUntilNoneAsync","content":"TaskSeq.replicateUntilNoneAsync \nreplicateUntilNoneAsync \n\n Creates a task sequence by repeatedly executing \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecomputation\u003C/span\u003E until it returns\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E, yielding each \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome\u003C/a\u003E value in order.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#scan","title":"TaskSeq.scan","content":"TaskSeq.scan \nscan \n\n Like \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.fold\u0022\u003Efold\u003C/a\u003E, but returns the sequence of intermediate results and the final result.\n The first element of the output sequence is always the initial state. If the input task sequence\n has \u003Ccode\u003EN\u003C/code\u003E elements, the output task sequence has \u003Ccode\u003EN \u002B 1\u003C/code\u003E elements.\n If the folder function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.scanasync\u0022\u003EscanAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#scanAsync","title":"TaskSeq.scanAsync","content":"TaskSeq.scanAsync \nscanAsync \n\n Like \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.foldasync\u0022\u003EfoldAsync\u003C/a\u003E, but returns the sequence of intermediate results and the final result.\n The first element of the output sequence is always the initial state. If the input task sequence\n has \u003Ccode\u003EN\u003C/code\u003E elements, the output task sequence has \u003Ccode\u003EN \u002B 1\u003C/code\u003E elements.\n If the folder function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.scan\u0022\u003Escan\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#singleton","title":"TaskSeq.singleton","content":"TaskSeq.singleton \nsingleton \n\n Creates a task sequence from \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Evalue\u003C/span\u003E that generates a single element and then ends.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#skip","title":"TaskSeq.skip","content":"TaskSeq.skip \nskip \n\n Returns a task sequence that, when iterated, skips \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E elements of the underlying\n sequence, and then yields the remainder. Raises an exception if there are not \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E\n items. See \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.drop\u0022\u003Edrop\u003C/a\u003E for a version that does not raise an exception.\n See also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.take\u0022\u003Etake\u003C/a\u003E for the inverse of this operation.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#skipWhile","title":"TaskSeq.skipWhile","content":"TaskSeq.skipWhile \nskipWhile \n\n Returns a task sequence that, when iterated, skips elements of the underlying sequence while the\n given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E, and then yields the remaining\n elements. Elements where the predicate returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E are propagated, which means that this\n function may not skip any elements (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhileinclusive\u0022\u003EskipWhileInclusive\u003C/a\u003E).\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhileasync\u0022\u003EskipWhileAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#skipWhileAsync","title":"TaskSeq.skipWhileAsync","content":"TaskSeq.skipWhileAsync \nskipWhileAsync \n\n Returns a task sequence that, when iterated, skips elements of the underlying sequence while the\n given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E, and then yields the\n remaining elements. Elements where the predicate returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E are propagated, which means that this\n function may not skip any elements (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhileinclusiveasync\u0022\u003EskipWhileInclusiveAsync\u003C/a\u003E).\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhile\u0022\u003EskipWhile\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#skipWhileInclusive","title":"TaskSeq.skipWhileInclusive","content":"TaskSeq.skipWhileInclusive \nskipWhileInclusive \n\n Returns a task sequence that, when iterated, skips elements of the underlying sequence until the given\n function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E, \u003Ci\u003Ealso skips that element\u003C/i\u003E\n and then yields the remaining elements (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhile\u0022\u003EskipWhile\u003C/a\u003E). It will thus always skip\n at least one element of a non-empty sequence, or returns the empty task sequence if the input is empty.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhileinclusiveasync\u0022\u003EskipWhileInclusiveAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#skipWhileInclusiveAsync","title":"TaskSeq.skipWhileInclusiveAsync","content":"TaskSeq.skipWhileInclusiveAsync \nskipWhileInclusiveAsync \n\n Returns a task sequence that, when iterated, skips elements of the underlying sequence until the given\n function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E, \u003Ci\u003Ealso skips that element\u003C/i\u003E\n and then yields the remaining elements (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhileasync\u0022\u003EskipWhileAsync\u003C/a\u003E). It will thus always skip\n at least one element of a non-empty sequence, or returns the empty task sequence if the input is empty.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skipwhileinclusive\u0022\u003EskipWhileInclusive\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#splitAt","title":"TaskSeq.splitAt","content":"TaskSeq.splitAt \nsplitAt \n\n Splits the task sequence into a prefix array of at most \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E elements and a task\n sequence containing the remaining elements. The prefix is eagerly evaluated in a single pass; the\n remaining sequence is lazy. If the source has fewer than \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E elements, the prefix\n array is shorter than \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E and the remaining sequence is empty.\n \n\n The prefix array and the remaining task sequence share a single enumerator over \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n For sequences backed by replayable data (arrays, lists, \u003Ccode\u003EtaskSeq\u003C/code\u003E builders, etc.) this is always safe.\n For externally-managed resources (network streams, database cursors) the remaining sequence should be\n consumed or disposed before any other operation on \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tail","title":"TaskSeq.tail","content":"TaskSeq.tail \ntail \n\n Returns the whole task sequence from \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, minus its first element.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#take","title":"TaskSeq.take","content":"TaskSeq.take \ntake \n\n Returns a task sequence that, when iterated, yields \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E elements of the\n underlying sequence, and then returns no further elements. Raises an exception if there are not enough\n elements in the sequence. See \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.truncate\u0022\u003Etruncate\u003C/a\u003E for a version that does not raise an exception.\n See also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.skip\u0022\u003Eskip\u003C/a\u003E for the inverse of this operation.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#takeWhile","title":"TaskSeq.takeWhile","content":"TaskSeq.takeWhile \ntakeWhile \n\n Returns a task sequence that, when iterated, yields elements of the underlying sequence while the\n given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E, and then returns no further elements.\n Stops consuming the source and yielding items as soon as the predicate returns \u003Ccode\u003Efalse\u003C/code\u003E.\n (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhileinclusive\u0022\u003EtakeWhileInclusive\u003C/a\u003E).\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhileasync\u0022\u003EtakeWhileAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#takeWhileAsync","title":"TaskSeq.takeWhileAsync","content":"TaskSeq.takeWhileAsync \ntakeWhileAsync \n\n Returns a task sequence that, when iterated, yields elements of the underlying sequence while the\n given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E, and then returns no further elements.\n Stops consuming the source and yielding items as soon as the predicate returns \u003Ccode\u003Efalse\u003C/code\u003E.\n (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhileinclusiveasync\u0022\u003EtakeWhileInclusiveAsync\u003C/a\u003E).\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhile\u0022\u003EtakeWhile\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#takeWhileInclusive","title":"TaskSeq.takeWhileInclusive","content":"TaskSeq.takeWhileInclusive \ntakeWhileInclusive \n\n Returns a task sequence that, when iterated, yields elements of the underlying sequence until the given\n function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E, returns that element\n and then returns no further elements (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhile\u0022\u003EtakeWhile\u003C/a\u003E). This function returns\n at least one element of a non-empty sequence, or the empty task sequence if the input is empty.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhileinclusiveasync\u0022\u003EtakeWhileInclusiveAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#takeWhileInclusiveAsync","title":"TaskSeq.takeWhileInclusiveAsync","content":"TaskSeq.takeWhileInclusiveAsync \ntakeWhileInclusiveAsync \n\n Returns a task sequence that, when iterated, yields elements of the underlying sequence until the given\n asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/false\u0022\u003Efalse\u003C/a\u003E, returns that element\n and then returns no further elements (see also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhileasync\u0022\u003EtakeWhileAsync\u003C/a\u003E). This function returns\n at least one element of a non-empty sequence, or the empty task sequence if the input is empty.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.takewhileinclusive\u0022\u003EtakeWhileInclusive\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#threadState","title":"TaskSeq.threadState","content":"TaskSeq.threadState \nthreadState \n\n Applies the function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element of the task sequence, threading a state\n argument through the computation, and lazily yields each mapped result as a new task sequence. Unlike\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.mapfold\u0022\u003EmapFold\u003C/a\u003E, the results are streamed rather than collected into an array, and the\n final state is not returned.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.threadstateasync\u0022\u003EthreadStateAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#threadStateAsync","title":"TaskSeq.threadStateAsync","content":"TaskSeq.threadStateAsync \nthreadStateAsync \n\n Applies the asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E to each element of the task sequence, threading\n a state argument through the computation, and lazily yields each mapped result as a new task sequence. Unlike\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.mapfoldasync\u0022\u003EmapFoldAsync\u003C/a\u003E, the results are streamed rather than collected into an array, and the\n final state is not returned.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Efolder\u003C/span\u003E function is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.threadstate\u0022\u003EthreadState\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toArray","title":"TaskSeq.toArray","content":"TaskSeq.toArray \ntoArray \n\n Builds an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/array\u0022\u003Earray\u003C/a\u003E from the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n This function is blocking until the sequence is exhausted and will then properly dispose of the resources.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toArrayAsync","title":"TaskSeq.toArrayAsync","content":"TaskSeq.toArrayAsync \ntoArrayAsync \n\n Builds an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/array\u0022\u003Earray\u003C/a\u003E asynchronously from the input task sequence.\n This function is non-blocking while it builds the array.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toChannelAsync","title":"TaskSeq.toChannelAsync","content":"TaskSeq.toChannelAsync \ntoChannelAsync \n\n Writes all elements of the input task sequence \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E to a\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/channelwriter\u003C\u0027t\u003E\u0022\u003EChannelWriter\u003C\u0027T\u003E\u003C/a\u003E and marks the writer as complete when the sequence\n is exhausted. If an exception is raised during iteration, the writer is completed with\n that exception so that downstream readers observe it.\n This function is non-blocking while it writes to the channel.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toIListAsync","title":"TaskSeq.toIListAsync","content":"TaskSeq.toIListAsync \ntoIListAsync \n\n Builds an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/ilist\u003C\u0027t\u003E\u0022\u003EIList\u003C\u0027T\u003E\u003C/a\u003E asynchronously from the input task sequence.\n This function is non-blocking while it builds the IList.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toList","title":"TaskSeq.toList","content":"TaskSeq.toList \ntoList \n\n Builds an F# \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/list\u0022\u003Elist\u003C/a\u003E from the input task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E.\n This function is blocking until the sequence is exhausted and will then properly dispose of the resources.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toListAsync","title":"TaskSeq.toListAsync","content":"TaskSeq.toListAsync \ntoListAsync \n\n Builds an F# \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/list\u0022\u003Elist\u003C/a\u003E asynchronously from the input task sequence.\n This function is non-blocking while it builds the list.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toResizeArrayAsync","title":"TaskSeq.toResizeArrayAsync","content":"TaskSeq.toResizeArrayAsync \ntoResizeArrayAsync \n\n Gathers items into a ResizeArray (see \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.collections.generic.list\u003C_\u003E\u0022\u003EList\u003C_\u003E\u003C/a\u003E) asynchronously from the input task sequence.\n This function is non-blocking while it builds the resizable array.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#toSeq","title":"TaskSeq.toSeq","content":"TaskSeq.toSeq \ntoSeq \n\n Views the task sequence in \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E as an F# \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/seq\u0022\u003Eseq\u003C/a\u003E, that is, an\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/ienumerable\u003C_\u003E\u0022\u003EIEnumerable\u003C_\u003E\u003C/a\u003E. This function is blocking at each call\n to \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/ienumerator\u003C_\u003E.movenext\u0022\u003EMoveNext()\u003C/a\u003E in the resulting sequence.\n Resources are disposed when the enumerator is disposed, or the enumerator is exhausted.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#truncate","title":"TaskSeq.truncate","content":"TaskSeq.truncate \ntruncate \n\n Returns a task sequence that, when iterated, yields at most \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Ecount\u003C/span\u003E elements of the underlying\n sequence, truncating the remainder, if any.\n See \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.take\u0022\u003Etake\u003C/a\u003E for a version that raises an exception if there are not enough elements in the\n sequence. See also \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.drop\u0022\u003Edrop\u003C/a\u003E for the inverse of this operation.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryExactlyOne","title":"TaskSeq.tryExactlyOne","content":"TaskSeq.tryExactlyOne \ntryExactlyOne \n\n Returns the only element of the task sequence, or \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if the sequence is empty of\n contains more than one element.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryFind","title":"TaskSeq.tryFind","content":"TaskSeq.tryFind \ntryFind \n\n Returns the first element for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E. Returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if no such element exists.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.tryfindasync\u0022\u003EtryFindAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryFindAsync","title":"TaskSeq.tryFindAsync","content":"TaskSeq.tryFindAsync \ntryFindAsync \n\n Returns the first element for which the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E. Returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if no such element exists.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.tryfind\u0022\u003EtryFind\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryFindIndex","title":"TaskSeq.tryFindIndex","content":"TaskSeq.tryFindIndex \ntryFindIndex \n\n Returns the index, starting from zero, for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E. Returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if no such element exists.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.tryfindindexasync\u0022\u003EtryFindIndexAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryFindIndexAsync","title":"TaskSeq.tryFindIndexAsync","content":"TaskSeq.tryFindIndexAsync \ntryFindIndexAsync \n\n Returns the index, starting from zero, for which the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns\n \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E. Returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if no such element exists.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.tryfindindex\u0022\u003EtryFindIndex\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryHead","title":"TaskSeq.tryHead","content":"TaskSeq.tryHead \ntryHead \n\n Returns the first element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E,\n or \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if the sequence is empty.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryItem","title":"TaskSeq.tryItem","content":"TaskSeq.tryItem \ntryItem \n\n Returns the nth element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E,\n or \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if the sequence does not contain enough elements.\n The index is zero-based, that is, using index 0 returns the first element.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryLast","title":"TaskSeq.tryLast","content":"TaskSeq.tryLast \ntryLast \n\n Returns the last element of the input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E,\n or \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if the sequence is empty.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryMax","title":"TaskSeq.tryMax","content":"TaskSeq.tryMax \ntryMax \n\n Returns \u003Ccode\u003ESome\u003C/code\u003E with the greatest of all elements of the task sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.max\u0022\u003Emax\u003C/a\u003E,\n or \u003Ccode\u003ENone\u003C/code\u003E if the sequence is empty. For sequences that should never be empty, prefer \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.max\u0022\u003Emax\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryMin","title":"TaskSeq.tryMin","content":"TaskSeq.tryMin \ntryMin \n\n Returns \u003Ccode\u003ESome\u003C/code\u003E with the smallest of all elements of the task sequence, compared via \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/operators.min\u0022\u003Emin\u003C/a\u003E,\n or \u003Ccode\u003ENone\u003C/code\u003E if the sequence is empty. For sequences that should never be empty, prefer \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.min\u0022\u003Emin\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryPick","title":"TaskSeq.tryPick","content":"TaskSeq.tryPick \ntryPick \n\n Applies the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to successive elements, returning the first result where\n the function returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome(x)\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.trypickasync\u0022\u003EtryPickAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryPickAsync","title":"TaskSeq.tryPickAsync","content":"TaskSeq.tryPickAsync \ntryPickAsync \n\n Applies the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E to successive elements, returning the first result where\n the function returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/some\u0022\u003ESome(x)\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Echooser\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.trypick\u0022\u003EtryPick\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#tryTail","title":"TaskSeq.tryTail","content":"TaskSeq.tryTail \ntryTail \n\n Returns the whole input task sequence given by \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Esource\u003C/span\u003E, minus its first element,\n or \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/none\u0022\u003ENone\u003C/a\u003E if the sequence is empty.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#unbox","title":"TaskSeq.unbox","content":"TaskSeq.unbox \nunbox \n\n Calls \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/unbox\u0022\u003Eunbox\u003C/a\u003E on each item when the task sequence is consumed.\n The target type must be a value type.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#unfold","title":"TaskSeq.unfold","content":"TaskSeq.unfold \nunfold \n\n Returns a task sequence generated by applying the generator function to a state value, until it returns \u003Ccode\u003ENone\u003C/code\u003E.\n Each call to \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Egenerator\u003C/span\u003E returns either \u003Ccode\u003ENone\u003C/code\u003E, which terminates the sequence, or\n \u003Ccode\u003ESome(element, newState)\u003C/code\u003E, which yields \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eelement\u003C/span\u003E and updates the state for the next call.\n Unlike \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.init\u0022\u003Einit\u003C/a\u003E, the number of elements need not be known in advance.\n If the generator function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.unfoldasync\u0022\u003EunfoldAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#unfoldAsync","title":"TaskSeq.unfoldAsync","content":"TaskSeq.unfoldAsync \nunfoldAsync \n\n Returns a task sequence generated by applying the asynchronous generator function to a state value, until it\n returns \u003Ccode\u003ENone\u003C/code\u003E. Each call to \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Egenerator\u003C/span\u003E returns either \u003Ccode\u003ENone\u003C/code\u003E, which terminates the\n sequence, or \u003Ccode\u003ESome(element, newState)\u003C/code\u003E, which yields \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Eelement\u003C/span\u003E and updates the state.\n Unlike \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.initasync\u0022\u003EinitAsync\u003C/a\u003E, the number of elements need not be known in advance.\n If the generator function is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.unfold\u0022\u003Eunfold\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#updateAt","title":"TaskSeq.updateAt","content":"TaskSeq.updateAt \nupdateAt \n\n Return a new task sequence with the item at a given index set to the new value.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#where","title":"TaskSeq.where","content":"TaskSeq.where \nwhere \n\n Returns a new task sequence containing only the elements of the collection\n for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.whereasync\u0022\u003EwhereAsync\u003C/a\u003E.\n\n Alias for \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.filter\u0022\u003Efilter\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#whereAsync","title":"TaskSeq.whereAsync","content":"TaskSeq.whereAsync \nwhereAsync \n\n Returns a new task sequence containing only the elements of the input sequence\n for which the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E returns \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/true\u0022\u003Etrue\u003C/a\u003E.\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Epredicate\u003C/span\u003E is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.where\u0022\u003Ewhere\u003C/a\u003E.\n\n Alias for \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.filterasync\u0022\u003EfilterAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#windowed","title":"TaskSeq.windowed","content":"TaskSeq.windowed \nwindowed \n\n Returns a task sequence of sliding windows of a given size over the source sequence.\n Each window is a fresh array of exactly \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EwindowSize\u003C/span\u003E consecutive elements.\n The result is empty if the source has fewer than \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EwindowSize\u003C/span\u003E elements.\n\n Uses a ring buffer internally to avoid redundant copies, yielding one allocation per window.\n\n If \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EwindowSize\u003C/span\u003E is not positive, an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.argumentexception\u0022\u003EArgumentException\u003C/a\u003E is raised immediately\n (before the sequence is evaluated).\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#withCancellation","title":"TaskSeq.withCancellation","content":"TaskSeq.withCancellation \nwithCancellation \n\n Returns a task sequence that, when iterated, passes the given \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EcancellationToken\u003C/span\u003E to the\n underlying \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E. This is the equivalent of calling\n \u003Ccode\u003E.WithCancellation(cancellationToken)\u003C/code\u003E on an \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E.\n \n\n The \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EcancellationToken\u003C/span\u003E supplied to this function overrides any token that would otherwise\n be passed to the enumerator. This is useful when consuming sequences from libraries such as Entity Framework,\n which accept a \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/cancellationtoken\u0022\u003ECancellationToken\u003C/a\u003E through \u003Ccode\u003EGetAsyncEnumerator\u003C/code\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#zip","title":"TaskSeq.zip","content":"TaskSeq.zip \nzip \n\n Combines the two task sequences into a new task sequence of pairs. The two sequences need not have equal lengths:\n when one sequence is exhausted any remaining elements in the other sequence are ignored.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#zip3","title":"TaskSeq.zip3","content":"TaskSeq.zip3 \nzip3 \n\n Combines the three task sequences into a new task sequence of triples. The three sequences need not have equal lengths:\n when one sequence is exhausted any remaining elements in the other sequences are ignored.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#zipWith","title":"TaskSeq.zipWith","content":"TaskSeq.zipWith \nzipWith \n\n Combines two task sequences and applies the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E to corresponding\n element pairs. The sequences need not have equal lengths: when one is exhausted any remaining elements in\n the other are ignored.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.zipwithasync\u0022\u003EzipWithAsync\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#zipWith3","title":"TaskSeq.zipWith3","content":"TaskSeq.zipWith3 \nzipWith3 \n\n Combines three task sequences and applies the given function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E to corresponding\n element triples. The sequences need not have equal lengths: when one is exhausted any remaining elements in\n the others are ignored.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E function is asynchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.zipwithasync3\u0022\u003EzipWithAsync3\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#zipWithAsync","title":"TaskSeq.zipWithAsync","content":"TaskSeq.zipWithAsync \nzipWithAsync \n\n Combines two task sequences and applies the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E to\n corresponding element pairs. The sequences need not have equal lengths: when one is exhausted any remaining\n elements in the other are ignored.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E function is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.zipwith\u0022\u003EzipWith\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq.html#zipWithAsync3","title":"TaskSeq.zipWithAsync3","content":"TaskSeq.zipWithAsync3 \nzipWithAsync3 \n\n Combines three task sequences and applies the given asynchronous function \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E to\n corresponding element triples. The sequences need not have equal lengths: when one is exhausted any remaining\n elements in the others are ignored.\n If the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003Emapping\u003C/span\u003E function is synchronous, consider using \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq.zipwith3\u0022\u003EzipWith3\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-1-0.html","title":"TaskSeq\u003C\u0027T\u003E","content":"TaskSeq\u003C\u0027T\u003E \n\n Represents a task sequence and is the output of using the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EtaskSeq{...}\u003C/span\u003E\n computation expression from this library. It is an alias for \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.iasyncenumerable\u003C_\u003E\u0022\u003EIAsyncEnumerable\u003C_\u003E\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-2.html","title":"TaskSeq\u003C\u0027Machine, \u0027T\u003E","content":"TaskSeq\u003C\u0027Machine, \u0027T\u003E \n\n Main implementation of generic \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E and related interfaces,\n which forms the meat of the logic behind \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expresssions.\n For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state.\n \nTaskSeq\u003C\u0027Machine, \u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTaskSeq\u003C\u0027Machine, \u0027T\u003E.InitMachineData \nInitMachineData \nTaskSeq\u003C\u0027Machine, \u0027T\u003E._initialMachine \n_initialMachine \nTaskSeq\u003C\u0027Machine, \u0027T\u003E._machine \n_machine","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-2.html#\u0060\u0060.ctor\u0060\u0060","title":"TaskSeq\u003C\u0027Machine, \u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"TaskSeq\u003C\u0027Machine, \u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-2.html#InitMachineData","title":"TaskSeq\u003C\u0027Machine, \u0027T\u003E.InitMachineData","content":"TaskSeq\u003C\u0027Machine, \u0027T\u003E.InitMachineData \nInitMachineData \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-2.html#_initialMachine","title":"TaskSeq\u003C\u0027Machine, \u0027T\u003E._initialMachine","content":"TaskSeq\u003C\u0027Machine, \u0027T\u003E._initialMachine \n_initialMachine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-2.html#_machine","title":"TaskSeq\u003C\u0027Machine, \u0027T\u003E._machine","content":"TaskSeq\u003C\u0027Machine, \u0027T\u003E._machine \n_machine \n Keeps the active state machine.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbase-1.html","title":"TaskSeqBase\u003C\u0027T\u003E","content":"TaskSeqBase\u003C\u0027T\u003E \n\n Abstract base class for \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u003C\u0027machine, \u0027t\u003E\u0022\u003ETaskSeq\u003C\u0027Machine, \u0027T\u003E\u003C/a\u003E.\n For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state.\n \nTaskSeqBase\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTaskSeqBase\u003C\u0027T\u003E.MoveNextAsyncResult \nMoveNextAsyncResult","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbase-1.html#\u0060\u0060.ctor\u0060\u0060","title":"TaskSeqBase\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"TaskSeqBase\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbase-1.html#MoveNextAsyncResult","title":"TaskSeqBase\u003C\u0027T\u003E.MoveNextAsyncResult","content":"TaskSeqBase\u003C\u0027T\u003E.MoveNextAsyncResult \nMoveNextAsyncResult \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html","title":"TaskSeqBuilder","content":"TaskSeqBuilder \n\n Main builder class for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression.\n \nTaskSeqBuilder.Combine \nCombine \nTaskSeqBuilder.Delay \nDelay \nTaskSeqBuilder.Run \nRun \nTaskSeqBuilder.TryFinally \nTryFinally \nTaskSeqBuilder.TryFinallyAsync \nTryFinallyAsync \nTaskSeqBuilder.TryWith \nTryWith \nTaskSeqBuilder.Using \nUsing \nTaskSeqBuilder.While \nWhile \nTaskSeqBuilder.WhileAsync \nWhileAsync \nTaskSeqBuilder.Yield \nYield \nTaskSeqBuilder.Zero \nZero","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#Combine","title":"TaskSeqBuilder.Combine","content":"TaskSeqBuilder.Combine \nCombine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#Delay","title":"TaskSeqBuilder.Delay","content":"TaskSeqBuilder.Delay \nDelay \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#Run","title":"TaskSeqBuilder.Run","content":"TaskSeqBuilder.Run \nRun \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#TryFinally","title":"TaskSeqBuilder.TryFinally","content":"TaskSeqBuilder.TryFinally \nTryFinally \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#TryFinallyAsync","title":"TaskSeqBuilder.TryFinallyAsync","content":"TaskSeqBuilder.TryFinallyAsync \nTryFinallyAsync \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#TryWith","title":"TaskSeqBuilder.TryWith","content":"TaskSeqBuilder.TryWith \nTryWith \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#Using","title":"TaskSeqBuilder.Using","content":"TaskSeqBuilder.Using \nUsing \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#While","title":"TaskSeqBuilder.While","content":"TaskSeqBuilder.While \nWhile \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#WhileAsync","title":"TaskSeqBuilder.WhileAsync","content":"TaskSeqBuilder.WhileAsync \nWhileAsync \n Used by \u0060For\u0060. F# currently doesn\u0027t support \u0060while!\u0060, so this cannot be called directly from the CE","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#Yield","title":"TaskSeqBuilder.Yield","content":"TaskSeqBuilder.Yield \nYield \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html#Zero","title":"TaskSeqBuilder.Zero","content":"TaskSeqBuilder.Zero \nZero \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamic-1.html","title":"TaskSeqDynamic\u003C\u0027T\u003E","content":"TaskSeqDynamic\u003C\u0027T\u003E \n\n Dynamic (FSI-compatible) implementation of \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/iasyncenumerable\u003C\u0027t\u003E\u0022\u003EIAsyncEnumerable\u003C\u0027T\u003E\u003C/a\u003E for \u003Ccode\u003EtaskSeq\u003C/code\u003E\n computation expressions. Used when the F# compiler cannot generate static resumable code (e.g., in FSI).\n For use by this library only.\n \nTaskSeqDynamic\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTaskSeqDynamic\u003C\u0027T\u003E.InitDynamicMachineData \nInitDynamicMachineData \nTaskSeqDynamic\u003C\u0027T\u003E._machine \n_machine \nTaskSeqDynamic\u003C\u0027T\u003E._initialResumptionFunc \n_initialResumptionFunc","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamic-1.html#\u0060\u0060.ctor\u0060\u0060","title":"TaskSeqDynamic\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"TaskSeqDynamic\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamic-1.html#InitDynamicMachineData","title":"TaskSeqDynamic\u003C\u0027T\u003E.InitDynamicMachineData","content":"TaskSeqDynamic\u003C\u0027T\u003E.InitDynamicMachineData \nInitDynamicMachineData \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamic-1.html#_machine","title":"TaskSeqDynamic\u003C\u0027T\u003E._machine","content":"TaskSeqDynamic\u003C\u0027T\u003E._machine \n_machine \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamic-1.html#_initialResumptionFunc","title":"TaskSeqDynamic\u003C\u0027T\u003E._initialResumptionFunc","content":"TaskSeqDynamic\u003C\u0027T\u003E._initialResumptionFunc \n_initialResumptionFunc \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamicbuilder.html","title":"TaskSeqDynamicBuilder","content":"TaskSeqDynamicBuilder \n\n Builder class for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseqdynamic\u0022\u003EtaskSeqDynamic\u003C/a\u003E computation expression. Inherits all members\n from \u003Ca href=\u0022https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqbuilder.html\u0022\u003ETaskSeqBuilder\u003C/a\u003E, using the dynamic resumable code path as fallback when the\n F# compiler cannot generate static resumable code (e.g., in F# Interactive / FSI).\n \nTaskSeqDynamicBuilder.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamicbuilder.html#\u0060\u0060.ctor\u0060\u0060","title":"TaskSeqDynamicBuilder.\u0060\u0060.ctor\u0060\u0060","content":"TaskSeqDynamicBuilder.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamicinfo-1.html","title":"TaskSeqDynamicInfo\u003C\u0027T\u003E","content":"TaskSeqDynamicInfo\u003C\u0027T\u003E \n\n Concrete implementation of \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseqresumptiondynamicinfo\u003C\u0027t\u003E\u0022\u003ETaskSeqResumptionDynamicInfo\u003C\u0027T\u003E\u003C/a\u003E for \u003Ccode\u003EtaskSeq\u003C/code\u003E computation\n expressions, used in the dynamic (FSI) path. Handles state-machine transitions when the F# compiler\n cannot generate static resumable code.\n For use by this library only.\n \nTaskSeqDynamicInfo\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqdynamicinfo-1.html#\u0060\u0060.ctor\u0060\u0060","title":"TaskSeqDynamicInfo\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"TaskSeqDynamicInfo\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqresumptiondynamicinfo-1.html","title":"TaskSeqResumptionDynamicInfo\u003C\u0027T\u003E","content":"TaskSeqResumptionDynamicInfo\u003C\u0027T\u003E \n \nTaskSeqResumptionDynamicInfo\u003C\u0027T\u003E.ResumptionData \nResumptionData \nTaskSeqResumptionDynamicInfo\u003C\u0027T\u003E.ResumptionFunc \nResumptionFunc","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqresumptiondynamicinfo-1.html#ResumptionData","title":"TaskSeqResumptionDynamicInfo\u003C\u0027T\u003E.ResumptionData","content":"TaskSeqResumptionDynamicInfo\u003C\u0027T\u003E.ResumptionData \nResumptionData \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqresumptiondynamicinfo-1.html#ResumptionFunc","title":"TaskSeqResumptionDynamicInfo\u003C\u0027T\u003E.ResumptionFunc","content":"TaskSeqResumptionDynamicInfo\u003C\u0027T\u003E.ResumptionFunc \nResumptionFunc \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqresumptionfunc-1.html","title":"TaskSeqResumptionFunc\u003C\u0027T\u003E","content":"TaskSeqResumptionFunc\u003C\u0027T\u003E \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachine-1.html","title":"TaskSeqStateMachine\u003C\u0027T\u003E","content":"TaskSeqStateMachine\u003C\u0027T\u003E \n\n Contains the state data for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression builder.\n For use in this library only. Required by the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseqbuilder.run\u0022\u003ERun\u003C/a\u003E method.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html","title":"TaskSeqStateMachineData\u003C\u0027T\u003E","content":"TaskSeqStateMachineData\u003C\u0027T\u003E \n\n Contains the state data for the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseq\u0022\u003EtaskSeq\u003C/a\u003E computation expression builder.\n For use in this library only. Required by the \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/taskseqbuilder.run\u0022\u003ERun\u003C/a\u003E method.\n \nTaskSeqStateMachineData\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \nTaskSeqStateMachineData\u003C\u0027T\u003E.PopDispose \nPopDispose \nTaskSeqStateMachineData\u003C\u0027T\u003E.PushDispose \nPushDispose \nTaskSeqStateMachineData\u003C\u0027T\u003E.cancellationToken \ncancellationToken \nTaskSeqStateMachineData\u003C\u0027T\u003E.disposalStack \ndisposalStack \nTaskSeqStateMachineData\u003C\u0027T\u003E.awaiter \nawaiter \nTaskSeqStateMachineData\u003C\u0027T\u003E.promiseOfValueOrEnd \npromiseOfValueOrEnd \nTaskSeqStateMachineData\u003C\u0027T\u003E.builder \nbuilder \nTaskSeqStateMachineData\u003C\u0027T\u003E.completed \ncompleted \nTaskSeqStateMachineData\u003C\u0027T\u003E.current \ncurrent \nTaskSeqStateMachineData\u003C\u0027T\u003E.boxedSelf \nboxedSelf","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#\u0060\u0060.ctor\u0060\u0060","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.\u0060\u0060.ctor\u0060\u0060 \n\u0060\u0060.ctor\u0060\u0060 \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#PopDispose","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.PopDispose","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.PopDispose \nPopDispose \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#PushDispose","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.PushDispose","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.PushDispose \nPushDispose \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#cancellationToken","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.cancellationToken","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.cancellationToken \ncancellationToken \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#disposalStack","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.disposalStack","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.disposalStack \ndisposalStack \n Keeps track of the objects that need to be disposed off on IAsyncDispose.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#awaiter","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.awaiter","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.awaiter \nawaiter \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#promiseOfValueOrEnd","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.promiseOfValueOrEnd","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.promiseOfValueOrEnd \npromiseOfValueOrEnd \n","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#builder","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.builder","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.builder \nbuilder \n Helper struct providing methods for awaiting \u0027next\u0027 in async iteration scenarios.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#completed","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.completed","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.completed \ncompleted \n Whether or not a full iteration through the IAsyncEnumerator has completed","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#current","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.current","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.current \ncurrent \n Used by the AsyncEnumerator interface to return the Current value when\n IAsyncEnumerator.Current is called","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseqstatemachinedata-1.html#boxedSelf","title":"TaskSeqStateMachineData\u003C\u0027T\u003E.boxedSelf","content":"TaskSeqStateMachineData\u003C\u0027T\u003E.boxedSelf \nboxedSelf \n A reference to \u0027self\u0027, because otherwise we can\u0027t use byref in the resumable code.","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/reference/fsharp-control-taskseq-1.html","title":"taskSeq\u003C\u0027T\u003E","content":"taskSeq\u003C\u0027T\u003E \n\n Represents a task sequence and is the output of using the \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EtaskSeq{...}\u003C/span\u003E\n computation expression from this library. It is an alias for \u003Ca href=\u0022https://learn.microsoft.com/dotnet/api/system.iasyncenumerable\u003C_\u003E\u0022\u003EIAsyncEnumerable\u003C_\u003E\u003C/a\u003E.\n\n The type \u003Cspan class=\u0022fsdocs-param-name\u0022\u003EtaskSeq\u0026lt;_\u0026gt;\u003C/span\u003E is deprecated since version 0.4.0,\n please use \u003Cspan class=\u0022fsdocs-param-name\u0022\u003ETaskSeq\u0026lt;_\u0026gt;\u003C/span\u003E in its stead. See \u003Ca href=\u0022https://fsharp.github.io/fsharp-core-docs/reference/fsharp-control-taskseq\u003C_\u003E\u0022\u003ETaskSeq\u003C_\u003E\u003C/a\u003E.\n ","headings":[],"type":"apiDocs"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/TaskSeqAdvanced.html","title":"Advanced Task Sequence Operations","content":"\nAdvanced Task Sequence Operations\nThis page covers advanced TaskSeq\u0026lt;\u0027T\u0026gt; operations: grouping, stateful transformation with\nmapFold and threadState, deduplication, set-difference, partitioning, counting by key, lexicographic\ncomparison, cancellation, and positional editing.\nopen System.Threading\nopen System.Threading.Tasks\nopen FSharp.Control\n\n\ngroupBy and groupByAsync\nTaskSeq.groupBy partitions a sequence into groups by a key-projection function. The result\nis an array of (key, elements[]) pairs, one per distinct key, in order of first occurrence.\n\nNote: groupBy consumes the entire source before returning. Do not use it on\npotentially infinite sequences.\n\ntype Event = { EntityId: int; Payload: string }\n\nlet events : TaskSeq\u0026lt;Event\u0026gt; =\n TaskSeq.ofList\n [ { EntityId = 1; Payload = \u0026quot;A\u0026quot; }\n { EntityId = 2; Payload = \u0026quot;B\u0026quot; }\n { EntityId = 1; Payload = \u0026quot;C\u0026quot; }\n { EntityId = 3; Payload = \u0026quot;D\u0026quot; }\n { EntityId = 2; Payload = \u0026quot;E\u0026quot; } ]\n\n// groups: (1, [A;C]), (2, [B;E]), (3, [D])\nlet grouped : Task\u0026lt;(int * Event[])[]\u0026gt; =\n events |\u0026gt; TaskSeq.groupBy (fun e -\u0026gt; e.EntityId)\n\nTaskSeq.groupByAsync accepts an async key projection:\nlet groupedAsync : Task\u0026lt;(int * Event[])[]\u0026gt; =\n events |\u0026gt; TaskSeq.groupByAsync (fun e -\u0026gt; task { return e.EntityId })\n\n\ncountBy and countByAsync\nTaskSeq.countBy counts how many elements map to each key, returning (key, count)[]:\nlet counts : Task\u0026lt;(int * int)[]\u0026gt; =\n events |\u0026gt; TaskSeq.countBy (fun e -\u0026gt; e.EntityId)\n// (1,2), (2,2), (3,1)\n\n\nmapFold and mapFoldAsync\nTaskSeq.mapFold threads a state accumulator through a sequence while simultaneously mapping\neach element to a result value. The output is a task returning a pair of (result[], finalState):\n// Number each word sequentially while building a running concatenation\nlet words : TaskSeq\u0026lt;string\u0026gt; =\n TaskSeq.ofList [ \u0026quot;hello\u0026quot;; \u0026quot;world\u0026quot;; \u0026quot;foo\u0026quot; ]\n\nlet numbered : Task\u0026lt;string[] * int\u0026gt; =\n words\n |\u0026gt; TaskSeq.mapFold (fun count w -\u0026gt; $\u0026quot;{count}: {w}\u0026quot;, count \u002B 1) 0\n\n// result: ([| \u0026quot;0: hello\u0026quot;; \u0026quot;1: world\u0026quot;; \u0026quot;2: foo\u0026quot; |], 3)\n\nTaskSeq.mapFoldAsync is the same but the mapping function returns Task\u0026lt;\u0027Result * \u0027State\u0026gt;.\n\nthreadState and threadStateAsync\nTaskSeq.threadState is the lazy, streaming counterpart to mapFold. It threads a state\naccumulator through the sequence while yielding each mapped result \u2014 but unlike mapFold it\nnever materialises the results into an array, and it discards the final state. This makes it\nsuitable for infinite sequences and pipelines where intermediate results should be streamed rather\nthan buffered:\nlet numbers : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofSeq (seq { 1..5 })\n\n// Produce a running total without collecting the whole sequence first\nlet runningSum : TaskSeq\u0026lt;int\u0026gt; =\n numbers\n |\u0026gt; TaskSeq.threadState (fun acc x -\u0026gt; acc \u002B x, acc \u002B x) 0\n\n// yields lazily: 1, 3, 6, 10, 15\n\nCompare with scan, which also emits a running result but prepends the initial state:\nlet viaScan = numbers |\u0026gt; TaskSeq.scan (fun acc x -\u0026gt; acc \u002B x) 0\n// yields: 0, 1, 3, 6, 10, 15 (one extra initial element)\n\nlet viaThreadState = numbers |\u0026gt; TaskSeq.threadState (fun acc x -\u0026gt; acc \u002B x, acc \u002B x) 0\n// yields: 1, 3, 6, 10, 15 (no initial element; result == new state here)\n\nTaskSeq.threadStateAsync accepts an asynchronous folder:\nlet asyncRunningSum : TaskSeq\u0026lt;int\u0026gt; =\n numbers\n |\u0026gt; TaskSeq.threadStateAsync (fun acc x -\u0026gt; Task.fromResult (acc \u002B x, acc \u002B x)) 0\n\nTaskSeq.scan is the streaming sibling of fold: it emits each intermediate state as a new\nelement, starting with the initial state:\nlet runningTotals : TaskSeq\u0026lt;int\u0026gt; =\n numbers |\u0026gt; TaskSeq.scan (fun acc n -\u0026gt; acc \u002B n) 0\n\n// yields: 0, 1, 3, 6, 10, 15\n\n\ndistinct and distinctBy\nTaskSeq.distinct removes duplicates (keeps first occurrence), using generic equality:\nlet withDups : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 2; 3; 1; 4 ]\n\nlet deduped : TaskSeq\u0026lt;int\u0026gt; = withDups |\u0026gt; TaskSeq.distinct // 1, 2, 3, 4\n\nTaskSeq.distinctBy deduplicates by a key projection:\nlet strings : TaskSeq\u0026lt;string\u0026gt; =\n TaskSeq.ofList [ \u0026quot;hello\u0026quot;; \u0026quot;HELLO\u0026quot;; \u0026quot;world\u0026quot;; \u0026quot;WORLD\u0026quot; ]\n\nlet caseInsensitiveDistinct : TaskSeq\u0026lt;string\u0026gt; =\n strings |\u0026gt; TaskSeq.distinctBy (fun s -\u0026gt; s.ToLowerInvariant())\n// \u0026quot;hello\u0026quot;, \u0026quot;world\u0026quot;\n\n\nNote: both distinct and distinctBy buffer all unique keys in a hash set. Do not use\nthem on potentially infinite sequences.\n\nTaskSeq.distinctByAsync accepts an async key projection.\n\ndistinctUntilChanged\nTaskSeq.distinctUntilChanged removes consecutive duplicates only \u2014 it does not buffer the\nwhole sequence, so it is safe on infinite streams:\nlet run : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 1; 2; 2; 2; 3; 1; 1 ]\n\nlet noConsecDups : TaskSeq\u0026lt;int\u0026gt; = run |\u0026gt; TaskSeq.distinctUntilChanged\n// 1, 2, 3, 1\n\n\nexcept and exceptOfSeq\nTaskSeq.except itemsToExclude source returns elements of source that do not appear in\nitemsToExclude. The exclusion set is materialised eagerly before iteration:\nlet exclusions : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 2; 4 ]\nlet source : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofSeq (seq { 1..5 })\n\nlet filtered : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.except exclusions source // 1, 3, 5\n\nTaskSeq.exceptOfSeq accepts a plain seq\u0026lt;\u0027T\u0026gt; as the exclusion set.\n\npartition and partitionAsync\nTaskSeq.partition splits the sequence into two arrays in a single pass. Elements for which\nthe predicate returns true go into the first array; the rest into the second:\nlet partitioned : Task\u0026lt;int[] * int[]\u0026gt; =\n source |\u0026gt; TaskSeq.partition (fun n -\u0026gt; n % 2 = 0)\n// trueItems: [|2;4|] falseItems: [|1;3;5|]\n\nTaskSeq.partitionAsync accepts an async predicate.\n\ncompareWith and compareWithAsync\nTaskSeq.compareWith performs a lexicographic comparison of two sequences using a custom\ncomparer. It returns the first non-zero comparison result, or 0 if the sequences are\nelement-wise equal and have the same length:\nlet a : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 3 ]\nlet b : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 4 ]\n\nlet cmp : Task\u0026lt;int\u0026gt; =\n TaskSeq.compareWith (fun x y -\u0026gt; compare x y) a b\n// negative (a \u0026lt; b)\n\nTaskSeq.compareWithAsync accepts an async comparer.\n\nwithCancellation\nTaskSeq.withCancellation token source injects a CancellationToken into the underlying\nIAsyncEnumerable\u0026lt;\u0027T\u0026gt;. This is equivalent to calling .WithCancellation(token) in C# and\nis useful when consuming sequences from libraries (e.g. Entity Framework Core) that require a\ntoken at the enumeration site:\nlet cts = new CancellationTokenSource()\n\nlet cancellable : TaskSeq\u0026lt;int\u0026gt; =\n source |\u0026gt; TaskSeq.withCancellation cts.Token\n\n\nPositional editing\nTaskSeq.insertAt, TaskSeq.insertManyAt, TaskSeq.removeAt, TaskSeq.removeManyAt, and\nTaskSeq.updateAt produce new sequences with an element inserted, removed, or replaced at a\ngiven zero-based index:\nlet original : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 4; 5 ]\n\nlet inserted : TaskSeq\u0026lt;int\u0026gt; = original |\u0026gt; TaskSeq.insertAt 2 3 // 1,2,3,4,5\n\nlet removed : TaskSeq\u0026lt;int\u0026gt; = original |\u0026gt; TaskSeq.removeAt 1 // 1,4,5\n\nlet updated : TaskSeq\u0026lt;int\u0026gt; = original |\u0026gt; TaskSeq.updateAt 0 99 // 99,2,4,5\n\nlet manyInserted : TaskSeq\u0026lt;int\u0026gt; =\n original\n |\u0026gt; TaskSeq.insertManyAt 2 (TaskSeq.ofList [ 10; 11 ])\n// 1, 2, 10, 11, 4, 5\n\nlet manyRemoved : TaskSeq\u0026lt;int\u0026gt; = original |\u0026gt; TaskSeq.removeManyAt 1 2 // 1, 5\n\n","headings":["Advanced Task Sequence Operations","groupBy and groupByAsync","countBy and countByAsync","mapFold and mapFoldAsync","threadState and threadStateAsync","distinct and distinctBy","distinctUntilChanged","except and exceptOfSeq","partition and partitionAsync","compareWith and compareWithAsync","withCancellation","Positional editing"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/TaskSeqTransforming.html","title":"Transforming Task Sequences","content":"\nTransforming Task Sequences\nThis page covers the core operations for transforming TaskSeq\u0026lt;\u0027T\u0026gt; values: map, filter,\nchoose, collect, indexed, and type conversions.\nFor operations that consume a sequence into a single result, see\nConsuming Sequences.\nopen System.Threading.Tasks\nopen FSharp.Control\n\nTransforming with a computation expression\nThe most flexible way to transform a task sequence is to write a function that accepts a\nTaskSeq\u0026lt;_\u0026gt; and returns a TaskSeq\u0026lt;_\u0026gt; using a taskSeq { ... } computation expression. The\nfor loop inside the CE is an asynchronous loop that awaits each element:\nlet labelEvenOdd (input: TaskSeq\u0026lt;int\u0026gt;) : TaskSeq\u0026lt;string\u0026gt; =\n taskSeq {\n for n in input do\n if n % 2 = 0 then\n do! Task.Delay 10 // simulate async work\n yield $\u0026quot;Even: {n}\u0026quot;\n else\n yield $\u0026quot;Odd: {n}\u0026quot;\n }\n\nInside taskSeq { ... } you can freely mix synchronous logic, let!/do! awaits, loops,\nand conditionals.\n\nmap and mapAsync\nTaskSeq.map applies a synchronous function to every element:\nlet numbers : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofSeq (seq { 1..5 })\n\nlet doubled : TaskSeq\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.map (fun n -\u0026gt; n * 2)\n\nTaskSeq.mapAsync is the same but the projection returns Task\u0026lt;\u0027U\u0026gt;, allowing async work per\nelement \u2014 for example, a database lookup or HTTP request:\nlet fetchDescription (n: int) : Task\u0026lt;string\u0026gt; =\n task { return $\u0026quot;item {n}\u0026quot; } // placeholder for a real async call\n\nlet descriptions : TaskSeq\u0026lt;string\u0026gt; = numbers |\u0026gt; TaskSeq.mapAsync fetchDescription\n\nmapi and mapiAsync\nTaskSeq.mapi and TaskSeq.mapiAsync additionally pass the zero-based index to the mapper:\nlet indexed : TaskSeq\u0026lt;string\u0026gt; =\n numbers |\u0026gt; TaskSeq.mapi (fun i n -\u0026gt; $\u0026quot;[{i}] {n}\u0026quot;)\n\n\nfilter and filterAsync\nTaskSeq.filter keeps only elements satisfying a synchronous predicate:\nlet evens : TaskSeq\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.filter (fun n -\u0026gt; n % 2 = 0)\n\nTaskSeq.filterAsync does the same with an async predicate \u2014 useful when the keep/discard\ndecision requires an async lookup:\nlet isInteresting (n: int) : Task\u0026lt;bool\u0026gt; =\n task { return n \u0026gt; 2 } // placeholder\n\nlet interesting : TaskSeq\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.filterAsync isInteresting\n\nTaskSeq.where and TaskSeq.whereAsync are aliases for filter and filterAsync provided\nfor readability.\n\nchoose and chooseAsync\nTaskSeq.choose applies a function that returns \u0027U option; only Some values are kept and\nthe option wrapper is removed \u2014 it is equivalent to filter \u002B map in a single pass:\nlet strings : TaskSeq\u0026lt;string\u0026gt; =\n TaskSeq.ofList [ \u0026quot;\u0026quot;; \u0026quot;hello\u0026quot;; \u0026quot;\u0026quot;; \u0026quot;world\u0026quot; ]\n\nlet nonEmpty : TaskSeq\u0026lt;string\u0026gt; =\n strings\n |\u0026gt; TaskSeq.choose (fun s -\u0026gt;\n if s.Length \u0026gt; 0 then Some s else None)\n\nTaskSeq.chooseAsync accepts an async chooser:\nlet parseAsync (s: string) : Task\u0026lt;int option\u0026gt; =\n task {\n match System.Int32.TryParse s with\n | true, n -\u0026gt; return Some n\n | _ -\u0026gt; return None\n }\n\nlet parsed : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.ofList [ \u0026quot;1\u0026quot;; \u0026quot;two\u0026quot;; \u0026quot;3\u0026quot; ]\n |\u0026gt; TaskSeq.chooseAsync parseAsync\n\n\ncollect and collectSeq\nTaskSeq.collect is the monadic bind for TaskSeq: it maps each element to a new task\nsequence and concatenates all the results end-to-end:\nlet words : TaskSeq\u0026lt;string\u0026gt; =\n TaskSeq.ofList [ \u0026quot;foo bar\u0026quot;; \u0026quot;baz qux\u0026quot; ]\n\nlet chars : TaskSeq\u0026lt;string\u0026gt; =\n words\n |\u0026gt; TaskSeq.collectSeq (fun sentence -\u0026gt;\n sentence.Split(\u0026#39; \u0026#39;) |\u0026gt; Array.toSeq)\n\nTaskSeq.collect maps to another TaskSeq\u0026lt;\u0027U\u0026gt;, while TaskSeq.collectSeq maps to a plain\nseq\u0026lt;\u0027U\u0026gt;. Async variants TaskSeq.collectAsync and TaskSeq.collectSeqAsync accept mappers\nthat return tasks.\n\nindexed\nTaskSeq.indexed pairs each element with its zero-based index, returning a\nTaskSeq\u0026lt;int * \u0027T\u0026gt;:\nlet withIndex : TaskSeq\u0026lt;int * string\u0026gt; =\n TaskSeq.ofList [ \u0026quot;a\u0026quot;; \u0026quot;b\u0026quot;; \u0026quot;c\u0026quot; ] |\u0026gt; TaskSeq.indexed\n\n// yields (0,\u0026quot;a\u0026quot;), (1,\u0026quot;b\u0026quot;), (2,\u0026quot;c\u0026quot;)\n\n\nType conversions\nTaskSeq.cast casts items from TaskSeq\u0026lt;obj\u0026gt; to a target reference type. For value types use\nTaskSeq.unbox:\nlet boxed : TaskSeq\u0026lt;obj\u0026gt; =\n TaskSeq.ofList [ box 1; box 2; box 3 ]\n\nlet unboxed : TaskSeq\u0026lt;int\u0026gt; = boxed |\u0026gt; TaskSeq.unbox\u0026lt;int\u0026gt;\n\nlet castToString : TaskSeq\u0026lt;string\u0026gt; =\n TaskSeq.ofList [ box \u0026quot;hello\u0026quot;; box \u0026quot;world\u0026quot; ]\n |\u0026gt; TaskSeq.cast\u0026lt;string\u0026gt;\n\n","headings":["Transforming Task Sequences","Transforming with a computation expression","map and mapAsync","mapi and mapiAsync","filter and filterAsync","choose and chooseAsync","collect and collectSeq","indexed","Type conversions"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/TaskSeqCombining.html","title":"Combining Task Sequences","content":"\nCombining Task Sequences\nThis page covers operations that combine multiple sequences or reshape a single sequence: append,\nzip, zipWith, concat, slicing with take/skip/splitAt, chunking and windowing.\nopen FSharp.Control\n\n\nAppend\nTaskSeq.append produces all elements of the first sequence followed by all elements of the\nsecond. The second sequence does not start until the first is exhausted:\nlet first = TaskSeq.ofList [ 1; 2; 3 ]\nlet second = TaskSeq.ofList [ 4; 5; 6 ]\n\nlet appended : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.append first second // 1, 2, 3, 4, 5, 6\n\nInside taskSeq { ... }, yield! is the natural way to concatenate:\nlet combined = taskSeq {\n yield! first\n yield! second\n}\n\nTaskSeq.appendSeq appends a plain seq\u0026lt;\u0027T\u0026gt; after a task sequence.\nTaskSeq.prependSeq prepends a plain seq\u0026lt;\u0027T\u0026gt; before a task sequence:\nlet withPrefix : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.prependSeq [ 0 ] first // 0, 1, 2, 3\nlet withSuffix : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.appendSeq first [ 4; 5 ] // 1, 2, 3, 4, 5\n\n\nconcat\nTaskSeq.concat flattens a task sequence of task sequences into a single flat sequence.\nEach inner sequence is consumed fully before the next one begins:\nlet nested : TaskSeq\u0026lt;TaskSeq\u0026lt;int\u0026gt;\u0026gt; =\n TaskSeq.ofList\n [ TaskSeq.ofList [ 1; 2 ]\n TaskSeq.ofList [ 3; 4 ]\n TaskSeq.ofList [ 5; 6 ] ]\n\nlet flat : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.concat nested // 1, 2, 3, 4, 5, 6\n\nOverloads also exist for TaskSeq\u0026lt;seq\u0026lt;\u0027T\u0026gt;\u0026gt;, TaskSeq\u0026lt;\u0027T list\u0026gt;, TaskSeq\u0026lt;\u0027T[]\u0026gt;, and\nTaskSeq\u0026lt;ResizeArray\u0026lt;\u0027T\u0026gt;\u0026gt;.\n\nzip and zip3\nTaskSeq.zip pairs up elements from two sequences, stopping when the shorter sequence ends:\nlet letters : TaskSeq\u0026lt;char\u0026gt; = TaskSeq.ofList [ \u0026#39;a\u0026#39;; \u0026#39;b\u0026#39;; \u0026#39;c\u0026#39; ]\nlet nums : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 3; 4 ]\n\nlet pairs : TaskSeq\u0026lt;char * int\u0026gt; = TaskSeq.zip letters nums\n// (\u0026#39;a\u0026#39;,1), (\u0026#39;b\u0026#39;,2), (\u0026#39;c\u0026#39;,3) \u2014 stops when letters runs out\n\nTaskSeq.zip3 does the same for three sequences:\nlet booleans : TaskSeq\u0026lt;bool\u0026gt; = TaskSeq.ofList [ true; false; true ]\n\nlet triples : TaskSeq\u0026lt;char * int * bool\u0026gt; = TaskSeq.zip3 letters nums booleans\n\n\nzipWith and zipWithAsync\nTaskSeq.zipWith is like zip but applies a mapping function to produce a result instead of\nyielding a tuple. The result sequence stops when the shorter source ends:\nlet addPairs : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.zipWith (\u002B) nums nums\n// 2, 4, 6, 8\n\nTaskSeq.zipWithAsync accepts an asynchronous mapping function:\nlet asyncProduct : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.zipWithAsync (fun a b -\u0026gt; Task.fromResult (a * b)) nums nums\n// 1, 4, 9, 16, ...\n\n\nzipWith3 and zipWithAsync3\nTaskSeq.zipWith3 combines three sequences with a three-argument mapping function, stopping at\nthe shortest:\nlet sumThree : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.zipWith3 (fun a b c -\u0026gt; a \u002B b \u002B c) nums nums nums\n// 3, 6, 9, 12, ...\n\nTaskSeq.zipWithAsync3 takes an asynchronous three-argument mapper:\nlet asyncSumThree : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.zipWithAsync3 (fun a b c -\u0026gt; Task.fromResult (a \u002B b \u002B c)) nums nums nums\n\n\npairwise\nTaskSeq.pairwise produces a sequence of consecutive pairs. An input with fewer than two elements\nproduces an empty result:\nlet consecutive : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 3; 4; 5 ]\n\nlet pairs2 : TaskSeq\u0026lt;int * int\u0026gt; = consecutive |\u0026gt; TaskSeq.pairwise\n// (1,2), (2,3), (3,4), (4,5)\n\n\ntake and truncate\nTaskSeq.take count yields exactly count elements and throws if the source is shorter:\nlet first3 : TaskSeq\u0026lt;int\u0026gt; = consecutive |\u0026gt; TaskSeq.take 3 // 1, 2, 3\n\nTaskSeq.truncate count yields at most count elements without throwing when the source is\nshorter:\nlet atMost10 : TaskSeq\u0026lt;int\u0026gt; = consecutive |\u0026gt; TaskSeq.truncate 10 // 1, 2, 3, 4, 5\n\n\nsplitAt\nTaskSeq.splitAt count splits a sequence into a prefix array and a lazy remainder sequence. The\nprefix always contains at most count elements \u2014 it never throws when the sequence is shorter.\nThe remainder sequence is a lazy view over the unconsumed tail and can be iterated once:\nlet splitData : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1..10 ]\n\nlet splitExample : Task\u0026lt;int[] * TaskSeq\u0026lt;int\u0026gt;\u0026gt; = TaskSeq.splitAt 4 splitData\n// prefix = [|1;2;3;4|], rest = lazy 5,6,7,8,9,10\n\nUnlike take/skip, a single splitAt call evaluates elements only once \u2014 the prefix is\nmaterialised eagerly and the rest is yielded lazily without re-reading the source.\n\nskip and drop\nTaskSeq.skip count skips exactly count elements and throws if the source is shorter:\nlet afterFirst2 : TaskSeq\u0026lt;int\u0026gt; = consecutive |\u0026gt; TaskSeq.skip 2 // 3, 4, 5\n\nTaskSeq.drop count drops at most count elements without throwing:\nlet safeAfter10 : TaskSeq\u0026lt;int\u0026gt; = consecutive |\u0026gt; TaskSeq.drop 10 // empty\n\n\ntakeWhile and takeWhileInclusive\nTaskSeq.takeWhile predicate yields elements while the predicate is true, then stops (the\nelement that caused the stop is not yielded):\nlet lessThan4 : TaskSeq\u0026lt;int\u0026gt; = consecutive |\u0026gt; TaskSeq.takeWhile (fun n -\u0026gt; n \u0026lt; 4)\n// 1, 2, 3\n\nTaskSeq.takeWhileInclusive yields the first element for which the predicate is false and\nthen stops \u2014 so at least one element is always yielded from a non-empty source:\nlet upToFirstGe4 : TaskSeq\u0026lt;int\u0026gt; =\n consecutive |\u0026gt; TaskSeq.takeWhileInclusive (fun n -\u0026gt; n \u0026lt; 4)\n// 1, 2, 3, 4\n\nAsync variants: TaskSeq.takeWhileAsync, TaskSeq.takeWhileInclusiveAsync.\n\nskipWhile and skipWhileInclusive\nTaskSeq.skipWhile predicate skips elements while the predicate is true, then yields the\nrest (the first failing element is yielded):\nlet from3 : TaskSeq\u0026lt;int\u0026gt; = consecutive |\u0026gt; TaskSeq.skipWhile (fun n -\u0026gt; n \u0026lt; 3)\n// 3, 4, 5\n\nTaskSeq.skipWhileInclusive also skips the first element for which the predicate is false:\nlet afterFirst3 : TaskSeq\u0026lt;int\u0026gt; =\n consecutive |\u0026gt; TaskSeq.skipWhileInclusive (fun n -\u0026gt; n \u0026lt; 3)\n// 4, 5\n\nAsync variants: TaskSeq.skipWhileAsync, TaskSeq.skipWhileInclusiveAsync.\n\nchunkBySize\nTaskSeq.chunkBySize chunkSize divides the sequence into non-overlapping arrays of at most\nchunkSize elements. The last chunk may be smaller if the sequence does not divide evenly:\nlet chunks : TaskSeq\u0026lt;int[]\u0026gt; = consecutive |\u0026gt; TaskSeq.chunkBySize 2\n// [|1;2|], [|3;4|], [|5|]\n\n\nchunkBy and chunkByAsync\nTaskSeq.chunkBy projection groups consecutive elements with the same key into (key, elements[]) pairs.\nA new group starts each time the key changes. Unlike groupBy, elements that are not adjacent are\nnot merged, so the source order is preserved and the sequence can be infinite:\nlet words : TaskSeq\u0026lt;string\u0026gt; = TaskSeq.ofList [ \u0026quot;apple\u0026quot;; \u0026quot;apricot\u0026quot;; \u0026quot;banana\u0026quot;; \u0026quot;blueberry\u0026quot;; \u0026quot;cherry\u0026quot; ]\n\nlet byFirstLetter : TaskSeq\u0026lt;char * string[]\u0026gt; =\n words |\u0026gt; TaskSeq.chunkBy (fun w -\u0026gt; w[0])\n// (\u0026#39;a\u0026#39;, [|\u0026quot;apple\u0026quot;;\u0026quot;apricot\u0026quot;|]), (\u0026#39;b\u0026#39;, [|\u0026quot;banana\u0026quot;;\u0026quot;blueberry\u0026quot;|]), (\u0026#39;c\u0026#39;, [|\u0026quot;cherry\u0026quot;|])\n\nTaskSeq.chunkByAsync accepts an asynchronous projection:\nlet byFirstLetterAsync : TaskSeq\u0026lt;char * string[]\u0026gt; =\n words |\u0026gt; TaskSeq.chunkByAsync (fun w -\u0026gt; Task.fromResult w[0])\n\n\nwindowed\nTaskSeq.windowed windowSize produces a sliding window of exactly windowSize consecutive\nelements. The result is empty if the source has fewer elements than the window size:\nlet windows : TaskSeq\u0026lt;int[]\u0026gt; = consecutive |\u0026gt; TaskSeq.windowed 3\n// [|1;2;3|], [|2;3;4|], [|3;4;5|]\n\nwindowed uses a ring buffer internally, so each window allocation is separate \u2014 safe to\nstore the windows independently.\n","headings":["Combining Task Sequences","Append","concat","zip and zip3","zipWith and zipWithAsync","zipWith3 and zipWithAsync3","pairwise","take and truncate","splitAt","skip and drop","takeWhile and takeWhileInclusive","skipWhile and skipWhileInclusive","chunkBySize","chunkBy and chunkByAsync","windowed"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/TaskSeqConsuming.html","title":"Consuming Task Sequences","content":"\nConsuming Task Sequences\nAll TaskSeq\u0026lt;\u0027T\u0026gt; values are lazy \u2014 they produce elements only when actively consumed. This\npage covers all the ways to consume a task sequence: iteration with side effects, collection\ninto arrays and lists, folding, aggregation, searching, and element access.\nopen System.Threading.Tasks\nopen FSharp.Control\n\nlet numbers : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofSeq (seq { 1..5 })\n\n\nIterating with a for loop\nInside a task { ... } or taskSeq { ... } computation expression, you can iterate a\nTaskSeq\u0026lt;\u0027T\u0026gt; with a plain for loop. The loop body may contain let! and do!:\ntask {\n for n in numbers do\n printfn \u0026quot;Got %d\u0026quot; n\n}\n|\u0026gt; Task.WaitAll\n\n\niter and iterAsync\nTaskSeq.iter applies a synchronous side-effecting function to every element:\nlet printAll : Task\u0026lt;unit\u0026gt; = numbers |\u0026gt; TaskSeq.iter (printfn \u0026quot;item: %d\u0026quot;)\n\nTaskSeq.iterAsync awaits the returned task before consuming the next element \u2014 ideal for\nactions that themselves do IO, such as writing to a database:\nlet processItem (n: int) : Task\u0026lt;unit\u0026gt; =\n task { printfn \u0026quot;processing %d\u0026quot; n }\n\nlet processAll : Task\u0026lt;unit\u0026gt; = numbers |\u0026gt; TaskSeq.iterAsync processItem\n\niteri and iteriAsync\nTaskSeq.iteri and TaskSeq.iteriAsync additionally pass the zero-based index to the action:\nlet printWithIndex : Task\u0026lt;unit\u0026gt; =\n numbers |\u0026gt; TaskSeq.iteri (fun i n -\u0026gt; printfn \u0026quot;[%d] %d\u0026quot; i n)\n\n\nCollecting into arrays and lists\nTaskSeq.toArrayAsync and TaskSeq.toListAsync consume the whole sequence into an in-memory\ncollection. The blocking (synchronous) variants toArray, toList, and toSeq are also\navailable when you need them in a synchronous context:\nlet arr : Task\u0026lt;int[]\u0026gt; = numbers |\u0026gt; TaskSeq.toArrayAsync\nlet lst : Task\u0026lt;int list\u0026gt; = numbers |\u0026gt; TaskSeq.toListAsync\nlet rz : Task\u0026lt;System.Collections.Generic.List\u0026lt;int\u0026gt;\u0026gt; = numbers |\u0026gt; TaskSeq.toResizeArrayAsync\n\n// Blocking variants (avoid in async code)\nlet arrSync : int[] = numbers |\u0026gt; TaskSeq.toArray\nlet lstSync : int list = numbers |\u0026gt; TaskSeq.toList\n\n\nfold and foldAsync\nTaskSeq.fold threads an accumulator through the sequence, returning the final state:\nlet sum : Task\u0026lt;int\u0026gt; =\n numbers |\u0026gt; TaskSeq.fold (fun acc n -\u0026gt; acc \u002B n) 0\n\nlet concat : Task\u0026lt;string\u0026gt; =\n TaskSeq.ofList [ \u0026quot;hello\u0026quot;; \u0026quot; \u0026quot;; \u0026quot;world\u0026quot; ]\n |\u0026gt; TaskSeq.fold (fun acc s -\u0026gt; acc \u002B s) \u0026quot;\u0026quot;\n\nTaskSeq.foldAsync is the same but the folder returns Task\u0026lt;\u0027State\u0026gt;:\nlet sumAsync : Task\u0026lt;int\u0026gt; =\n numbers\n |\u0026gt; TaskSeq.foldAsync (fun acc n -\u0026gt; task { return acc \u002B n }) 0\n\n\nscan and scanAsync\nTaskSeq.scan is like fold but emits each intermediate state as a new element. The output\nsequence has N \u002B 1 elements when the input has N, because the initial state is also\nemitted:\nlet runningTotals : TaskSeq\u0026lt;int\u0026gt; =\n numbers |\u0026gt; TaskSeq.scan (fun acc n -\u0026gt; acc \u002B n) 0\n\n// yields 0, 1, 3, 6, 10, 15\n\n\nreduce and reduceAsync\nTaskSeq.reduce uses the first element as the initial state \u2014 there is no extra zero argument:\nlet product : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.reduce (fun acc n -\u0026gt; acc * n)\n\n\nAggregation: sum, average, min, max\nNumeric aggregates follow the same pattern as the Seq module:\nlet total : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.sum\n\nlet avg : Task\u0026lt;float\u0026gt; =\n TaskSeq.ofList [ 1.0; 2.0; 3.0 ] |\u0026gt; TaskSeq.average\n\nlet biggest : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.max\nlet smallest : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.min\n\nsumBy, averageBy, maxBy, and minBy apply a projection first. Async variants\nsumByAsync, averageByAsync, maxByAsync, and minByAsync are also available:\nlet sumOfSquares : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.sumBy (fun n -\u0026gt; n * n)\n\n\nlength and isEmpty\nTaskSeq.length consumes the whole sequence. Use TaskSeq.lengthOrMax to avoid evaluating\nmore than a known upper bound \u2014 useful for infinite sequences or for early termination:\nlet len : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.length // 5\n\nlet atMost3 : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.lengthOrMax 3 // 3 (stops early)\n\nlet empty : Task\u0026lt;bool\u0026gt; = numbers |\u0026gt; TaskSeq.isEmpty // false\n\nTaskSeq.lengthBy counts elements satisfying a predicate in a single pass:\nlet countEvens : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.lengthBy (fun n -\u0026gt; n % 2 = 0)\n\n\nElement access: head, last, item, exactlyOne, firstOrDefault, lastOrDefault\nlet first : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.head // 1\nlet last : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.last // 5\nlet third : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.item 2 // 3 (zero-based)\nlet only : Task\u0026lt;int\u0026gt; = TaskSeq.singleton 42 |\u0026gt; TaskSeq.exactlyOne // 42\n\n// Safe \u0026quot;try\u0026quot; variants return None instead of throwing:\nlet tryFirst : Task\u0026lt;int option\u0026gt; = numbers |\u0026gt; TaskSeq.tryHead\nlet tryLast : Task\u0026lt;int option\u0026gt; = numbers |\u0026gt; TaskSeq.tryLast\nlet tryThird : Task\u0026lt;int option\u0026gt; = numbers |\u0026gt; TaskSeq.tryItem 2\nlet tryOnly : Task\u0026lt;int option\u0026gt; = TaskSeq.singleton 42 |\u0026gt; TaskSeq.tryExactlyOne\n\nTaskSeq.firstOrDefault and TaskSeq.lastOrDefault return a caller-supplied default when the\nsequence is empty \u2014 useful as a concise alternative to tryHead/tryLast when None would\nneed to be immediately unwrapped:\nlet firstOrZero : Task\u0026lt;int\u0026gt; = TaskSeq.empty\u0026lt;int\u0026gt; |\u0026gt; TaskSeq.firstOrDefault 0 // 0\nlet lastOrZero : Task\u0026lt;int\u0026gt; = TaskSeq.empty\u0026lt;int\u0026gt; |\u0026gt; TaskSeq.lastOrDefault 0 // 0\n\nlet firstOrMinus1 : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.firstOrDefault -1 // 1\nlet lastOrMinus1 : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.lastOrDefault -1 // 5\n\n\nSearching: find, pick, contains, exists, forall\nTaskSeq.find returns the first element satisfying a predicate, or throws if none is found.\nTaskSeq.tryFind returns None instead of throwing:\nlet firstEven : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.find (fun n -\u0026gt; n % 2 = 0)\n\nlet maybeEven : Task\u0026lt;int option\u0026gt; = numbers |\u0026gt; TaskSeq.tryFind (fun n -\u0026gt; n % 2 = 0)\n\nTaskSeq.findIndex and TaskSeq.tryFindIndex return the zero-based index:\nlet indexOfFirst3 : Task\u0026lt;int\u0026gt; = numbers |\u0026gt; TaskSeq.findIndex (fun n -\u0026gt; n = 3)\n\nTaskSeq.pick and TaskSeq.tryPick are like find but the predicate also projects to a new\nvalue \u2014 equivalent to a combined choose \u002B head:\nlet firstSquareOver10 : Task\u0026lt;int option\u0026gt; =\n numbers\n |\u0026gt; TaskSeq.tryPick (fun n -\u0026gt;\n let sq = n * n\n if sq \u0026gt; 10 then Some sq else None)\n\nTaskSeq.contains tests membership by equality. TaskSeq.exists tests with a predicate.\nTaskSeq.forall tests that all elements satisfy a predicate:\nlet has3 : Task\u0026lt;bool\u0026gt; = numbers |\u0026gt; TaskSeq.contains 3\n\nlet anyNegative : Task\u0026lt;bool\u0026gt; = numbers |\u0026gt; TaskSeq.exists (fun n -\u0026gt; n \u0026lt; 0)\n\nlet allPositive : Task\u0026lt;bool\u0026gt; = numbers |\u0026gt; TaskSeq.forall (fun n -\u0026gt; n \u0026gt; 0)\n\nAll search/predicate operations have Async variants (findAsync, existsAsync,\nforallAsync, etc.) that accept a predicate returning Task\u0026lt;bool\u0026gt;.\n","headings":["Consuming Task Sequences","Iterating with a for loop","iter and iterAsync","iteri and iteriAsync","Collecting into arrays and lists","fold and foldAsync","scan and scanAsync","reduce and reduceAsync","Aggregation: sum, average, min, max","length and isEmpty","Element access: head, last, item, exactlyOne, firstOrDefault, lastOrDefault","Searching: find, pick, contains, exists, forall"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/TaskSeqGenerating.html","title":"Generating Task Sequences","content":"\nGenerating Task Sequences\nThis page covers the main ways to create TaskSeq\u0026lt;\u0027T\u0026gt; values: the taskSeq computation\nexpression, factory functions such as TaskSeq.init and TaskSeq.unfold, and conversion\nfunctions that wrap existing collections.\nopen System.Threading.Tasks\nopen FSharp.Control\n\nComputation Expression Syntax\ntaskSeq { ... } is a computation expression that lets you write asynchronous sequences\nusing familiar F# constructs. Under the hood it compiles to a resumable state machine, so\nthere is no allocation per element.\nYielding values\nUse yield to emit a single value and yield! to splice in another sequence:\nlet helloWorld = taskSeq {\n yield \u0026quot;hello\u0026quot;\n yield \u0026quot;world\u0026quot;\n}\n\nlet combined = taskSeq {\n yield! helloWorld\n yield \u0026quot;!\u0026quot;\n}\n\nConditionals\nif/then/else works just like in ordinary F#:\nlet evenNumbers = taskSeq {\n for i in 1..10 do\n if i % 2 = 0 then\n yield i\n}\n\nMatch expressions\nmatch expressions are fully supported:\ntype Shape =\n | Circle of radius: float\n | Rectangle of width: float * height: float\n\nlet areas = taskSeq {\n for shape in [ Circle 3.0; Rectangle(4.0, 5.0); Circle 1.5 ] do\n match shape with\n | Circle r -\u0026gt; yield System.Math.PI * r * r\n | Rectangle(w, h) -\u0026gt; yield w * h\n}\n\nFor loops\nfor iterates over any seq\u0026lt;\u0027T\u0026gt;/IEnumerable\u0026lt;\u0027T\u0026gt; synchronously, or over another\nTaskSeq\u0026lt;\u0027T\u0026gt; asynchronously:\nlet squaresOfList = taskSeq {\n for n in [ 1; 2; 3; 4; 5 ] do\n yield n * n\n}\n\n// Iterate another TaskSeq\nlet doubled = taskSeq {\n for n in squaresOfList do\n yield n * 2\n}\n\nWhile loops\nwhile emits elements until a condition becomes false. Async operations can appear in the\nloop body:\nlet countdown = taskSeq {\n let mutable i = 5\n\n while i \u0026gt; 0 do\n yield i\n do! Task.Delay 100\n i \u0026lt;- i - 1\n}\n\nAwaiting tasks with let! and do!\nInside taskSeq { ... } you can await any Task\u0026lt;\u0027T\u0026gt; with let! and any Task\u0026lt;unit\u0026gt; with\ndo!:\nlet fetchData (url: string) : Task\u0026lt;string\u0026gt; =\n task { return $\u0026quot;data from {url}\u0026quot; } // placeholder\n\nlet results = taskSeq {\n for url in [ \u0026quot;https://example.com/a\u0026quot;; \u0026quot;https://example.com/b\u0026quot; ] do\n let! data = fetchData url\n yield data\n}\n\nUse bindings and try / with\nuse and use! dispose the resource when the sequence finishes or is abandoned. try/with\nand try/finally work as expected:\nlet withResource = taskSeq {\n use resource = { new System.IDisposable with member _.Dispose() = () } // placeholder\n yield 1\n yield 2\n}\n\nlet withErrorHandling = taskSeq {\n try\n yield 1\n failwith \u0026quot;oops\u0026quot;\n yield 2\n with ex -\u0026gt;\n yield -1\n}\n\n\ninit and initInfinite\nTaskSeq.init count initializer generates count elements by calling initializer with the\nzero-based index:\n// [| 0; 1; 4; 9; 16 |]\nlet squares : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.init 5 (fun i -\u0026gt; i * i)\n\n// With an async initializer\nlet asyncSquares : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.initAsync 5 (fun i -\u0026gt; task { return i * i })\n\nTaskSeq.initInfinite generates an unbounded sequence \u2014 use TaskSeq.take or\nTaskSeq.takeWhile to limit consumption:\nlet naturals : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.initInfinite id\n\nlet first10 : TaskSeq\u0026lt;int\u0026gt; = naturals |\u0026gt; TaskSeq.take 10 // 0 .. 9\n\n\nunfold\nTaskSeq.unfold derives a sequence from a state value. Each call to the generator returns\neither None (end) or Some (element, nextState):\n// 0, 1, 2, ... up to but not including 5\nlet counting : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.unfold\n (fun state -\u0026gt;\n if state \u0026lt; 5 then\n Some(state, state \u002B 1)\n else\n None)\n 0\n\n// Same with an async generator\nlet countingAsync : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.unfoldAsync\n (fun state -\u0026gt;\n task {\n if state \u0026lt; 5 then\n return Some(state, state \u002B 1)\n else\n return None\n })\n 0\n\n\nsingleton, replicate, replicateInfinite, and empty\nlet one : TaskSeq\u0026lt;string\u0026gt; = TaskSeq.singleton \u0026quot;hello\u0026quot;\n\nlet fives : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.replicate 3 5 // 5, 5, 5\n\nlet nothing : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.empty\u0026lt;int\u0026gt;\n\nTaskSeq.replicateInfinite yields a constant value indefinitely. Always combine it with a\nbounding operation such as take or takeWhile:\nlet infinitePings : TaskSeq\u0026lt;string\u0026gt; = TaskSeq.replicateInfinite \u0026quot;ping\u0026quot;\n\nlet first10pings : TaskSeq\u0026lt;string\u0026gt; = infinitePings |\u0026gt; TaskSeq.take 10\n\nTaskSeq.replicateInfiniteAsync calls a function on every step, useful for polling or streaming\nside-effectful sources:\nlet mutable counter = 0\n\nlet pollingSeq : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.replicateInfiniteAsync (fun () -\u0026gt;\n task {\n counter \u0026lt;- counter \u002B 1\n return counter\n })\n\nlet first5counts : TaskSeq\u0026lt;int\u0026gt; = pollingSeq |\u0026gt; TaskSeq.take 5\n\nTaskSeq.replicateUntilNoneAsync stops when the function returns None, making it easy to\nwrap a pull-based source that signals end-of-stream with None:\nlet readLine (reader: System.IO.TextReader) =\n TaskSeq.replicateUntilNoneAsync (fun () -\u0026gt;\n task {\n let! line = reader.ReadLineAsync()\n return if line = null then None else Some line\n })\n\n\ndelay\nTaskSeq.delay creates a sequence whose body is not evaluated until iteration starts. This\nis useful when the sequence depends on side-effectful initialisation:\nlet deferred =\n TaskSeq.delay (fun () -\u0026gt;\n taskSeq {\n printfn \u0026quot;sequence started\u0026quot;\n yield! [ 1; 2; 3 ]\n })\n\n\nConverting from existing collections\nAll of these produce a TaskSeq\u0026lt;\u0027T\u0026gt; that replays the source on each iteration:\nlet fromArray : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofArray [| 1; 2; 3 |]\nlet fromList : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofList [ 1; 2; 3 ]\nlet fromSeq : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofSeq (seq { 1..3 })\nlet fromResizeArray : TaskSeq\u0026lt;int\u0026gt; = TaskSeq.ofResizeArray (System.Collections.Generic.List\u0026lt;int\u0026gt;([ 1; 2; 3 ]))\n\nYou can also wrap existing task or async collections. Note that wrapping a list of already\nstarted Tasks does not guarantee sequential execution\u2014the tasks are already running:\n// Sequence of not-yet-started task factories (safe)\nlet fromTaskSeq : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.ofTaskSeq (seq { yield task { return 1 }; yield task { return 2 } })\n\n// Sequence of asyncs (each started on demand as the sequence is consumed)\nlet fromAsyncSeq : TaskSeq\u0026lt;int\u0026gt; =\n TaskSeq.ofAsyncSeq (seq { yield async { return 1 }; yield async { return 2 } })\n\n","headings":["Generating Task Sequences","Computation Expression Syntax","Yielding values","Conditionals","Match expressions","For loops","While loops","Use bindings and try / with","init and initInfinite","unfold","singleton, replicate, replicateInfinite, and empty","delay","Converting from existing collections"],"type":"content"},{"uri":"https://fsprojects.github.io/FSharp.Control.TaskSeq/index.html","title":"FSharp.Control.TaskSeq\n","content":"FSharp.Control.TaskSeq\nFSharp.Control.TaskSeq provides a taskSeq computation expression for IAsyncEnumerable\u0026lt;\u0027T\u0026gt;,\nalong with a comprehensive TaskSeq module.\nAn task sequence is an asynchronous sequence in which individual elements are awaited:\nthe next element is not necessarily available immediately.\nUnder the hood each taskSeq { ... } is an IAsyncEnumerable\u0026lt;\u0027T\u0026gt; \u2014 the .NET standard\ninterface used by C# await foreach, Entity Framework Core, gRPC streaming, and many other\nlibraries in the ecosystem.\nQuick Start\nAdd the NuGet package FSharp.Control.TaskSeq\nto your project and open the namespace:\n// #r \u0026quot;nuget: FSharp.Control.TaskSeq\u0026quot;\n\nopen FSharp.Control\n\nA TaskSeq\u0026lt;\u0027T\u0026gt; can be created with the taskSeq { ... } computation expression:\nlet oneThenTwo = taskSeq {\n yield 1\n do! Task.Delay 1000 // non-blocking sleep\n yield 2\n}\n\nWhen iterated, the sequence above yields 1 immediately and 2 after one second. Consumers\nmust await each step.\nUse await foreach in C#, or any TaskSeq consumer in F#:\n// Iterate with a for loop inside a task { ... }\ntask {\n for item in oneThenTwo do\n printfn \u0026quot;Got %d\u0026quot; item\n} |\u0026gt; Task.Run |\u0026gt; ignore\n\n// Or use TaskSeq.iter\ndo! oneThenTwo |\u0026gt; TaskSeq.iter (printfn \u0026quot;Got %d\u0026quot;)\n\nTopics\n\nGenerating sequences \u2014 taskSeq { }, init, unfold, ofArray, \u2026\nTransforming sequences \u2014 map, filter, choose, collect, \u2026\nConsuming sequences \u2014 iter, fold, find, toArray, sum, \u2026\nCombining sequences \u2014 append, zip, take, skip, chunkBySize, \u2026\nAdvanced operations \u2014 groupBy, mapFold, distinct, partition, \u2026\n\nComparison with FSharp.Control.AsyncSeq\nFSharp.Control.AsyncSeq is the\npredecessor library, oriented towards Async\u0026lt;\u0027T\u0026gt;.\nBoth libraries implement IAsyncEnumerable\u0026lt;\u0027T\u0026gt; so they are interoperable.\nThe main differences are:\n\n\n\n\nTaskSeq\nAsyncSeq\n\n\n\n\nAsync model\nTask / ValueTask\nAsync\n\n\nPerformance\nHigher (resumable state machines)\nGood\n\n\n.NET interop\nNative IAsyncEnumerable\u0026lt;\u0027T\u0026gt;\nNative IAsyncEnumerable\u0026lt;\u0027T\u0026gt;\n\n\nCancellation\nCancellationToken via withCancellation\nBuilt in to Async\n\n\n\n\nRelated links\n\nNuGet package\nGitHub repository\nRelease notes\nAPI reference\n\n","headings":["FSharp.Control.TaskSeq","Quick Start","Topics","Comparison with FSharp.Control.AsyncSeq","Related links"],"type":"content"}] \ No newline at end of file diff --git a/reference/fsharp-control-async.html b/reference/fsharp-control-async.html new file mode 100644 index 00000000..e22b804c --- /dev/null +++ b/reference/fsharp-control-async.html @@ -0,0 +1,780 @@ + + + + + + + + + + + + + + + + + + Async (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
              +
              + + + Header menu logo + FSharp.Control.TaskSeq + +
              +
              + + + + + +
              +
              + +
              +
              +
              +

              + Async Module +

              +
              +
              + Namespace: + + FSharp.Control + +
              +
              + Assembly: FSharp.Control.TaskSeq.dll +
              +
              +
              +
              +
              +

              + +

              +
              +
              +
              +
              +

              + Functions and values +

              + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
              + Function or value + + Description + +
              +
              + +

              + + + bind binder async + + +

              +               +
              +
              + Full Usage: + bind binder async +
              +
              + Parameters: +
                + + + binder + + : + 'T -> Async<'U> + +
                + + + async + + : + Async<'T> + +
                +
              +
              + + Returns: + Async<'U> + +
              + Modifiers: + inline +
              + Type parameters: + 'T, 'U +
              +
              +
              +               		+
              + +
              +
              +

              + Bind an Async<'T> +

              +
              +
              + + + +
              + +
              +
              + +
              +
              +
              +               +
              +
              + + binder + + : + 'T -> Async<'U> +
              +
              +
              + + async + + : + Async<'T> +
              +
              +
              +
              +
              + + Returns: + + Async<'U> +
              +
              +
              +
              +
              +
              + +

              + + + ignore async + + +

              +               +
              +
              + Full Usage: + ignore async +
              +
              + Parameters: +
                + + + async + + : + Async<'T> + +
                +
              +
              + + Returns: + Async<unit> + +
              + Modifiers: + inline +
              + Type parameters: + 'T +
              +
              +
              +               		+
              + +
              +
              +

              + Convert an Async<'T> into an Async, ignoring the result +

              +
              +
              + + + +
              + +
              +
              + +
              +
              +
              +               +
              +
              + + async + + : + Async<'T> +
              +
              +
              +
              +
              + + Returns: + + Async<unit> +
              +
              +
              +
              +
              +
              + +

              + + + map mapper async + + +

              +               +
              +
              + Full Usage: + map mapper async +
              +
              + Parameters: +
                + + + mapper + + : + 'T -> 'U + +
                + + + async + + : + Async<'T> + +
                +
              +
              + + Returns: + Async<'U> + +
              + Modifiers: + inline +
              + Type parameters: + 'T, 'U +
              +
              +
              +               		+
              + +
              +
              +

              + Map an Async<'T> +

              +
              +
              + + + +
              + +
              +
              + +
              +
              +
              +               +
              +
              + + mapper + + : + 'T -> 'U +
              +
              +
              + + async + + : + Async<'T> +
              +
              +
              +
              +
              + + Returns: + + Async<'U> +
              +
              +
              +
              +
              +
              + +

              + + + ofTask task + + +

              +               +
              +
              + Full Usage: + ofTask task +
              +
              + Parameters: +
                + + + task + + : + Task<'T> + +
                +
              +
              + + Returns: + Async<'T> + +
              + Modifiers: + inline +
              + Type parameters: + 'T +
              +
              +
              +               		+
              + +
              +
              +

              + Convert an Task<'T> into an Async<'T> +

              +
              +
              + + + +
              + +
              +
              + +
              +
              +
              +               +
              +
              + + task + + : + Task<'T> +
              +
              +
              +
              +
              + + Returns: + + Async<'T> +
              +
              +
              +
              +
              +
              + +

              + + + ofUnitTask task + + +

              +               +
              +
              + Full Usage: + ofUnitTask task +
              +
              + Parameters: +
                + + + task + + : + Task + +
                +
              +
              + + Returns: + Async<unit> + +
              + Modifiers: + inline +
              +
              +
              +
              +               		+
              + +
              +
              +

              + Convert a non-generic Task into an Async +

              +
              +
              + + + +
              + +
              +
              + +
              +
              +
              +               +
              +
              + + task + + : + Task +
              +
              +
              +
              +
              + + Returns: + + Async<unit> +
              +
              +
              +
              +
              +
              + +

              + + + toTask async + + +

              +               +
              +
              + Full Usage: + toTask async +
              +
              + Parameters: +
                + + + async + + : + Async<'T> + +
                +
              +
              + + Returns: + Task<'T> + +
              + Modifiers: + inline +
              + Type parameters: + 'T +
              +
              +
              +               		+
              + +
              +
              +

              + Starts the `Async<'T>` computation, returning the associated `Task<'T>` +

              +
              +
              + + + +
              + +
              +
              + +
              +
              +
              +               +
              +
              + + async + + : + Async<'T> +
              +
              +
              +
              +
              + + Returns: + + Task<'T> +
              +
              +
              +
              +
              +
              +
              +
              +
              +
              +
              +
              +
              +
              +
              + +
              +
              + + + +
              +
                +

                Type something to start searching.

                +
                +                 + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-asyncextensions.html b/reference/fsharp-control-asyncextensions.html new file mode 100644 index 00000000..dedc4cbc --- /dev/null +++ b/reference/fsharp-control-asyncextensions.html @@ -0,0 +1,327 @@ + + + + + + + + + + + + + + + + + + AsyncExtensions (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                +
                + + + Header menu logo + FSharp.Control.TaskSeq + +
                +
                + + + + + +
                +
                + +
                +
                +
                +

                + AsyncExtensions Module +

                +
                +
                + Namespace: + + FSharp.Control + +
                +
                + Assembly: FSharp.Control.TaskSeq.dll +
                +
                +
                +
                +
                +

                + +

                +
                +
                +
                +
                +
                +

                + Type extensions +

                + + + + + + + + + + + + + +
                + Type extension + + Description + +
                +
                + +

                + + + this.For + + +

                +                 +
                +
                + Full Usage: + this.For +
                +
                + Parameters: +
                  + + + source + + : + TaskSeq<'T> + +
                  + + + action + + : + 'T -> Async<unit> + +
                  +
                +
                + + Returns: + Async<unit> + +
                +
                +
                +
                +                 		+
                + +
                +
                +

                + + Inside async, iterate over all values of a taskSeq. + +

                +
                +
                + + + +
                + +
                +
                + +
                +
                +
                +                 +

                + Extended Type: + AsyncBuilder +

                +
                +
                + + source + + : + TaskSeq<'T> +
                +
                +
                + + action + + : + 'T -> Async<unit> +
                +
                +
                +
                +
                + + Returns: + + Async<unit> +
                +
                +
                +
                +
                +
                +
                +
                +
                +
                +
                +
                +
                +
                + +
                +
                + + + +
                +
                  +

                  Type something to start searching.

                  +
                  +                   + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-debug.html b/reference/fsharp-control-debug.html new file mode 100644 index 00000000..bb7c1896 --- /dev/null +++ b/reference/fsharp-control-debug.html @@ -0,0 +1,448 @@ + + + + + + + + + + + + + + + + + + Debug (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                  +
                  + + + Header menu logo + FSharp.Control.TaskSeq + +
                  +
                  + + + + + +
                  +
                  + +
                  +
                  +
                  +

                  + Debug Type +

                  +
                  +
                  + Namespace: + + FSharp.Control + +
                  +
                  + Assembly: FSharp.Control.TaskSeq.dll +
                  +
                  + Base Type: + obj +
                  +
                  +
                  +
                  +
                  +

                  + +

                  +
                  +
                  +
                  +
                  +
                  +
                  +
                  +
                  +

                  + Record fields +

                  + + + + + + + + + + + + + +
                  + Record Field + + Description + +
                  +
                  + +

                  + + + verbose + + +

                  +                   +
                  +
                  + Full Usage: + verbose +
                  +
                  + + Field type: + bool option + +
                  + Modifiers: + mutable static +
                  +
                  +
                  +
                  +                   		+
                  +
                  + + + +
                  +
                  +
                  + + Field type: + + bool option +
                  +
                  +
                  +
                  +
                  +
                  +
                  +
                  +
                  +
                  +

                  + Static members +

                  + + + + + + + + + + + + + + + + + +
                  + Static member + + Description + +
                  +
                  + +

                  + + + Debug.logInfo (str, data) + + +

                  +                   +
                  +
                  + Full Usage: + Debug.logInfo (str, data) +
                  +
                  + Parameters: +
                    + + + str + + : + string + +
                    + + + data + + : + 'a + +
                    +
                  +
                  +
                  +
                  +
                  +                   		+
                  + +
                  +
                  +

                  + Log to stdout in DEBUG builds only +

                  +
                  +
                  + + + +
                  + +
                  +
                  + +
                  +
                  +
                  +                   +
                  +
                  + + str + + : + string +
                  +
                  +
                  + + data + + : + 'a +
                  +
                  +
                  +
                  +
                  +
                  + +

                  + + + Debug.logInfo str + + +

                  +                   +
                  +
                  + Full Usage: + Debug.logInfo str +
                  +
                  + Parameters: +
                    + + + str + + : + string + +
                    +
                  +
                  +
                  +
                  +
                  +                   		+
                  + +
                  +
                  +

                  + Log to stdout in DEBUG builds only +

                  +
                  +
                  + + + +
                  + +
                  +
                  + +
                  +
                  +
                  +                   +
                  +
                  + + str + + : + string +
                  +
                  +
                  +
                  +
                  +
                  +
                  + +
                  +
                  + + + +
                  +
                    +

                    Type something to start searching.

                    +
                    +                     + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-highpriority.html b/reference/fsharp-control-highpriority.html new file mode 100644 index 00000000..72721327 --- /dev/null +++ b/reference/fsharp-control-highpriority.html @@ -0,0 +1,412 @@ + + + + + + + + + + + + + + + + + + HighPriority (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                    +
                    + + + Header menu logo + FSharp.Control.TaskSeq + +
                    +
                    + + + + + +
                    +
                    + +
                    +
                    +
                    +

                    + HighPriority Module +

                    +
                    +
                    + Namespace: + + FSharp.Control + +
                    +
                    + Assembly: FSharp.Control.TaskSeq.dll +
                    +
                    +
                    +
                    +
                    +

                    + + Contains low priority extension methods for the main builder class for the taskSeq computation expression. + The LowPriority, MediumPriority and HighPriority modules are not meant to be + accessed directly from user code. They solely serve to disambiguate overload resolution inside the taskSeq computation expression. + +

                    +
                    +
                    +
                    +
                    +
                    +

                    + Type extensions +

                    + + + + + + + + + + + + + + + + + +
                    + Type extension + + Description + +
                    +
                    + +

                    + + + this.Bind + + +

                    +                     +
                    +
                    + Full Usage: + this.Bind +
                    +
                    + Parameters: +
                      + + + task + + : + Task<'T> + +
                      + + + continuation + + : + 'T -> ResumableTSC<'U> + +
                      +
                    +
                    + + Returns: + ResumableTSC<'U> + +
                    + Modifiers: + inline +
                    + Type parameters: + 'T, 'U +
                    +
                    +
                    +                     		+
                    +
                    + + + +
                    +

                    + Extended Type: + TaskSeqBuilder +

                    +
                    +
                    + + task + + : + Task<'T> +
                    +
                    +
                    + + continuation + + : + 'T -> ResumableTSC<'U> +
                    +
                    +
                    +
                    +
                    + + Returns: + + ResumableTSC<'U> +
                    +
                    +
                    +
                    +
                    +
                    + +

                    + + + this.Bind + + +

                    +                     +
                    +
                    + Full Usage: + this.Bind +
                    +
                    + Parameters: +
                      + + + computation + + : + Async<'T> + +
                      + + + continuation + + : + 'T -> ResumableTSC<'U> + +
                      +
                    +
                    + + Returns: + ResumableTSC<'U> + +
                    + Modifiers: + inline +
                    + Type parameters: + 'T, 'U +
                    +
                    +
                    +                     		+
                    +
                    + + + +
                    +

                    + Extended Type: + TaskSeqBuilder +

                    +
                    +
                    + + computation + + : + Async<'T> +
                    +
                    +
                    + + continuation + + : + 'T -> ResumableTSC<'U> +
                    +
                    +
                    +
                    +
                    + + Returns: + + ResumableTSC<'U> +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    +
                    + +
                    +
                    + + + +
                    +
                      +

                      Type something to start searching.

                      +
                      +                       + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-internal.html b/reference/fsharp-control-internal.html new file mode 100644 index 00000000..a9be005e --- /dev/null +++ b/reference/fsharp-control-internal.html @@ -0,0 +1,470 @@ + + + + + + + + + + + + + + + + + + Internal (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                      +
                      + + + Header menu logo + FSharp.Control.TaskSeq + +
                      +
                      + + + + + +
                      +
                      + +
                      +
                      +
                      +

                      + Internal Module +

                      +
                      +
                      + Namespace: + + FSharp.Control + +
                      +
                      + Assembly: FSharp.Control.TaskSeq.dll +
                      +
                      +
                      +
                      +
                      +

                      + +

                      +
                      +
                      +
                      +
                      +

                      + Functions and values +

                      + + + + + + + + + + + + + + + + + + + + + +
                      + Function or value + + Description + +
                      +
                      + +

                      + + + initVerbose () + + +

                      +                       +
                      +
                      + Full Usage: + initVerbose () +
                      +
                      + Parameters: +
                        + + + () + + : + unit + +
                        +
                      +
                      + + Returns: + bool + +
                      +
                      +
                      +
                      +                       		+
                      + +
                      +
                      +

                      + + Setting from environment variable TASKSEQ_LOG_VERBOSE, which, + when set, enables (very) verbose printing of flow and state + +

                      +
                      +
                      + + + +
                      + +
                      +
                      + +
                      +
                      +
                      +                       +
                      +
                      + + () + + : + unit +
                      +
                      +
                      +
                      +
                      + + Returns: + + bool +
                      +
                      +
                      +
                      +
                      +
                      + +

                      + + + moveNextRef x + + +

                      +                       +
                      +
                      + Full Usage: + moveNextRef x +
                      +
                      + Parameters: +
                        + + + x + + : + byref<'a> + +
                        +
                      +
                      + Modifiers: + inline +
                      + Type parameters: + 'a +
                      +
                      +
                      +                       		+
                      + +
                      +
                      +

                      + Call MoveNext on an IAsyncStateMachine by reference +

                      +
                      +
                      + + + +
                      + +
                      +
                      + +
                      +
                      +
                      +                       +
                      +
                      + + x + + : + byref<'a> +
                      +
                      +
                      +
                      +
                      +
                      + +

                      + + + raiseNotImpl () + + +

                      +                       +
                      +
                      + Full Usage: + raiseNotImpl () +
                      +
                      + Parameters: +
                        + + + () + + : + unit + +
                        +
                      +
                      + + Returns: + 'a + +
                      + Modifiers: + inline +
                      + Type parameters: + 'a +
                      +
                      +
                      +                       		+
                      + +
                      +
                      +

                      + F# requires that we implement interfaces even on an abstract class. +

                      +
                      +
                      + + + +
                      + +
                      +
                      + +
                      +
                      +
                      +                       +
                      +
                      + + () + + : + unit +
                      +
                      +
                      +
                      +
                      + + Returns: + + 'a +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      +
                      + +
                      +
                      + + + +
                      +
                        +

                        Type something to start searching.

                        +
                        +                         + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-lowpriority.html b/reference/fsharp-control-lowpriority.html new file mode 100644 index 00000000..431e0166 --- /dev/null +++ b/reference/fsharp-control-lowpriority.html @@ -0,0 +1,319 @@ + + + + + + + + + + + + + + + + + + LowPriority (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                        +
                        + + + Header menu logo + FSharp.Control.TaskSeq + +
                        +
                        + + + + + +
                        +
                        + +
                        +
                        +
                        +

                        + LowPriority Module +

                        +
                        +
                        + Namespace: + + FSharp.Control + +
                        +
                        + Assembly: FSharp.Control.TaskSeq.dll +
                        +
                        +
                        +
                        +
                        +

                        + + Contains low priority extension methods for the main builder class for the taskSeq computation expression. + The LowPriority, MediumPriority and HighPriority modules are not meant to be + accessed directly from user code. They solely serve to disambiguate overload resolution inside the taskSeq computation expression. + +

                        +
                        +
                        +
                        +
                        +
                        +

                        + Type extensions +

                        + + + + + + + + + + + + + +
                        + Type extension + + Description + +
                        +
                        + +

                        + + + this.Bind + + +

                        +                         +
                        +
                        + Full Usage: + this.Bind +
                        +
                        + Parameters: +
                          + + + task + + : + ^TaskLike + +
                          + + + continuation + + : + 'T -> ResumableTSC<'U> + +
                          +
                        +
                        + + Returns: + ResumableTSC<'U> + +
                        + Modifiers: + inline +
                        + Type parameters: + ^TaskLike, 'T, 'U, ^Awaiter +
                        +
                        +
                        +                         		+
                        +
                        + + + +
                        +

                        + Extended Type: + TaskSeqBuilder +

                        +
                        +
                        + + task + + : + ^TaskLike +
                        +
                        +
                        + + continuation + + : + 'T -> ResumableTSC<'U> +
                        +
                        +
                        +
                        +
                        + + Returns: + + ResumableTSC<'U> +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        +
                        + +
                        +
                        + + + +
                        +
                          +

                          Type something to start searching.

                          +
                          +                           + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-mediumpriority.html b/reference/fsharp-control-mediumpriority.html new file mode 100644 index 00000000..8a6a3ddb --- /dev/null +++ b/reference/fsharp-control-mediumpriority.html @@ -0,0 +1,659 @@ + + + + + + + + + + + + + + + + + + MediumPriority (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                          +
                          + + + Header menu logo + FSharp.Control.TaskSeq + +
                          +
                          + + + + + +
                          +
                          + +
                          +
                          +
                          +

                          + MediumPriority Module +

                          +
                          +
                          + Namespace: + + FSharp.Control + +
                          +
                          + Assembly: FSharp.Control.TaskSeq.dll +
                          +
                          +
                          +
                          +
                          +

                          + + Contains low priority extension methods for the main builder class for the taskSeq computation expression. + The LowPriority, MediumPriority and HighPriority modules are not meant to be + accessed directly from user code. They solely serve to disambiguate overload resolution inside the taskSeq computation expression. + +

                          +
                          +
                          +
                          +
                          +
                          +

                          + Type extensions +

                          + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                          + Type extension + + Description + +
                          +
                          + +

                          + + + this.For + + +

                          +                           +
                          +
                          + Full Usage: + this.For +
                          +
                          + Parameters: +
                            + + + sequence + + : + 'TElement seq + +
                            + + + body + + : + 'TElement -> ResumableTSC<'T> + +
                            +
                          +
                          + + Returns: + ResumableTSC<'T> + +
                          + Modifiers: + inline +
                          + Type parameters: + 'TElement, 'T +
                          +
                          +
                          +                           		+
                          +
                          + + + +
                          +

                          + Extended Type: + TaskSeqBuilder +

                          +
                          +
                          + + sequence + + : + 'TElement seq +
                          +
                          +
                          + + body + + : + 'TElement -> ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          + + Returns: + + ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          +
                          + +

                          + + + this.For + + +

                          +                           +
                          +
                          + Full Usage: + this.For +
                          +
                          + Parameters: +
                            + + + source + + : + 'a + +
                            + + + body + + : + 'TElement -> ResumableTSC<'T> + +
                            +
                          +
                          + + Returns: + ResumableTSC<'T> + +
                          + Modifiers: + inline +
                          + Type parameters: + 'a, 'TElement, 'T +
                          +
                          +
                          +                           		+
                          +
                          + + + +
                          +

                          + Extended Type: + TaskSeqBuilder +

                          +
                          +
                          + + source + + : + 'a +
                          +
                          +
                          + + body + + : + 'TElement -> ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          + + Returns: + + ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          +
                          + +

                          + + + this.Using + + +

                          +                           +
                          +
                          + Full Usage: + this.Using +
                          +
                          + Parameters: +
                            + + + dispensation + + : + 'Disp + +
                            + + + body + + : + 'Disp -> ResumableTSC<'T> + +
                            +
                          +
                          + + Returns: + ResumableTSC<'T> + +
                          + Modifiers: + inline +
                          + Type parameters: + 'Disp, 'T +
                          +
                          +
                          +                           		+
                          +
                          + + + +
                          +

                          + Extended Type: + TaskSeqBuilder +

                          +
                          +
                          + + dispensation + + : + 'Disp +
                          +
                          +
                          + + body + + : + 'Disp -> ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          + + Returns: + + ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          +
                          + +

                          + + + this.YieldFrom + + +

                          +                           +
                          +
                          + Full Usage: + this.YieldFrom +
                          +
                          + Parameters: +
                            + + + source + + : + 'T seq + +
                            +
                          +
                          + + Returns: + ResumableTSC<'T> + +
                          + Modifiers: + inline +
                          + Type parameters: + 'T +
                          +
                          +
                          +                           		+
                          +
                          + + + +
                          +

                          + Extended Type: + TaskSeqBuilder +

                          +
                          +
                          + + source + + : + 'T seq +
                          +
                          +
                          +
                          +
                          + + Returns: + + ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          +
                          + +

                          + + + this.YieldFrom + + +

                          +                           +
                          +
                          + Full Usage: + this.YieldFrom +
                          +
                          + Parameters: +
                            + + + source + + : + TaskSeq<'T> + +
                            +
                          +
                          + + Returns: + ResumableTSC<'T> + +
                          + Modifiers: + inline +
                          + Type parameters: + 'T +
                          +
                          +
                          +                           		+
                          +
                          + + + +
                          +

                          + Extended Type: + TaskSeqBuilder +

                          +
                          +
                          + + source + + : + TaskSeq<'T> +
                          +
                          +
                          +
                          +
                          + + Returns: + + ResumableTSC<'T> +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          +
                          + +
                          +
                          + + + +
                          +
                            +

                            Type something to start searching.

                            +
                            +                             + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-resumabletsc-1.html b/reference/fsharp-control-resumabletsc-1.html new file mode 100644 index 00000000..2fec60af --- /dev/null +++ b/reference/fsharp-control-resumabletsc-1.html @@ -0,0 +1,208 @@ + + + + + + + + + + + + + + + + + + ResumableTSC<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                            +
                            + + + Header menu logo + FSharp.Control.TaskSeq + +
                            +
                            + + + + + +
                            +
                            + +
                            +
                            +
                            +

                            + ResumableTSC<'T> Type +

                            +
                            +
                            + Namespace: + + FSharp.Control + +
                            +
                            + Assembly: FSharp.Control.TaskSeq.dll +
                            +
                            + Abbreviation For: + ResumableCode<TaskSeqStateMachineData<'T>, unit> +
                            +
                            + Base Type: + MulticastDelegate +
                            +
                            + All Interfaces: + ICloneable + , + ISerializable +
                            +
                            +
                            +
                            +
                            +

                            + TaskSeqCode type alias of ResumableCode delegate type, specially recognized by the F# compiler +

                            +
                            +
                            +
                            +
                            + +
                            +
                            + + + +
                            +
                              +

                              Type something to start searching.

                              +
                              +                               + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-task.html b/reference/fsharp-control-task.html new file mode 100644 index 00000000..eb6df594 --- /dev/null +++ b/reference/fsharp-control-task.html @@ -0,0 +1,1135 @@ + + + + + + + + + + + + + + + + + + Task (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                              +
                              + + + Header menu logo + FSharp.Control.TaskSeq + +
                              +
                              + + + + + +
                              +
                              + +
                              +
                              +
                              +

                              + Task Module +

                              +
                              +
                              + Namespace: + + FSharp.Control + +
                              +
                              + Assembly: FSharp.Control.TaskSeq.dll +
                              +
                              +
                              +
                              +
                              +

                              + +

                              +
                              +
                              +
                              +
                              +

                              + Functions and values +

                              + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                              + Function or value + + Description + +
                              +
                              + +

                              + + + apply func + + +

                              +                               +
                              +
                              + Full Usage: + apply func +
                              +
                              + Parameters: +
                                + + + func + + : + 'a -> 'b + +
                                +
                              +
                              + + Returns: + 'a -> Task<'b> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'a, 'b +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Convert a plain function into a task-returning function +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + func + + : + 'a -> 'b +
                              +
                              +
                              +
                              +
                              + + Returns: + + 'a -> Task<'b> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + bind binder task + + +

                              +                               +
                              +
                              + Full Usage: + bind binder task +
                              +
                              + Parameters: +
                                + + + binder + + : + 'T -> 'a + +
                                + + + task + + : + Task<'T> + +
                                +
                              +
                              + + Returns: + Task<'U> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T, 'a, 'U +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Bind a Task<'T> +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + binder + + : + 'T -> 'a +
                              +
                              +
                              + + task + + : + Task<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task<'U> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + fromResult value + + +

                              +                               +
                              +
                              + Full Usage: + fromResult value +
                              +
                              + Parameters: +
                                + + + value + + : + 'U + +
                                +
                              +
                              + + Returns: + Task<'U> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'U +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Creates a Task<'U> that's completed successfully with the specified result. +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + value + + : + 'U +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task<'U> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + ignore task + + +

                              +                               +
                              +
                              + Full Usage: + ignore task +
                              +
                              + Parameters: +
                                + + + task + + : + Task<'T> + +
                                +
                              +
                              + + Returns: + Task + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Convert a Task<'T> into a non-generic Task, ignoring the result +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + task + + : + Task<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + map mapper task + + +

                              +                               +
                              +
                              + Full Usage: + map mapper task +
                              +
                              + Parameters: +
                                + + + mapper + + : + 'T -> 'U + +
                                + + + task + + : + Task<'T> + +
                                +
                              +
                              + + Returns: + Task<'U> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T, 'U +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Map a Task<'T> +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + mapper + + : + 'T -> 'U +
                              +
                              +
                              + + task + + : + Task<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task<'U> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + ofAsync async + + +

                              +                               +
                              +
                              + Full Usage: + ofAsync async +
                              +
                              + Parameters: +
                                + + + async + + : + Async<'T> + +
                                +
                              +
                              + + Returns: + Task<'T> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Starts the `Async<'T>` computation, returning the associated `Task<'T>` +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + async + + : + Async<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task<'T> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + ofTask task' + + +

                              +                               +
                              +
                              + Full Usage: + ofTask task' +
                              +
                              + Parameters: +
                                + + + task' + + : + Task + +
                                +
                              +
                              + + Returns: + Task<unit> + +
                              + Modifiers: + inline +
                              +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Convert a non-generic Task into a Task +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + task' + + : + Task +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task<unit> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + ofValueTask valueTask + + +

                              +                               +
                              +
                              + Full Usage: + ofValueTask valueTask +
                              +
                              + Parameters: +
                                + + + valueTask + + : + ValueTask<'T> + +
                                +
                              +
                              + + Returns: + Task<'T> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + + Convert a ValueTask<'T> to a Task<'T>. For a non-generic ValueTask, + consider: myValueTask |> Task.ofValueTask |> Task.ofTask. + +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + valueTask + + : + ValueTask<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + Task<'T> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + toAsync task + + +

                              +                               +
                              +
                              + Full Usage: + toAsync task +
                              +
                              + Parameters: +
                                + + + task + + : + Task<'T> + +
                                +
                              +
                              + + Returns: + Async<'T> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Convert a Task<'T> into an Async<'T> +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + task + + : + Task<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + Async<'T> +
                              +
                              +
                              +
                              +
                              +
                              + +

                              + + + toValueTask task + + +

                              +                               +
                              +
                              + Full Usage: + toValueTask task +
                              +
                              + Parameters: +
                                + + + task + + : + Task<'T> + +
                                +
                              +
                              + + Returns: + ValueTask<'T> + +
                              + Modifiers: + inline +
                              + Type parameters: + 'T +
                              +
                              +
                              +                               		+
                              + +
                              +
                              +

                              + Convert a Task<'T> into a ValueTask<'T> +

                              +
                              +
                              + + + +
                              + +
                              +
                              + +
                              +
                              +
                              +                               +
                              +
                              + + task + + : + Task<'T> +
                              +
                              +
                              +
                              +
                              + + Returns: + + ValueTask<'T> +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              +
                              + +
                              +
                              + + + +
                              +
                                +

                                Type something to start searching.

                                +
                                +                                 + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskextensions.html b/reference/fsharp-control-taskextensions.html new file mode 100644 index 00000000..0cf21d6f --- /dev/null +++ b/reference/fsharp-control-taskextensions.html @@ -0,0 +1,332 @@ + + + + + + + + + + + + + + + + + + TaskExtensions (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                +
                                + + + Header menu logo + FSharp.Control.TaskSeq + +
                                +
                                + + + + + +
                                +
                                + +
                                +
                                +
                                +

                                + TaskExtensions Module +

                                +
                                +
                                + Namespace: + + FSharp.Control + +
                                +
                                + Assembly: FSharp.Control.TaskSeq.dll +
                                +
                                +
                                +
                                +
                                +

                                + +

                                +
                                +
                                +
                                +
                                +
                                +

                                + Type extensions +

                                + + + + + + + + + + + + + +
                                + Type extension + + Description + +
                                +
                                + +

                                + + + this.For + + +

                                +                                 +
                                +
                                + Full Usage: + this.For +
                                +
                                + Parameters: +
                                  + + + source + + : + TaskSeq<'T> + +
                                  + + + body + + : + 'T -> TaskCode<'TOverall, unit> + +
                                  +
                                +
                                + + Returns: + TaskCode<'TOverall, unit> + +
                                + Modifiers: + inline +
                                + Type parameters: + 'T, 'TOverall +
                                +
                                +
                                +                                 		+
                                + +
                                +
                                +

                                + + Inside task, iterate over all values of a taskSeq. + +

                                +
                                +
                                + + + +
                                + +
                                +
                                + +
                                +
                                +
                                +                                 +

                                + Extended Type: + TaskBuilderBase +

                                +
                                +
                                + + source + + : + TaskSeq<'T> +
                                +
                                +
                                + + body + + : + 'T -> TaskCode<'TOverall, unit> +
                                +
                                +
                                +
                                +
                                + + Returns: + + TaskCode<'TOverall, unit> +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                +
                                + +
                                +
                                + + + +
                                +
                                  +

                                  Type something to start searching.

                                  +
                                  +                                   + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseq-1-0.html b/reference/fsharp-control-taskseq-1-0.html new file mode 100644 index 00000000..6a1d5396 --- /dev/null +++ b/reference/fsharp-control-taskseq-1-0.html @@ -0,0 +1,205 @@ + + + + + + + + + + + + + + + + + + TaskSeq<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                  +
                                  + + + Header menu logo + FSharp.Control.TaskSeq + +
                                  +
                                  + + + + + +
                                  +
                                  + +
                                  +
                                  +
                                  +

                                  + TaskSeq<'T> Type +

                                  +
                                  +
                                  + Namespace: + + FSharp.Control + +
                                  +
                                  + Assembly: FSharp.Control.TaskSeq.dll +
                                  +
                                  + Abbreviation For: + IAsyncEnumerable<'T> +
                                  +
                                  + All Interfaces: + TaskSeq<'T> +
                                  +
                                  +
                                  +
                                  +
                                  +

                                  + + Represents a task sequence and is the output of using the taskSeq{...} + computation expression from this library. It is an alias for IAsyncEnumerable<_>. + +

                                  +
                                  +
                                  +
                                  +
                                  + +
                                  +
                                  + + + +
                                  +
                                    +

                                    Type something to start searching.

                                    +
                                    +                                     + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseq-1.html b/reference/fsharp-control-taskseq-1.html new file mode 100644 index 00000000..c639cf41 --- /dev/null +++ b/reference/fsharp-control-taskseq-1.html @@ -0,0 +1,208 @@ + + + + + + + + + + + + + + + + + + taskSeq<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                    +
                                    + + + Header menu logo + FSharp.Control.TaskSeq + +
                                    +
                                    + + + + + +
                                    +
                                    + +
                                    +
                                    +
                                    +

                                    + taskSeq<'T> Type +

                                    +
                                    +
                                    + Namespace: + + FSharp.Control + +
                                    +
                                    + Assembly: FSharp.Control.TaskSeq.dll +
                                    +
                                    + Abbreviation For: + IAsyncEnumerable<'T> +
                                    +
                                    + All Interfaces: + taskSeq<'T> +
                                    +
                                    +
                                    +
                                    +
                                    +

                                    + + Represents a task sequence and is the output of using the taskSeq{...} + computation expression from this library. It is an alias for IAsyncEnumerable<_>. + + The type taskSeq<_> is deprecated since version 0.4.0, + please use TaskSeq<_> in its stead. See TaskSeq<_>. + +

                                    +
                                    +
                                    +
                                    +
                                    + +
                                    +
                                    + + + +
                                    +
                                      +

                                      Type something to start searching.

                                      +
                                      +                                       + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseq-2.html b/reference/fsharp-control-taskseq-2.html new file mode 100644 index 00000000..a2550e9f --- /dev/null +++ b/reference/fsharp-control-taskseq-2.html @@ -0,0 +1,505 @@ + + + + + + + + + + + + + + + + + + TaskSeq<'Machine, 'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                      +
                                      + + + Header menu logo + FSharp.Control.TaskSeq + +
                                      +
                                      + + + + + +
                                      +
                                      + +
                                      +
                                      +
                                      +

                                      + TaskSeq<'Machine, 'T> Type +

                                      +
                                      +
                                      + Namespace: + + FSharp.Control + +
                                      +
                                      + Assembly: FSharp.Control.TaskSeq.dll +
                                      +
                                      + Base Type: + TaskSeqBase<'T> +
                                      +
                                      + All Interfaces: + IValueTaskSource + , + IValueTaskSource<bool> + , + IAsyncStateMachine + , + IAsyncEnumerable<'T> + , + IAsyncEnumerator<'T> + , + IAsyncDisposable +
                                      +
                                      +
                                      +
                                      +
                                      +

                                      + + Main implementation of generic IAsyncEnumerable<'T> and related interfaces, + which forms the meat of the logic behind taskSeq computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + +

                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +

                                      + Record fields +

                                      + + + + + + + + + + + + + + + + + +
                                      + Record Field + + Description + +
                                      +
                                      + +

                                      + + + _initialMachine + + +

                                      +                                       +
                                      +
                                      + Full Usage: + _initialMachine +
                                      +
                                      + + Field type: + 'Machine + +
                                      + Modifiers: + mutable +
                                      +
                                      +
                                      +
                                      +                                       		+
                                      +
                                      + + + +
                                      +
                                      +
                                      + + Field type: + + 'Machine +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      + +

                                      + + + _machine + + +

                                      +                                       +
                                      +
                                      + Full Usage: + _machine +
                                      +
                                      + + Field type: + 'Machine + +
                                      + Modifiers: + mutable +
                                      +
                                      +
                                      +
                                      +                                       		+
                                      + +
                                      +
                                      +

                                      + Keeps the active state machine. +

                                      +
                                      +
                                      + + + +
                                      +
                                      +                                       +
                                      +
                                      + + Field type: + + 'Machine +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +

                                      + Constructors +

                                      + + + + + + + + + + + + + +
                                      + Constructor + + Description + +
                                      +
                                      + +

                                      + + + TaskSeq() + + +

                                      +                                       +
                                      +
                                      + Full Usage: + TaskSeq() +
                                      +
                                      + + Returns: + TaskSeq<'Machine, 'T> + +
                                      +
                                      +
                                      +
                                      +                                       		+
                                      +
                                      + + + +
                                      +
                                      +
                                      + + Returns: + + TaskSeq<'Machine, 'T> +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +

                                      + Instance members +

                                      + + + + + + + + + + + + + +
                                      + Instance member + + Description + +
                                      +
                                      + +

                                      + + + this.InitMachineData + + +

                                      +                                       +
                                      +
                                      + Full Usage: + this.InitMachineData +
                                      +
                                      + Parameters: + +
                                      +
                                      +
                                      +
                                      +                                       		+
                                      +
                                      + + + +
                                      +
                                      +
                                      + + ct + + : + CancellationToken +
                                      +
                                      +
                                      + + machine + + : + byref<'Machine> +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      +
                                      + +
                                      +
                                      + + + +
                                      +
                                        +

                                        Type something to start searching.

                                        +
                                        +                                         + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseq.html b/reference/fsharp-control-taskseq.html new file mode 100644 index 00000000..c54ebdf5 --- /dev/null +++ b/reference/fsharp-control-taskseq.html @@ -0,0 +1,21497 @@ + + + + + + + + + + + + + + + + + + TaskSeq (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                        +
                                        + + + Header menu logo + FSharp.Control.TaskSeq + +
                                        +
                                        + + + + + +
                                        +
                                        + +
                                        +
                                        +
                                        +

                                        + TaskSeq Type +

                                        +
                                        +
                                        + Namespace: + + FSharp.Control + +
                                        +
                                        + Assembly: FSharp.Control.TaskSeq.dll +
                                        +
                                        + Base Type: + obj +
                                        +
                                        +
                                        +
                                        +
                                        +

                                        + +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        +

                                        + Static members +

                                        + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                        + Static member + + Description + +
                                        +
                                        + +

                                        + + + TaskSeq.append source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.append source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + source1 + + : + TaskSeq<'T> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'T> + - + The second input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Concatenates task sequences source1 and source2 in order as a single + task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.appendSeq source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.appendSeq source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + source1 + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          + + + source2 + + : + 'T seq + - + The input F# seq sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Concatenates a task sequence source1 with a (non-async) F# seq in source2 + and returns a single task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + 'T seq +
                                        +
                                        +

                                        + The input F# seq sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the input sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.box source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.box source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<obj> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views each item in the input task sequence as obj, boxing value types. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<obj> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.cast source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.cast source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<obj> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Casts each item in the untyped input task sequence. If the input sequence contains value types + it is recommended to consider using unbox instead. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<obj> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + InvalidCastException + + + Thrown when the function is unable to cast an item to the target type. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.choose chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.choose chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'U option + - + A function to transform items of type 'T into options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given function chooser to each element of the task sequence. Returns + a sequence comprised of the results where the function returns Some(x). + If chooser is asynchronous, consider using chooseAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'U option +
                                        +
                                        +

                                        + A function to transform items of type 'T into options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.chooseAsync chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.chooseAsync chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'a + - + An asynchronous function to transform items of type 'T into options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given asynchronous function chooser to each element of the task sequence. + Returns a sequence comprised of the results where the function returns a task result + of Some(x). + If chooser is synchronous, consider using choose. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items of type 'T into options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.chooseV chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.chooseV chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'U voption + - + A function to transform items of type 'T into value options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given function chooser to each element of the task sequence. Returns + a sequence comprised of the results where the function returns ValueSome(x). + If chooser is asynchronous, consider using chooseVAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'U voption +
                                        +
                                        +

                                        + A function to transform items of type 'T into value options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.chooseVAsync chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.chooseVAsync chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'a + - + An asynchronous function to transform items of type 'T into value options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given asynchronous function chooser to each element of the task sequence. + Returns a sequence comprised of the results where the function returns a task result + of ValueSome(x). + If chooser is synchronous, consider using chooseV. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items of type 'T into value options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.chunkBy projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.chunkBy projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'Key + - + A function that computes the key for each element. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'Key * 'T[]> + + A task sequence of (key, elements[]) pairs for each run of equal keys. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Groups consecutive elements of the task sequence by a key derived from each element using + projection, yielding (key, elements[]) pairs. A new group is started + each time the key changes from one element to the next. Unlike groupBy, + only consecutive elements with the same key are merged. + If the projection function is asynchronous, consider using chunkByAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + projection + + : + 'T -> 'Key +
                                        +
                                        +

                                        + A function that computes the key for each element. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'Key * 'T[]> +
                                        +
                                        +

                                        + A task sequence of (key, elements[]) pairs for each run of equal keys. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.chunkByAsync projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.chunkByAsync projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'a + - + An asynchronous function that computes the key for each element. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'Key * 'T[]> + + A task sequence of (key, elements[]) pairs for each run of equal keys. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Groups consecutive elements of the task sequence by a key derived from each element using the + asynchronous function projection, yielding (key, elements[]) pairs. + A new group is started each time the key changes from one element to the next. + Unlike groupByAsync, only consecutive elements with the same key are merged. + If the projection function is synchronous, consider using chunkBy. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + projection + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that computes the key for each element. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'Key * 'T[]> +
                                        +
                                        +

                                        + A task sequence of (key, elements[]) pairs for each run of equal keys. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.chunkBySize chunkSize source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.chunkBySize chunkSize source +
                                        +
                                        + Parameters: +
                                          + + + chunkSize + + : + int + - + The maximum number of elements in each chunk. Must be positive. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T[]> + + A task sequence of non-overlapping array chunks. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Divides the input task sequence into chunks of size at most chunkSize. + The last chunk may be smaller than chunkSize if the source sequence does not divide evenly. + Returns an empty task sequence when the source is empty. + + If chunkSize is not positive, an ArgumentException is raised immediately + (before the sequence is evaluated). + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chunkSize + + : + int +
                                        +
                                        +

                                        + The maximum number of elements in each chunk. Must be positive. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T[]> +
                                        +
                                        +

                                        + A task sequence of non-overlapping array chunks. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when chunkSize is not positive. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.collect binder source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.collect binder source +
                                        +
                                        + Parameters: +
                                          + + + binder + + : + 'T -> 'a + - + A function to transform items from the input task sequence into a task sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting concatenation of all returned task sequences. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the binder + function to each of the elements of the input task sequence in source, and concatenating the + returned task sequences. + The given function will be applied as elements are pulled using async enumerators retrieved from the + input task sequence. + + If binder is asynchronous, consider using collectAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + binder + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to transform items from the input task sequence into a task sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting concatenation of all returned task sequences. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.collectAsync binder source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.collectAsync binder source +
                                        +
                                        + Parameters: +
                                          + + + binder + + : + 'T -> 'a + - + An asynchronous function to transform items from the input task sequence into a task sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting concatenation of all returned task sequences. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the asynchronous binder + function to each of the elements of the input task sequence in source, and concatenating the + returned task sequences. + The given function will be applied as elements are pulled using async enumerators retrieved from the + input task sequence. + + If binder is synchronous, consider using collect. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + binder + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items from the input task sequence into a task sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting concatenation of all returned task sequences. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.collectSeq binder source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.collectSeq binder source +
                                        +
                                        + Parameters: +
                                          + + + binder + + : + 'T -> 'a + - + A function to transform items from the input task sequence into a regular sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting concatenation of all returned task sequences. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the binder + function to each of the elements of the input task sequence in source, and concatenating the + returned regular F# sequences. + The given function will be applied as elements are pulled using async enumerators retrieved from the + input task sequence. + + If binder is asynchronous, consider using collectSeqAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + binder + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to transform items from the input task sequence into a regular sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting concatenation of all returned task sequences. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.collectSeqAsync binder source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.collectSeqAsync binder source +
                                        +
                                        + Parameters: +
                                          + + + binder + + : + 'T -> 'a + - + An asynchronous function to transform items from the input task sequence into a regular sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting concatenation of all returned task sequences. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the asynchronous binder + function to each of the elements of the input task sequence in source, and concatenating the + returned regular F# sequences. + The given function will be applied as elements are pulled using async enumerators retrieved from the + input task sequence. + + If binder is synchronous, consider using collectSeqAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + binder + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items from the input task sequence into a regular sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting concatenation of all returned task sequences. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.compareWith comparer source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.compareWith comparer source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + comparer + + : + 'T -> 'T -> int + - + A function that compares an element from the first sequence with one from the second, returning an integer (negative = less than, zero = equal, positive = greater than). + +
                                          + + + source1 + + : + TaskSeq<'T> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'T> + - + The second input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + A task returning the first non-zero comparison result, or zero if all elements compare equal and the sequences have equal length. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies a comparer function to corresponding elements of two task sequences, returning the result of the + first comparison that is non-zero, or zero if all compared elements are equal. The sequences are compared + element by element until one of them is exhausted; if one sequence is shorter than the other, it is considered + less than the longer sequence. + If the comparer function comparer is asynchronous, consider using compareWithAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + comparer + + : + 'T -> 'T -> int +
                                        +
                                        +

                                        + A function that compares an element from the first sequence with one from the second, returning an integer (negative = less than, zero = equal, positive = greater than). +

                                        +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + A task returning the first non-zero comparison result, or zero if all elements compare equal and the sequences have equal length. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.compareWithAsync comparer source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.compareWithAsync comparer source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + comparer + + : + 'T -> 'T -> 'a + - + An asynchronous function that compares an element from the first sequence with one from the second, returning an integer (negative = less than, zero = equal, positive = greater than). + +
                                          + + + source1 + + : + TaskSeq<'T> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'T> + - + The second input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + A task returning the first non-zero comparison result, or zero if all elements compare equal and the sequences have equal length. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies an asynchronous comparer function to corresponding elements of two task sequences, returning the result of + the first comparison that is non-zero, or zero if all compared elements are equal. The sequences are compared + element by element until one of them is exhausted; if one sequence is shorter than the other, it is considered + less than the longer sequence. + If the comparer function comparer is synchronous, consider using compareWith. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + comparer + + : + 'T -> 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that compares an element from the first sequence with one from the second, returning an integer (negative = less than, zero = equal, positive = greater than). +

                                        +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + A task returning the first non-zero comparison result, or zero if all elements compare equal and the sequences have equal length. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.concat sources + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.concat sources +
                                        +
                                        + Parameters: +
                                          + + + sources + + : + TaskSeq<ResizeArray<'T>> + - + The input task sequence of resizable arrays. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting, flattened task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the given task sequence of resizable arrays and concatenates them end-to-end, to form a + new flattened, single task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + sources + + : + TaskSeq<ResizeArray<'T>> +
                                        +
                                        +

                                        + The input task sequence of resizable arrays. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting, flattened task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence of task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.concat sources + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.concat sources +
                                        +
                                        + Parameters: +
                                          + + + sources + + : + TaskSeq<'T list> + - + The input task sequence of lists. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting, flattened task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the given task sequence of lists and concatenates them end-to-end, to form a + new flattened, single task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + sources + + : + TaskSeq<'T list> +
                                        +
                                        +

                                        + The input task sequence of lists. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting, flattened task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence of task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.concat sources + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.concat sources +
                                        +
                                        + Parameters: +
                                          + + + sources + + : + TaskSeq<'T[]> + - + The input task sequence of arrays. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting, flattened task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the given task sequence of arrays and concatenates them end-to-end, to form a + new flattened, single task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + sources + + : + TaskSeq<'T[]> +
                                        +
                                        +

                                        + The input task sequence of arrays. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting, flattened task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence of task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.concat sources + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.concat sources +
                                        +
                                        + Parameters: +
                                          + + + sources + + : + TaskSeq<'T seq> + - + The input task sequence of sequences. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting, flattened task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the given task sequence of sequences and concatenates them end-to-end, to form a + new flattened, single task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + sources + + : + TaskSeq<'T seq> +
                                        +
                                        +

                                        + The input task sequence of sequences. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting, flattened task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence of task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.concat sources + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.concat sources +
                                        +
                                        + Parameters: +
                                          + + + sources + + : + TaskSeq<'a> + - + The input task-sequence-of-task-sequences. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting, flattened task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the given task sequence of task sequences and concatenates them end-to-end, to form a + new flattened, single task sequence, like TaskSeq.collect id. Each task sequence is + awaited and consumed in full, before the next one is iterated. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + sources + + : + TaskSeq<'a> +
                                        +
                                        +

                                        + The input task-sequence-of-task-sequences. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting, flattened task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence of task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.contains value source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.contains value source +
                                        +
                                        + Parameters: +
                                          + + + value + + : + 'T + - + The value to locate in the input sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<bool> + + true if the input sequence contains the specified element; false otherwise. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Tests if the sequence contains the specified element. Returns true + if source contains the specified element; false + otherwise. The input task sequence is only evaluated until the first element that matches the value. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + value + + : + 'T +
                                        +
                                        +

                                        + The value to locate in the input sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<bool> +
                                        +
                                        +

                                        + true if the input sequence contains the specified element; false otherwise. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.countBy projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.countBy projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'Key + - + A function that transforms each element into a key. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<('Key * int)[]> + + A task returning an array of (key, count) pairs. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies a key-generating function to each element of a task sequence and returns a task with an array of + unique keys and their element counts, in order of first occurrence of each key. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function consumes the entire source task sequence before returning. + If the projection function projection is asynchronous, consider using + countByAsync. + +

                                        +
                                        +
                                        + + projection + + : + 'T -> 'Key +
                                        +
                                        +

                                        + A function that transforms each element into a key. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<('Key * int)[]> +
                                        +
                                        +

                                        + A task returning an array of (key, count) pairs. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.countByAsync projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.countByAsync projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'a + - + An asynchronous function that transforms each element into a key. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<('Key * int)[]> + + A task returning an array of (key, count) pairs. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies an asynchronous key-generating function to each element of a task sequence and returns a task with + an array of unique keys and their element counts, in order of first occurrence of each key. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function consumes the entire source task sequence before returning. + If the projection function projection is synchronous, consider using + countBy. + +

                                        +
                                        +
                                        + + projection + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that transforms each element into a key. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<('Key * int)[]> +
                                        +
                                        +

                                        + A task returning an array of (key, count) pairs. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.delay generator + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.delay generator +
                                        +
                                        + Parameters: +
                                          + + + generator + + : + unit -> TaskSeq<'T> + - + The generating function for the task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The generated task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that is given by the delayed specification of a task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + generator + + : + unit -> TaskSeq<'T> +
                                        +
                                        +

                                        + The generating function for the task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The generated task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.distinct source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.distinct source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence with duplicate elements removed. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence that contains no duplicate entries, using generic hash and equality comparisons. + If an element occurs multiple times in the sequence, only the first occurrence is returned. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function iterates the whole sequence and buffers all unique elements in a hash set, so it should not + be used on potentially infinite sequences. + +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence with duplicate elements removed. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.distinctBy projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.distinctBy projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'Key + - + A function that transforms each element to a key that is used for equality comparison. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence with elements whose projected keys are distinct. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence that contains no duplicate entries according to the generic hash and equality + comparisons on the keys returned by the given projection function. + If two elements have the same projected key, only the first occurrence is returned. + If the projection function is asynchronous, consider using distinctByAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function iterates the whole sequence and buffers all unique keys in a hash set, so it should not + be used on potentially infinite sequences. + +

                                        +
                                        +
                                        + + projection + + : + 'T -> 'Key +
                                        +
                                        +

                                        + A function that transforms each element to a key that is used for equality comparison. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence with elements whose projected keys are distinct. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.distinctByAsync projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.distinctByAsync projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'a + - + An asynchronous function that transforms each element to a key used for equality comparison. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence with elements whose projected keys are distinct. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence that contains no duplicate entries according to the generic hash and equality + comparisons on the keys returned by the given asynchronous projection function. + If two elements have the same projected key, only the first occurrence is returned. + If the projection function is synchronous, consider using distinctBy. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function iterates the whole sequence and buffers all unique keys in a hash set, so it should not + be used on potentially infinite sequences. + +

                                        +
                                        +
                                        + + projection + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that transforms each element to a key used for equality comparison. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence with elements whose projected keys are distinct. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.distinctUntilChanged source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.distinctUntilChanged source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence whose consecutive duplicates will be removed. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence without consecutive duplicates elements. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence without consecutive duplicate elements. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence whose consecutive duplicates will be removed. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence without consecutive duplicates elements. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.distinctUntilChangedWith comparer source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.distinctUntilChangedWith comparer source +
                                        +
                                        + Parameters: +
                                          + + + comparer + + : + 'T -> 'T -> bool + - + A function that returns if two consecutive elements are equal. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence whose consecutive duplicates will be removed. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence without consecutive duplicate elements. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence without consecutive duplicate elements, using the supplied comparer + to determine equality of consecutive elements. The comparer returns if two elements are + considered equal (and thus the second should be skipped). + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + comparer + + : + 'T -> 'T -> bool +
                                        +
                                        +

                                        + A function that returns if two consecutive elements are equal. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence whose consecutive duplicates will be removed. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence without consecutive duplicate elements. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.distinctUntilChangedWithAsync comparer source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.distinctUntilChangedWithAsync comparer source +
                                        +
                                        + Parameters: +
                                          + + + comparer + + : + 'T -> 'T -> 'a + - + An async function that returns if two consecutive elements are equal. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence whose consecutive duplicates will be removed. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence without consecutive duplicate elements. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence without consecutive duplicate elements, using the supplied async comparer + to determine equality of consecutive elements. The comparer returns if two elements are + considered equal (and thus the second should be skipped). + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + comparer + + : + 'T -> 'T -> 'a +
                                        +
                                        +

                                        + An async function that returns if two consecutive elements are equal. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence whose consecutive duplicates will be removed. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence without consecutive duplicate elements. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.drop count source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.drop count source +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The maximum number of items to drop. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, drops at most count elements of the + underlying sequence, and then returns the remainder of the elements, if any. + See skip for a version that raises an exception if there + are not enough elements. See also truncate for the inverse of this operation. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The maximum number of items to drop. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when count is less than zero. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.exactlyOne source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.exactlyOne source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The only element of the singleton task sequence, or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the only element of the task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The only element of the singleton task sequence, or None. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the input task sequence does not contain precisely one element. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.except itemsToExclude source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.except itemsToExclude source +
                                        +
                                        + Parameters: +
                                          + + + itemsToExclude + + : + TaskSeq<'T> + - + A task sequence whose elements that also occur in the second sequence will cause those elements to be removed from the returned sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence whose elements that are not also in the first will be returned. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence that contains the set difference of the elements of two sequences. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence with the distinct elements of the second task sequence which do not appear in the + itemsToExclude sequence, using generic hash and equality comparisons to compare values. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + Note that this function returns a task sequence that digests the whole of the first input task sequence as soon as + the resulting task sequence first gets awaited or 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. + +

                                        +
                                        +
                                        + + itemsToExclude + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + A task sequence whose elements that also occur in the second sequence will cause those elements to be removed from the returned sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence whose elements that are not also in the first will be returned. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence that contains the set difference of the elements of two sequences. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the two input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.exceptOfSeq itemsToExclude source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.exceptOfSeq itemsToExclude source +
                                        +
                                        + Parameters: +
                                          + + + itemsToExclude + + : + 'T seq + - + A task sequence whose elements that also occur in the second sequence will cause those elements to be removed from the returned sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence whose elements that are not also in first will be returned. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A sequence that contains the set difference of the elements of two sequences. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence with the distinct elements of the second task sequence which do not appear in the + itemsToExclude sequence, using generic hash and equality comparisons to compare values. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + Note that this function returns a task sequence that digests the whole of the first input task sequence as soon as + the result sequence first gets awaited or 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. + +

                                        +
                                        +
                                        + + itemsToExclude + + : + 'T seq +
                                        +
                                        +

                                        + A task sequence whose elements that also occur in the second sequence will cause those elements to be removed from the returned sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence whose elements that are not also in first will be returned. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A sequence that contains the set difference of the elements of two sequences. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the two input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.exists predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.exists predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function to test each item of the input sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<bool> + + true if any result from the predicate is true; false otherwise. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Tests if any element of the task sequence in source satisfies the given predicate. The function + is applied to the elements of the input task sequence. If any application returns true then the overall result + is true and no further elements are evaluated and tested. + Otherwise, false is returned. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function to test each item of the input sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<bool> +
                                        +
                                        +

                                        + true if any result from the predicate is true; false otherwise. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.existsAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.existsAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + A function to test each item of the input sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<bool> + + true if any result from the predicate is true; false otherwise. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Tests if any element of the task sequence in source satisfies the given asynchronous predicate. + The function is applied to the elements of the input task sequence. If any application returns true then the overall result + is true and no further elements are evaluated and tested. + Otherwise, false is returned. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to test each item of the input sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<bool> +
                                        +
                                        +

                                        + true if any result from the predicate is true; false otherwise. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.filter predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.filter predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function to test whether an item in the input sequence should be included in the output or not. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence containing only the elements of the collection + for which the given function predicate returns true. + If predicate is asynchronous, consider using filterAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function to test whether an item in the input sequence should be included in the output or not. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.filterAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.filterAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function to test whether an item in the input sequence should be included in the output or not. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence containing only the elements of the input sequence + for which the given function predicate returns true. + If predicate is synchronous, consider using filter. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to test whether an item in the input sequence should be included in the output or not. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.find predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.find predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The first element for which the predicate returns true. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element for which the given function predicate returns true. + Throws an exception if none is found. + If predicate is asynchronous, consider using findAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The first element for which the predicate returns true. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + KeyNotFoundException + + + Thrown if no element returns true when evaluated by the predicate function. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.findAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.findAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The first element for which the predicate returns true. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element for which the given asynchronous function predicate returns true. + Throws an exception if none is found. + If predicate is synchronous, consider using find. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The first element for which the predicate returns true. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + KeyNotFoundException + + + Thrown if no element returns true when evaluated by the predicate function. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.findIndex predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.findIndex predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + The index for which the predicate returns true. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the index, starting from zero, of the first element for which the given function predicate + returns true. + If predicate is asynchronous, consider using findIndexAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + The index for which the predicate returns true. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + KeyNotFoundException + + + Thrown if no element returns true when evaluated by the predicate function. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.findIndexAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.findIndexAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + The index for which the predicate returns true. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the index, starting from zero, of the first element for which the given function predicate + returns true. + If predicate is synchronous, consider using findIndex. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + The index for which the predicate returns true. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + KeyNotFoundException + + + Thrown if no element returns true when evaluated by the predicate function. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.firstOrDefault defaultValue source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.firstOrDefault defaultValue source +
                                        +
                                        + Parameters: +
                                          + + + defaultValue + + : + 'T + - + The value to return when the source sequence is empty. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The first element of the task sequence, or defaultValue if empty. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element of the input task sequence given by source, + or defaultValue if the sequence is empty. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + defaultValue + + : + 'T +
                                        +
                                        +

                                        + The value to return when the source sequence is empty. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The first element of the task sequence, or defaultValue if empty. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.fold folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.fold folder state source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'State -> 'T -> 'State + +
                                          + + + state + + : + 'State + +
                                          + + + source + + : + TaskSeq<'T> + +
                                          +
                                        +
                                        + + Returns: + Task<'State> + +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + then computes. + If the accumulator function is asynchronous, consider using . + argument of type through the computation. If the input function is and the elements are + then computes . + If the accumulator function is asynchronous, consider using . +

                                        + + A function that updates the state with each element from the sequence. + The initial state. + The input sequence. + The state object after the folding function is applied to each element of the sequence. + Thrown when the input task sequence is null. +

                                        + +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        + + +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'State +
                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'State> +
                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.foldAsync folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.foldAsync folder state source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'State -> 'T -> 'a + - + A function that updates the state with each element from the sequence. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'State> + + The state object after the folding function is applied to each element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the asynchronous function folder to each element in the task sequence, threading an accumulator + argument of type 'State through the computation. If the input function is f and the elements are i0...iN + then computes f (... (f s i0)...) iN. + If the accumulator function folder is synchronous, consider using fold. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'a +
                                        +
                                        +

                                        + A function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'State> +
                                        +
                                        +

                                        + The state object after the folding function is applied to each element of the sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.foldWhile predicate folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.foldWhile predicate folder state source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'State -> 'T -> bool + - + A function that, given the current state and next element, returns true to keep folding or false to stop. + +
                                          + + + folder + + : + 'State -> 'T -> 'State + - + A function that updates the state with each element from the sequence. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'State> + + The state object after iteration halted, or after the whole sequence was consumed. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the function folder to each element in the task sequence, threading an + accumulator of type 'State through the computation, for as long as + predicate returns true. The predicate is evaluated against the current + state and next element before that element is folded in; once it returns false the element + is not folded, iteration stops, and no further elements of the input are enumerated. + If either function is asynchronous, consider using foldWhileAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'State -> 'T -> bool +
                                        +
                                        +

                                        + A function that, given the current state and next element, returns true to keep folding or false to stop. +

                                        +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'State +
                                        +
                                        +

                                        + A function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'State> +
                                        +
                                        +

                                        + The state object after iteration halted, or after the whole sequence was consumed. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.foldWhileAsync predicate folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.foldWhileAsync predicate folder state source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'State -> 'T -> 'a + - + An async function that, given the current state and next element, returns true to keep folding or false to stop. + +
                                          + + + folder + + : + 'State -> 'T -> 'b + - + An async function that updates the state with each element from the sequence. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'State> + + The state object after iteration halted, or after the whole sequence was consumed. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the asynchronous function folder to each element in the task sequence, + threading an accumulator of type 'State through the computation, for as long as + the asynchronous predicate returns true. The predicate is evaluated + against the current state and next element before that element is folded in; once it returns + false the element is not folded, iteration stops, and no further elements of the input are + enumerated. + If both functions are synchronous, consider using foldWhile. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'State -> 'T -> 'a +
                                        +
                                        +

                                        + An async function that, given the current state and next element, returns true to keep folding or false to stop. +

                                        +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'b +
                                        +
                                        +

                                        + An async function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'State> +
                                        +
                                        +

                                        + The state object after iteration halted, or after the whole sequence was consumed. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.forall predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.forall predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function to test an element of the input sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<bool> + + A task that, after awaiting, holds true if every element of the sequence satisfies the predicate; false otherwise. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Tests if all elements of the sequence satisfy the given predicate. Stops evaluating + as soon as predicate returns false. + If predicate is asynchronous, consider using forallAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function to test an element of the input sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<bool> +
                                        +
                                        +

                                        + A task that, after awaiting, holds true if every element of the sequence satisfies the predicate; false otherwise. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.forallAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.forallAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + A function to test an element of the input sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<bool> + + A task that, after awaiting, holds true if every element of the sequence satisfies the predicate; false otherwise. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Tests if all elements of the sequence satisfy the given asynchronous predicate. Stops evaluating + as soon as predicate returns false. + If predicate is synchronous, consider using forall. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to test an element of the input sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<bool> +
                                        +
                                        +

                                        + A task that, after awaiting, holds true if every element of the sequence satisfies the predicate; false otherwise. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.groupBy projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.groupBy projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'Key + - + A function that transforms each element into a key. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<('Key * 'T[])[]> + + A task returning an array of (key, elements[]) pairs. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies a key-generating function to each element of a task sequence and yields a sequence of unique keys + and arrays of all elements that have each key, in order of first occurrence of each key. + The returned array preserves the original order of elements within each group. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function consumes the entire source task sequence before returning. + If the projection function projection is asynchronous, consider using + groupByAsync. + +

                                        +
                                        +
                                        + + projection + + : + 'T -> 'Key +
                                        +
                                        +

                                        + A function that transforms each element into a key. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<('Key * 'T[])[]> +
                                        +
                                        +

                                        + A task returning an array of (key, elements[]) pairs. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.groupByAsync projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.groupByAsync projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'a + - + An asynchronous function that transforms each element into a key. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<('Key * 'T[])[]> + + A task returning an array of (key, elements[]) pairs. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies an asynchronous key-generating function to each element of a task sequence and yields a sequence of + unique keys and arrays of all elements that have each key, in order of first occurrence of each key. + The returned array preserves the original order of elements within each group. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function consumes the entire source task sequence before returning. + If the projection function projection is synchronous, consider using + groupBy. + +

                                        +
                                        +
                                        + + projection + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that transforms each element into a key. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<('Key * 'T[])[]> +
                                        +
                                        +

                                        + A task returning an array of (key, elements[]) pairs. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.head source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.head source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The first element of the task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element of the input task sequence given by source. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The first element of the task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.indexed source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.indexed source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<int * 'T> + + The resulting task sequence of tuples. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the corresponding elements of the input task + sequence source paired with the integer index (from 0) of each element. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<int * 'T> +
                                        +
                                        +

                                        + The resulting task sequence of tuples. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.init count initializer + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.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: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Generates a new task sequence which, when iterated, will return successive elements by calling the given function + with the current zero-based index, up to the given count. Each element is saved after its initialization for successive access to + Current, which will not re-evaluate the initializer. However, + re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may + be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should + not be accessed concurrently. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + 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: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentException + + + Thrown when count is negative. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.initAsync count initializer + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.initAsync count initializer +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The maximum number of items to generate for the sequence. + +
                                          + + + initializer + + : + int -> 'a + - + A function that generates an item in the sequence from a given index. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Generates a new task sequence which, when iterated, will return successive elements by calling the given function + with the current zero-based index, up to the given count. Each element is saved after its initialization for successive access to + Current, which will not re-evaluate the initializer. However, + re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may + be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should + not be accessed concurrently. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The maximum number of items to generate for the sequence. +

                                        +
                                        +
                                        + + initializer + + : + int -> 'a +
                                        +
                                        +

                                        + A function that generates an item in the sequence from a given index. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentException + + + Thrown when count is negative. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.initInfinite initializer + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.initInfinite initializer +
                                        +
                                        + Parameters: +
                                          + + + initializer + + : + int -> 'T + - + A function that generates an item in the sequence from a given index. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Generates a new task sequence which, when iterated, will return successive elements by calling the given function + with the current zero-based index, ad infinitum, or until MaxValue is reached. + Each element is saved after its initialization for successive access to + Current, which will not re-evaluate the initializer. However, + re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may + be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should + not be accessed concurrently. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + initializer + + : + int -> 'T +
                                        +
                                        +

                                        + A function that generates an item in the sequence from a given index. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.initInfiniteAsync initializer + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.initInfiniteAsync initializer +
                                        +
                                        + Parameters: +
                                          + + + initializer + + : + int -> 'a + - + A function that generates an item in the sequence from a given index. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Generates a new task sequence which, when iterated, will return successive elements by calling the given function + with the current zero-based index, ad infinitum, or until MaxValue is reached. + Each element is saved after its initialization for successive access to + Current, which will not re-evaluate the initializer. However, + re-iterating the returned task sequence will re-evaluate the initialization function. The returned sequence may + be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should + not be accessed concurrently. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + initializer + + : + int -> 'a +
                                        +
                                        +

                                        + A function that generates an item in the sequence from a given index. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.insertAt index value source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.insertAt index value source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index where the item should be inserted. + +
                                          + + + value + + : + 'T + - + The value to insert. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The result task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Return a new task sequence with a new item inserted before the given index. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index where the item should be inserted. +

                                        +
                                        +
                                        + + value + + : + 'T +
                                        +
                                        +

                                        + The value to insert. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The result task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when index is below 0 or greater than source length. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.insertManyAt index values source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.insertManyAt index values source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index where the items should be inserted. + +
                                          + + + values + + : + TaskSeq<'T> + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The result task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Return a new task sequence with the new items inserted before the given index. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index where the items should be inserted. +

                                        +
                                        +
                                        + + values + + : + TaskSeq<'T> +
                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The result task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when index is below 0 or greater than source length. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.isEmpty source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.isEmpty source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<bool> + + A task returning true if the sequence contains no elements; false otherwise. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns true if the task sequence contains no elements, false otherwise. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<bool> +
                                        +
                                        +

                                        + A task returning true if the sequence contains no elements; false otherwise. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.item index source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.item index source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index of the item to retrieve. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The nth element of the task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the nth element of the input task sequence given by source, + or raises an exception if the sequence does not contain enough elements. + The index is zero-based, that is, using index 0 returns the first element. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index of the item to retrieve. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The nth element of the task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the sequence has insufficient length or index is negative. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.iter action source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.iter action source +
                                        +
                                        + Parameters: +
                                          + + + action + + : + 'T -> unit + - + A function to apply to each element of the task sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<unit> + + A unittask. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Iterates over the input task sequence, applying the action function to each item. + This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + action + + : + 'T -> unit +
                                        +
                                        +

                                        + A function to apply to each element of the task sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<unit> +
                                        +
                                        +

                                        + A unittask. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.iterAsync action source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.iterAsync action source +
                                        +
                                        + Parameters: +
                                          + + + action + + : + 'T -> 'a + - + An asynchronous function to apply to each element of the task sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<unit> + + A unittask. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Iterates over the input task sequence, applying the asynchronous action function to each item. + This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + action + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to apply to each element of the task sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<unit> +
                                        +
                                        +

                                        + A unittask. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.iteri action source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.iteri action source +
                                        +
                                        + Parameters: +
                                          + + + action + + : + int -> 'T -> unit + - + A function to apply to each element of the task sequence that can also access the current index. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<unit> + + A unittask. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Iterates over the input task sequence, applying the action function to each item, + supplying the zero-based index as extra parameter for the action function. + This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + action + + : + int -> 'T -> unit +
                                        +
                                        +

                                        + A function to apply to each element of the task sequence that can also access the current index. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<unit> +
                                        +
                                        +

                                        + A unittask. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.iteriAsync action source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.iteriAsync action source +
                                        +
                                        + Parameters: +
                                          + + + action + + : + int -> 'T -> 'a + - + An asynchronous function to apply to each element of the task sequence that can also access the current index. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<unit> + + A unittask. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Iterates over the input task sequence, applying the asynchronous action function to each item, + supplying the zero-based index as extra parameter for the action function. + This function is non-blocking, but will exhaust the full input sequence as soon as the task is evaluated. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + action + + : + int -> 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to apply to each element of the task sequence that can also access the current index. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<unit> +
                                        +
                                        +

                                        + A unittask. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.last source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.last source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The last element of the task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the last element of the input task sequence given by source. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The last element of the task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.lastOrDefault defaultValue source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.lastOrDefault defaultValue source +
                                        +
                                        + Parameters: +
                                          + + + defaultValue + + : + 'T + - + The value to return when the source sequence is empty. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The last element of the task sequence, or defaultValue if empty. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the last element of the input task sequence given by source, + or defaultValue if the sequence is empty. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + defaultValue + + : + 'T +
                                        +
                                        +

                                        + The value to return when the source sequence is empty. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The last element of the task sequence, or defaultValue if empty. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.length source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.length source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + A task returning the number of elements in the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the length of the sequence. This operation requires the whole sequence to be evaluated and + should not be used on potentially infinite sequences, see lengthOrMax for an alternative. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + A task returning the number of elements in the sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.lengthBy predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.lengthBy predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function to test whether an item in the input sequence should be included in the count. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + A task returning the number of elements for which predicate returns true. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the length of the sequence of all items for which the predicate returns true. + This operation requires the whole sequence to be evaluated and should not be used on potentially infinite sequences. + If predicate is asynchronous, consider using lengthByAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function to test whether an item in the input sequence should be included in the count. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + A task returning the number of elements for which predicate returns true. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.lengthByAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.lengthByAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + A function to test whether an item in the input sequence should be included in the count. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + A task returning the number of elements for which predicate returns true. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the length of the sequence of all items for which the predicate returns true. + This operation requires the whole sequence to be evaluated and should not be used on potentially infinite sequences. + If predicate is synchronous, consider using lengthBy. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to test whether an item in the input sequence should be included in the count. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + A task returning the number of elements for which predicate returns true. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.lengthOrMax max source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.lengthOrMax max source +
                                        +
                                        + Parameters: +
                                          + + + max + + : + int + - + Limit at which to stop evaluating source items for finding the length. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int> + + A task returning the actual length of the sequence, or max if the sequence is longer than max. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the length of the sequence, or max, whichever comes first. This operation requires the task sequence + to be evaluated ether in full, or until max items have been processed. Use this method instead of + length if you need to limit the number of items evaluated, or if the sequence is potentially infinite. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + max + + : + int +
                                        +
                                        +

                                        + Limit at which to stop evaluating source items for finding the length. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int> +
                                        +
                                        +

                                        + A task returning the actual length of the sequence, or max if the sequence is longer than max. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.map mapper source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.map mapper source +
                                        +
                                        + Parameters: +
                                          + + + mapper + + : + 'T -> 'U + - + A function to transform items from the input task sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the mapper + function to each of the elements of the input task sequence in source. + The given function will be applied as elements are pulled using async enumerators retrieved from the + input task sequence. + + If mapper is asynchronous, consider using mapAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapper + + : + 'T -> 'U +
                                        +
                                        +

                                        + A function to transform items from the input task sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.mapAsync mapper source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.mapAsync mapper source +
                                        +
                                        + Parameters: +
                                          + + + mapper + + : + 'T -> 'a + - + An asynchronous function to transform items from the input task sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the asynchronous mapper + function to each of the elements of the input task sequence in source. + The given function will be applied as elements are pulled using async enumerators retrieved from the + input task sequence. + + If mapper is synchronous, consider using map. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapper + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items from the input task sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.mapFold mapping state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.mapFold mapping state source +
                                        +
                                        + Parameters: +
                                          + + + mapping + + : + 'State -> 'T -> 'Result * 'State + - + A function that maps each element to a result while also updating the state. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'Result[] * 'State> + + A task returning a pair of the array of mapped results and the final state. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the function mapping to each element of the task sequence, threading an accumulator + argument through the computation, while also generating a new mapped element for each input element. + If the input function is f and the elements are i0...iN, then + computes both the mapped results r0...rN and the final state in a single pass. + The result is a pair of an array of mapped values and the final state. + If the mapping function mapping is asynchronous, consider using mapFoldAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapping + + : + 'State -> 'T -> 'Result * 'State +
                                        +
                                        +

                                        + A function that maps each element to a result while also updating the state. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'Result[] * 'State> +
                                        +
                                        +

                                        + A task returning a pair of the array of mapped results and the final state. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.mapFoldAsync mapping state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.mapFoldAsync mapping state source +
                                        +
                                        + Parameters: +
                                          + + + mapping + + : + 'State -> 'T -> 'a + - + An asynchronous function that maps each element to a result while also updating the state. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'Result[] * 'State> + + A task returning a pair of the array of mapped results and the final state. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the asynchronous function mapping to each element of the task sequence, + threading an accumulator argument through the computation, while also generating a new mapped element for each input element. + If the input function is f and the elements are i0...iN, then + computes both the mapped results r0...rN and the final state in a single pass. + The result is a pair of an array of mapped values and the final state. + If the mapping function mapping is synchronous, consider using mapFold. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapping + + : + 'State -> 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that maps each element to a result while also updating the state. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'Result[] * 'State> +
                                        +
                                        +

                                        + A task returning a pair of the array of mapped results and the final state. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.mapi mapper source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.mapi mapper source +
                                        +
                                        + Parameters: +
                                          + + + mapper + + : + int -> 'T -> 'U + - + A function to transform items from the input task sequence that also access the current index. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the mapper + function to each of the elements of the input task sequence in source, passing + an extra zero-based index argument to the mapper function. + The given function will be applied as elements are pulled using the MoveNextAsync + method on async enumerators retrieved from the input task sequence. + Does not evaluate the input sequence until requested. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapper + + : + int -> 'T -> 'U +
                                        +
                                        +

                                        + A function to transform items from the input task sequence that also access the current index. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.mapiAsync mapper source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.mapiAsync mapper source +
                                        +
                                        + Parameters: +
                                          + + + mapper + + : + int -> 'T -> 'a + - + An asynchronous function to transform items from the input task sequence that also access the current index. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds a new task sequence whose elements are the results of applying the asynchronous mapper + function to each of the elements of the input task sequence in source, passing + an extra zero-based index argument to the mapper function. + The given function will be applied as elements are pulled using the MoveNextAsync + method on async enumerators retrieved from the input task sequence. + Does not evaluate the input sequence until requested. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapper + + : + int -> 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items from the input task sequence that also access the current index. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.max source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.max source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The largest element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the greatest of all elements of the sequence, compared via max. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The largest element of the sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.maxBy projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.maxBy projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'U + - + A function to transform items from the input sequence into comparable keys. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The largest element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the greatest of all elements of the task sequence, compared via max + on the result of applying the function projection to each element. + + If projection is asynchronous, consider using maxByAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + projection + + : + 'T -> 'U +
                                        +
                                        +

                                        + A function to transform items from the input sequence into comparable keys. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The largest element of the sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        + + ArgumentException + + + Thrown when the input sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.maxByAsync projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.maxByAsync projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'a + - + A function to transform items from the input sequence into comparable keys. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The largest element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the greatest of all elements of the task sequence, compared via max + on the result of applying the function projection to each element. + + If projection is synchronous, consider using maxBy. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + projection + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to transform items from the input sequence into comparable keys. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The largest element of the sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        + + ArgumentException + + + Thrown when the input sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.min source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.min source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The smallest element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the smallest of all elements of the sequence, compared via min. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The smallest element of the sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.minBy projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.minBy projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'U + - + A function to transform items from the input sequence into comparable keys. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The smallest element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the smallest of all elements of the task sequence, compared via min + on the result of applying the function projection to each element. + + If projection is asynchronous, consider using minByAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + projection + + : + 'T -> 'U +
                                        +
                                        +

                                        + A function to transform items from the input sequence into comparable keys. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The smallest element of the sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        + + ArgumentException + + + Thrown when the input sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.minByAsync projection source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.minByAsync projection source +
                                        +
                                        + Parameters: +
                                          + + + projection + + : + 'T -> 'a + - + A function to transform items from the input sequence into comparable keys. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The smallest element of the sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the smallest of all elements of the task sequence, compared via min + on the result of applying the function projection to each element. + + If projection is synchronous, consider using minBy. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + projection + + : + 'T -> 'a +
                                        +
                                        +

                                        + A function to transform items from the input sequence into comparable keys. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The smallest element of the sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        + + ArgumentException + + + Thrown when the input sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofArray source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofArray source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + 'T[] + - + The input array. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given array as a task sequence, that is, as an IAsyncEnumerable<'T>. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + 'T[] +
                                        +
                                        +

                                        + The input array. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input array is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofAsyncArray source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofAsyncArray source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + Async<'T> array + - + The input array-of-asyncs. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given array of Asyncs as a task sequence, that is, as an + IAsyncEnumerable<'T>. An array of asyncs is not the same as a task sequence. + Each async computation in an array of asyncs can be run individually or in parallel, potentially + with overlapping side effects, while a task sequence forces awaiting between the items in the sequence, + preventing such overlap to happen. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + Async<'T> array +
                                        +
                                        +

                                        + The input array-of-asyncs. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofAsyncList source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofAsyncList source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + Async<'T> list + - + The input list-of-asyncs. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given list of Asyncs as a task sequence, that is, as an + IAsyncEnumerable<'T>. A list of asyncs is not the same as a task sequence. + Each async computation in a list of asyncs can be run individually or in parallel, potentially + with overlapping side effects, while a task sequence forces awaiting between the items in the sequence, + preventing such overlap to happen. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + Async<'T> list +
                                        +
                                        +

                                        + The input list-of-asyncs. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofAsyncSeq source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofAsyncSeq source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + Async<'T> seq + - + The input sequence-of-asyncs. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given seq of Asyncs as a task sequence, that is, as an + IAsyncEnumerable<'T>. A sequence of asyncs is not the same as a task sequence. + Each async computation in a sequence of asyncs can be run individually or in parallel, potentially + with overlapping side effects, while a task sequence forces awaiting between the items in the sequence, + preventing such overlap to happen. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + Async<'T> seq +
                                        +
                                        +

                                        + The input sequence-of-asyncs. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofChannel reader + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofChannel reader +
                                        +
                                        + Parameters: +
                                          + + + reader + + : + ChannelReader<'T> + - + The channel reader to read elements from. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A task sequence that yields elements from the channel. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views a ChannelReader<'T> as a task sequence. Elements are yielded as they + become available; the sequence ends when the channel is completed and all buffered elements + have been consumed. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + reader + + : + ChannelReader<'T> +
                                        +
                                        +

                                        + The channel reader to read elements from. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A task sequence that yields elements from the channel. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when reader is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofList source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofList source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + 'T list + - + The input list. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given list as a task sequence, that is, as an IAsyncEnumerable<'T>. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + 'T list +
                                        +
                                        +

                                        + The input list. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofResizeArray source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofResizeArray source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + ResizeArray<'T> + - + The input resize array. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given resizable array as a task sequence, that is, as an IAsyncEnumerable<'T>. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + ResizeArray<'T> +
                                        +
                                        +

                                        + The input resize array. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input resize array is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofSeq source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofSeq source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + 'T seq + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given seq as a task sequence, that is, as an IAsyncEnumerable<'T>. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + 'T seq +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofTaskArray source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofTaskArray source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + 'a array + - + The input array-of-tasks. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given array of Tasks as a task sequence, that is, as an + IAsyncEnumerable<'T>. An array of tasks will typically already be hot-started, + as a result, each task can already run and potentially out of order, or with + overlapping side effects, while a task sequence forces awaiting between the items in the sequence, + preventing such overlap to happen. Converting an array of tasks into a task sequence is no guarantee + that overlapping side effects are prevented. Safe for side-effect free tasks. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + 'a array +
                                        +
                                        +

                                        + The input array-of-tasks. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input array is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofTaskList source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofTaskList source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + 'a list + - + The input list-of-tasks. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given list of Tasks as a task sequence, that is, as an + IAsyncEnumerable<'T>. A list of tasks will typically already be hot-started, + as a result, each task can already run and potentially out of order, or with + overlapping side effects, while a task sequence forces awaiting between the items in the sequence, + preventing such overlap to happen. Converting a list of tasks into a task sequence is no guarantee + that overlapping side effects are prevented. Safe for side-effect free tasks. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + 'a list +
                                        +
                                        +

                                        + The input list-of-tasks. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.ofTaskSeq source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.ofTaskSeq source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + 'a seq + - + The input sequence-of-tasks. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the given seq of Tasks as a task sequence, that is, as an + IAsyncEnumerable<'T>. A sequence of tasks is not the same as a task sequence. + Each task in a sequence of tasks can be run individually and potentially out of order, or with + overlapping side effects, while a task sequence forces awaiting between the items in the sequence, + preventing such overlap to happen. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + 'a seq +
                                        +
                                        +

                                        + The input sequence-of-tasks. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.pairwise source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.pairwise source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T * 'T> + + A task sequence of consecutive element pairs. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence of each element in the source paired with its successor. + The sequence is empty if the source has fewer than two elements. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T * 'T> +
                                        +
                                        +

                                        + A task sequence of consecutive element pairs. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.partition predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.partition predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that returns true for elements to include in the first array. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T[] * 'T[]> + + A task returning a tuple of two arrays: (trueItems, falseItems). +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Splits the task sequence into two arrays: those for which the given predicate returns true, + and those for which it returns false. The relative order of elements within each partition is preserved. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function consumes the entire source task sequence before returning. + If the predicate function predicate is asynchronous, consider using + partitionAsync. + +

                                        +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that returns true for elements to include in the first array. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T[] * 'T[]> +
                                        +
                                        +

                                        + A task returning a tuple of two arrays: (trueItems, falseItems). +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.partitionAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.partitionAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that returns true for elements to include in the first array. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T[] * 'T[]> + + A task returning a tuple of two arrays: (trueItems, falseItems). +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Splits the task sequence into two arrays using an asynchronous predicate: those for which the predicate returns + true, and those for which it returns false. The relative order of elements within each partition + is preserved. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + This function consumes the entire source task sequence before returning. + If the predicate function predicate is synchronous, consider using + partition. + +

                                        +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that returns true for elements to include in the first array. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T[] * 'T[]> +
                                        +
                                        +

                                        + A task returning a tuple of two arrays: (trueItems, falseItems). +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.pick chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.pick chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'U option + - + A function to transform items of type 'T into options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'U> + + The selected element. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given function chooser to successive elements, returning the first result where + the function returns Some(x). Throws an exception if none is found. + If chooser is asynchronous, consider using pickAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'U option +
                                        +
                                        +

                                        + A function to transform items of type 'T into options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'U> +
                                        +
                                        +

                                        + The selected element. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + KeyNotFoundException + + + Thrown when every item of the sequence evaluates to None when the given function is applied. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.pickAsync chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.pickAsync chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'a + - + An asynchronous function to transform items of type 'T into options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'U> + + The selected element. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given asynchronous function chooser to successive elements, returning the first result where + the function returns Some(x). Throws an exception if none is found. + If chooser is synchronous, consider using pick. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items of type 'T into options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'U> +
                                        +
                                        +

                                        + The selected element. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + KeyNotFoundException + + + Thrown when every item of the sequence evaluates to None when the given function is applied. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.prependSeq source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.prependSeq source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + source1 + + : + 'T seq + - + The input F# seq sequence. + +
                                          + + + source2 + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Concatenates a (non-async) F# seq in source1 with a task sequence in source2 + and returns a single task sequence. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source1 + + : + 'T seq +
                                        +
                                        +

                                        + The input F# seq sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the input sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.reduce folder source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.reduce folder source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'T -> 'T -> 'T + - + A function that updates the state with each element from the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The final state value after applying the reduction function to all elements. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the function folder to each element of the task sequence, threading + an accumulator argument through the computation. The first element is used as the initial state. If the input + function is f and the elements are i0...iN, then computes + f (... (f i0 i1)...) iN. Raises ArgumentException when the + sequence is empty. + If the accumulator function folder is asynchronous, consider using reduceAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'T -> 'T -> 'T +
                                        +
                                        +

                                        + A function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The final state value after applying the reduction function to all elements. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.reduceAsync folder source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.reduceAsync folder source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'T -> 'T -> 'a + - + A function that updates the state with each element from the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T> + + The final state value after applying the reduction function to all elements. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the asynchronous function folder to each element of the task sequence, threading + an accumulator argument through the computation. The first element is used as the initial state. If the input + function is f and the elements are i0...iN, then computes + f (... (f i0 i1)...) iN. Raises ArgumentException when the + sequence is empty. + If the accumulator function folder is synchronous, consider using reduce. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'T -> 'T -> 'a +
                                        +
                                        +

                                        + A function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T> +
                                        +
                                        +

                                        + The final state value after applying the reduction function to all elements. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.removeAt index source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.removeAt index source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index where the item should be removed. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The result task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Return a new task sequence with the item at the given index removed. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index where the item should be removed. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The result task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when index is below 0 or greater than source length. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.removeManyAt index count source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.removeManyAt index count source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index where the items should be removed. + +
                                          + + + count + + : + int + - + The number of items to remove. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The result task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Return a new task sequence with the number of items starting at a given index removed. + If count is negative or zero, no items are removed. If index + + count is greater than source length, but index is not, then + all items until end of sequence are removed. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index where the items should be removed. +

                                        +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The number of items to remove. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The result task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when index is below 0 or greater than source length. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.replicate count value + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.replicate count value +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The number of times to replicate the value. + +
                                          + + + value + + : + 'T + - + The value to replicate. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A task sequence containing count copies of value. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Creates a task sequence by replicating value a total of count times. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The number of times to replicate the value. +

                                        +
                                        +
                                        + + value + + : + 'T +
                                        +
                                        +

                                        + The value to replicate. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A task sequence containing count copies of value. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentException + + + Thrown when count is negative. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.replicateInfinite value + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.replicateInfinite value +
                                        +
                                        + Parameters: +
                                          + + + value + + : + 'T + - + The value to repeat. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + An infinite task sequence of value. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Creates an infinite task sequence by repeating value indefinitely. + The sequence never ends; use take, takeWhile, + or similar to bound consumption. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + value + + : + 'T +
                                        +
                                        +

                                        + The value to repeat. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + An infinite task sequence of value. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.replicateInfiniteAsync computation + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.replicateInfiniteAsync computation +
                                        +
                                        + Parameters: +
                                          + + + computation + + : + unit -> 'a + - + A function that produces the next value on each invocation. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + An infinite task sequence of values produced by computation. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Creates an infinite task sequence by repeatedly executing computation, + yielding each produced value indefinitely. + The sequence never ends; use take, takeWhile, + or similar to bound consumption. + If the computation is synchronous, consider using replicateInfinite. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + computation + + : + unit -> 'a +
                                        +
                                        +

                                        + A function that produces the next value on each invocation. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + An infinite task sequence of values produced by computation. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.replicateUntilNoneAsync computation + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.replicateUntilNoneAsync computation +
                                        +
                                        + Parameters: +
                                          + + + computation + + : + unit -> 'a + - + + A function that returns Some value to emit, or None to end the sequence. + + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A task sequence of values produced by computation until it returns None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Creates a task sequence by repeatedly executing computation until it returns + None, yielding each Some value in order. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + computation + + : + unit -> 'a +
                                        +
                                        +

                                        + + A function that returns Some value to emit, or None to end the sequence. + +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A task sequence of values produced by computation until it returns None. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.scan folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.scan 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 + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'State> + + A task sequence of states, starting with the initial state and applying the folder to each element. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Like fold, but returns the sequence of intermediate results and the final result. + The first element of the output sequence is always the initial state. If the input task sequence + has N elements, the output task sequence has N + 1 elements. + If the folder function folder is asynchronous, consider using scanAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'State +
                                        +
                                        +

                                        + A function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'State> +
                                        +
                                        +

                                        + A task sequence of states, starting with the initial state and applying the folder to each element. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.scanAsync folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.scanAsync folder state source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'State -> 'T -> 'a + - + A function that updates the state with each element from the sequence. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'State> + + A task sequence of states, starting with the initial state and applying the folder to each element. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Like foldAsync, but returns the sequence of intermediate results and the final result. + The first element of the output sequence is always the initial state. If the input task sequence + has N elements, the output task sequence has N + 1 elements. + If the folder function folder is synchronous, consider using scan. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'a +
                                        +
                                        +

                                        + A function that updates the state with each element from the sequence. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'State> +
                                        +
                                        +

                                        + A task sequence of states, starting with the initial state and applying the folder to each element. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.singleton value + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.singleton value +
                                        +
                                        + Parameters: +
                                          + + + value + + : + 'T + - + The input item to use as the single item of the task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A task sequence containing exactly one element. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Creates a task sequence from value that generates a single element and then ends. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + value + + : + 'T +
                                        +
                                        +

                                        + The input item to use as the single item of the task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A task sequence containing exactly one element. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + TaskSeq.skip count source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.skip count source +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The number of items to skip. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, skips count elements of the underlying + sequence, and then yields the remainder. Raises an exception if there are not count + items. See drop for a version that does not raise an exception. + See also take for the inverse of this operation. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The number of items to skip. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + + Thrown when count is less than zero or when + it exceeds the number of elements in the sequence. + +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.skipWhile predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.skipWhile predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to false when no more items should be skipped. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, skips elements of the underlying sequence while the + given function predicate returns true, and then yields the remaining + elements. Elements where the predicate returns false are propagated, which means that this + function may not skip any elements (see also skipWhileInclusive). + If predicate is asynchronous, consider using skipWhileAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to false when no more items should be skipped. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.skipWhileAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.skipWhileAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to false when no more items should be skipped. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, skips elements of the underlying sequence while the + given asynchronous function predicate returns true, and then yields the + remaining elements. Elements where the predicate returns false are propagated, which means that this + function may not skip any elements (see also skipWhileInclusiveAsync). + If predicate is synchronous, consider using skipWhile. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to false when no more items should be skipped. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.skipWhileInclusive predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.skipWhileInclusive predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to false for the final item to be skipped. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, skips elements of the underlying sequence until the given + function predicate returns false, also skips that element + and then yields the remaining elements (see also skipWhile). It will thus always skip + at least one element of a non-empty sequence, or returns the empty task sequence if the input is empty. + If predicate is asynchronous, consider using skipWhileInclusiveAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to false for the final item to be skipped. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.skipWhileInclusiveAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.skipWhileInclusiveAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to false for the final item to be skipped. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, skips elements of the underlying sequence until the given + function predicate returns false, also skips that element + and then yields the remaining elements (see also skipWhileAsync). It will thus always skip + at least one element of a non-empty sequence, or returns the empty task sequence if the input is empty. + If predicate is synchronous, consider using skipWhileInclusive. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to false for the final item to be skipped. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.splitAt count source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.splitAt count source +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The maximum number of elements in the prefix. Must be non-negative. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T[] * TaskSeq<'T>> + + A task returning a tuple (prefix, rest) where prefix is an array of the first elements and rest is the remaining task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Splits the task sequence into a prefix array of at most count elements and a task + sequence containing the remaining elements. The prefix is eagerly evaluated in a single pass; the + remaining sequence is lazy. If the source has fewer than count elements, the prefix + array is shorter than count and the remaining sequence is empty. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + The prefix array and the remaining task sequence share a single enumerator over source. + For sequences backed by replayable data (arrays, lists, taskSeq builders, etc.) this is always safe. + For externally-managed resources (network streams, database cursors) the remaining sequence should be + consumed or disposed before any other operation on source. + +

                                        +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The maximum number of elements in the prefix. Must be non-negative. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T[] * TaskSeq<'T>> +
                                        +
                                        +

                                        + A task returning a tuple (prefix, rest) where prefix is an array of the first elements and rest is the remaining task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when count is negative. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tail source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tail source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<TaskSeq<'T>> + + The input task sequence minus the first element. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the whole task sequence from source, minus its first element. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<TaskSeq<'T>> +
                                        +
                                        +

                                        + The input task sequence minus the first element. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when the task sequence is empty. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.take count source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.take count source +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The number of items to take. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, yields count elements of the + underlying sequence, and then returns no further elements. Raises an exception if there are not enough + elements in the sequence. See truncate for a version that does not raise an exception. + See also skip for the inverse of this operation. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The number of items to take. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + + Thrown when count is less than zero or when + it exceeds the number of elements in the sequence. + +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.takeWhile predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.takeWhile predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to false when no more items should be returned. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, yields elements of the underlying sequence while the + given function predicate returns true, and then returns no further elements. + Stops consuming the source and yielding items as soon as the predicate returns false. + (see also takeWhileInclusive). + If predicate is asynchronous, consider using takeWhileAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to false when no more items should be returned. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.takeWhileAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.takeWhileAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to false when no more items should be returned. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, yields elements of the underlying sequence while the + given asynchronous function predicate returns true, and then returns no further elements. + Stops consuming the source and yielding items as soon as the predicate returns false. + (see also takeWhileInclusiveAsync). + If predicate is synchronous, consider using takeWhile. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to false when no more items should be returned. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.takeWhileInclusive predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.takeWhileInclusive predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to false when no more items should be returned. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, yields elements of the underlying sequence until the given + function predicate returns false, returns that element + and then returns no further elements (see also takeWhile). This function returns + at least one element of a non-empty sequence, or the empty task sequence if the input is empty. + If predicate is asynchronous, consider using takeWhileInclusiveAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to false when no more items should be returned. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.takeWhileInclusiveAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.takeWhileInclusiveAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to false when no more items should be returned. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, yields elements of the underlying sequence until the given + asynchronous function predicate returns false, returns that element + and then returns no further elements (see also takeWhileAsync). This function returns + at least one element of a non-empty sequence, or the empty task sequence if the input is empty. + If predicate is synchronous, consider using takeWhileInclusive. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to false when no more items should be returned. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.threadState folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.threadState folder state source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'State -> 'T -> 'Result * 'State + - + A function that maps each element to a result while also updating the state. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'Result> + + A task sequence of mapped results, produced lazily in source order. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the function folder to each element of the task sequence, threading a state + argument through the computation, and lazily yields each mapped result as a new task sequence. Unlike + mapFold, the results are streamed rather than collected into an array, and the + final state is not returned. + If the folder function is asynchronous, consider using threadStateAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'Result * 'State +
                                        +
                                        +

                                        + A function that maps each element to a result while also updating the state. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'Result> +
                                        +
                                        +

                                        + A task sequence of mapped results, produced lazily in source order. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.threadStateAsync folder state source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.threadStateAsync folder state source +
                                        +
                                        + Parameters: +
                                          + + + folder + + : + 'State -> 'T -> 'a + - + An asynchronous function that maps each element to a result while also updating the state. + +
                                          + + + state + + : + 'State + - + The initial state. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'Result> + + A task sequence of mapped results, produced lazily in source order. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the asynchronous function folder to each element of the task sequence, threading + a state argument through the computation, and lazily yields each mapped result as a new task sequence. Unlike + mapFoldAsync, the results are streamed rather than collected into an array, and the + final state is not returned. + If the folder function is synchronous, consider using threadState. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + folder + + : + 'State -> 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that maps each element to a result while also updating the state. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'Result> +
                                        +
                                        +

                                        + A task sequence of mapped results, produced lazily in source order. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toArray source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toArray source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + 'T[] + + The resulting array. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds an array from the input task sequence in source. + This function is blocking until the sequence is exhausted and will then properly dispose of the resources. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + 'T[] +
                                        +
                                        +

                                        + The resulting array. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toArrayAsync source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toArrayAsync source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T[]> + + The resulting array. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds an array asynchronously from the input task sequence. + This function is non-blocking while it builds the array. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T[]> +
                                        +
                                        +

                                        + The resulting array. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toChannelAsync writer source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toChannelAsync writer source +
                                        +
                                        + Parameters: +
                                          + + + writer + + : + ChannelWriter<'T> + - + The channel writer to write elements into. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task + + A Task that completes when all elements have been written. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Writes all elements of the input task sequence source to a + ChannelWriter<'T> and marks the writer as complete when the sequence + is exhausted. If an exception is raised during iteration, the writer is completed with + that exception so that downstream readers observe it. + This function is non-blocking while it writes to the channel. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + writer + + : + ChannelWriter<'T> +
                                        +
                                        +

                                        + The channel writer to write elements into. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task +
                                        +
                                        +

                                        + A Task that completes when all elements have been written. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when writer or source is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toIListAsync source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toIListAsync source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<IList<'T>> + + The resulting IList interface. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds an IList<'T> asynchronously from the input task sequence. + This function is non-blocking while it builds the IList. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<IList<'T>> +
                                        +
                                        +

                                        + The resulting IList interface. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toList source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toList source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + 'T list + + The resulting list. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds an F# list from the input task sequence in source. + This function is blocking until the sequence is exhausted and will then properly dispose of the resources. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + 'T list +
                                        +
                                        +

                                        + The resulting list. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toListAsync source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toListAsync source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T list> + + The resulting list. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Builds an F# list asynchronously from the input task sequence. + This function is non-blocking while it builds the list. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T list> +
                                        +
                                        +

                                        + The resulting list. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toResizeArrayAsync source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toResizeArrayAsync source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<ResizeArray<'T>> + + The resulting resizable array. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Gathers items into a ResizeArray (see List<_>) asynchronously from the input task sequence. + This function is non-blocking while it builds the resizable array. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<ResizeArray<'T>> +
                                        +
                                        +

                                        + The resulting resizable array. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.toSeq source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.toSeq source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + 'T seq + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Views the task sequence in source as an F# seq, that is, an + IEnumerable<_>. This function is blocking at each call + to MoveNext() in the resulting sequence. + Resources are disposed when the enumerator is disposed, or the enumerator is exhausted. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + 'T seq +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.truncate count source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.truncate count source +
                                        +
                                        + Parameters: +
                                          + + + count + + : + int + - + The maximum number of items to enumerate. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, yields at most count elements of the underlying + sequence, truncating the remainder, if any. + See take for a version that raises an exception if there are not enough elements in the + sequence. See also drop for the inverse of this operation. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + count + + : + int +
                                        +
                                        +

                                        + The maximum number of items to enumerate. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when count is less than zero. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryExactlyOne source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryExactlyOne source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The only element of the singleton task sequence, or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the only element of the task sequence, or None if the sequence is empty of + contains more than one element. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The only element of the singleton task sequence, or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryFind predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryFind predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The found element or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element for which the given function predicate returns + true. Returns None if no such element exists. + If predicate is asynchronous, consider using tryFindAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The found element or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryFindAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryFindAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The found element or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element for which the given asynchronous function predicate returns + true. Returns None if no such element exists. + If predicate is synchronous, consider using tryFind. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The found element or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryFindIndex predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryFindIndex predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int option> + + The found element or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the index, starting from zero, for which the given function predicate returns + true. Returns None if no such element exists. + If predicate is asynchronous, consider using tryFindIndexAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int option> +
                                        +
                                        +

                                        + The found element or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryFindIndexAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryFindIndexAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function that evaluates to a bool when given an item in the sequence. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<int option> + + The found element or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the index, starting from zero, for which the given asynchronous function predicate returns + true. Returns None if no such element exists. + If predicate is synchronous, consider using tryFindIndex. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function that evaluates to a bool when given an item in the sequence. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<int option> +
                                        +
                                        +

                                        + The found element or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryHead source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryHead source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The first element of the task sequence, or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the first element of the input task sequence given by source, + or None if the sequence is empty. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The first element of the task sequence, or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryItem index source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryItem index source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index of the item to retrieve. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The nth element of the task sequence, or None if it doesn't exist. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the nth element of the input task sequence given by source, + or None if the sequence does not contain enough elements. + The index is zero-based, that is, using index 0 returns the first element. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index of the item to retrieve. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The nth element of the task sequence, or None if it doesn't exist. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryLast source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryLast source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The last element of the task sequence, or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the last element of the input task sequence given by source, + or None if the sequence is empty. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The last element of the task sequence, or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryMax source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryMax source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The largest element of the sequence wrapped in Some, or None if the sequence is empty. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns Some with the greatest of all elements of the task sequence, compared via max, + or None if the sequence is empty. For sequences that should never be empty, prefer max. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The largest element of the sequence wrapped in Some, or None if the sequence is empty. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryMin source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryMin source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'T option> + + The smallest element of the sequence wrapped in Some, or None if the sequence is empty. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns Some with the smallest of all elements of the task sequence, compared via min, + or None if the sequence is empty. For sequences that should never be empty, prefer min. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'T option> +
                                        +
                                        +

                                        + The smallest element of the sequence wrapped in Some, or None if the sequence is empty. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryPick chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryPick chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'U option + - + A function to transform items of type 'T into options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'U option> + + The chosen element or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given function chooser to successive elements, returning the first result where + the function returns Some(x). + If chooser is asynchronous, consider using tryPickAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'U option +
                                        +
                                        +

                                        + A function to transform items of type 'T into options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'U option> +
                                        +
                                        +

                                        + The chosen element or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryPickAsync chooser source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryPickAsync chooser source +
                                        +
                                        + Parameters: +
                                          + + + chooser + + : + 'T -> 'a + - + An asynchronous function to transform items of type 'T into options of type 'U. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<'U option> + + The chosen element or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Applies the given asynchronous function chooser to successive elements, returning the first result where + the function returns Some(x). + If chooser is synchronous, consider using tryPick. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + chooser + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to transform items of type 'T into options of type 'U. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<'U option> +
                                        +
                                        +

                                        + The chosen element or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.tryTail source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.tryTail source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + Task<TaskSeq<'T> option> + + The input task sequence minus the first element, or None. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns the whole input task sequence given by source, minus its first element, + or None if the sequence is empty. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + Task<TaskSeq<'T> option> +
                                        +
                                        +

                                        + The input task sequence minus the first element, or None. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.unbox source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.unbox source +
                                        +
                                        + Parameters: +
                                          + + + source + + : + TaskSeq<obj> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'U> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Calls unbox on each item when the task sequence is consumed. + The target type must be a value type. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source + + : + TaskSeq<obj> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'U> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + InvalidCastException + + + Thrown when the function is unable to cast an item to the target type. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.unfold generator state + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.unfold generator state +
                                        +
                                        + Parameters: +
                                          + + + generator + + : + 'State -> ('T * 'State) option + - + A function that takes the current state and returns either None to terminate, + or Some(element, newState) to yield an element and continue with a new state. + +
                                          + + + state + + : + 'State + - + The initial state value. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence generated by applying the generator function to a state value, until it returns None. + Each call to generator returns either None, which terminates the sequence, or + Some(element, newState), which yields element and updates the state for the next call. + Unlike init, the number of elements need not be known in advance. + If the generator function is asynchronous, consider using unfoldAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + generator + + : + 'State -> ('T * 'State) option +
                                        +
                                        +

                                        + A function that takes the current state and returns either None to terminate, + or Some(element, newState) to yield an element and continue with a new state. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state value. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.unfoldAsync generator state + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.unfoldAsync generator state +
                                        +
                                        + Parameters: +
                                          + + + generator + + : + 'State -> Task<('T * 'State) option> + - + An async function that takes the current state and returns either None to terminate, + or Some(element, newState) to yield an element and continue with a new state. + +
                                          + + + state + + : + 'State + - + The initial state value. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence generated by applying the asynchronous generator function to a state value, until it + returns None. Each call to generator returns either None, which terminates the + sequence, or Some(element, newState), which yields element and updates the state. + Unlike initAsync, the number of elements need not be known in advance. + If the generator function is synchronous, consider using unfold. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + generator + + : + 'State -> Task<('T * 'State) option> +
                                        +
                                        +

                                        + An async function that takes the current state and returns either None to terminate, + or Some(element, newState) to yield an element and continue with a new state. +

                                        +
                                        +
                                        + + state + + : + 'State +
                                        +
                                        +

                                        + The initial state value. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.updateAt index value source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.updateAt index value source +
                                        +
                                        + Parameters: +
                                          + + + index + + : + int + - + The index of the item to be replaced. + +
                                          + + + value + + : + 'T + - + The new value. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The result task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Return a new task sequence with the item at a given index set to the new value. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + index + + : + int +
                                        +
                                        +

                                        + The index of the item to be replaced. +

                                        +
                                        +
                                        + + value + + : + 'T +
                                        +
                                        +

                                        + The new value. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The result task sequence. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when index is below 0 or greater than source length. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.where predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.where predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> bool + - + A function to test whether an item in the input sequence should be included in the output or not. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence containing only the elements of the collection + for which the given function predicate returns true. + If predicate is asynchronous, consider using whereAsync. + + Alias for filter. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> bool +
                                        +
                                        +

                                        + A function to test whether an item in the input sequence should be included in the output or not. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.whereAsync predicate source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.whereAsync predicate source +
                                        +
                                        + Parameters: +
                                          + + + predicate + + : + 'T -> 'a + - + An asynchronous function to test whether an item in the input sequence should be included in the output or not. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + The resulting task sequence. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a new task sequence containing only the elements of the input sequence + for which the given function predicate returns true. + If predicate is synchronous, consider using where. + + Alias for filterAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + predicate + + : + 'T -> 'a +
                                        +
                                        +

                                        + An asynchronous function to test whether an item in the input sequence should be included in the output or not. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + The resulting task sequence. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.windowed windowSize source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.windowed windowSize source +
                                        +
                                        + Parameters: +
                                          + + + windowSize + + : + int + - + The number of elements in each window. Must be positive. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T[]> + + A task sequence of overlapping array windows. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence of sliding windows of a given size over the source sequence. + Each window is a fresh array of exactly windowSize consecutive elements. + The result is empty if the source has fewer than windowSize elements. + + Uses a ring buffer internally to avoid redundant copies, yielding one allocation per window. + + If windowSize is not positive, an ArgumentException is raised immediately + (before the sequence is evaluated). + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + windowSize + + : + int +
                                        +
                                        +

                                        + The number of elements in each window. Must be positive. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T[]> +
                                        +
                                        +

                                        + A task sequence of overlapping array windows. +

                                        +
                                        +
                                        + + + + + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        + + ArgumentException + + + Thrown when windowSize is not positive. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.withCancellation cancellationToken source + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.withCancellation cancellationToken source +
                                        +
                                        + Parameters: +
                                          + + + cancellationToken + + : + CancellationToken + - + The cancellation token to pass to GetAsyncEnumerator. + +
                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T> + + A task sequence that uses the given cancellationToken when iterated. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Returns a task sequence that, when iterated, passes the given cancellationToken to the + underlying IAsyncEnumerable<'T>. This is the equivalent of calling + .WithCancellation(cancellationToken) on an IAsyncEnumerable<'T>. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +

                                        + + The cancellationToken supplied to this function overrides any token that would otherwise + be passed to the enumerator. This is useful when consuming sequences from libraries such as Entity Framework, + which accept a CancellationToken through GetAsyncEnumerator. + +

                                        +
                                        +
                                        + + cancellationToken + + : + CancellationToken +
                                        +
                                        +

                                        + The cancellation token to pass to GetAsyncEnumerator. +

                                        +
                                        +
                                        + + source + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T> +
                                        +
                                        +

                                        + A task sequence that uses the given cancellationToken when iterated. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.zip source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.zip source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + source1 + + : + TaskSeq<'T> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'U> + - + The second input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T * 'U> + + The result task sequence of tuples. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the two task sequences into a new task sequence of pairs. The two sequences need not have equal lengths: + when one sequence is exhausted any remaining elements in the other sequence are ignored. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'U> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T * 'U> +
                                        +
                                        +

                                        + The result task sequence of tuples. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the two input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.zip3 source1 source2 source3 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.zip3 source1 source2 source3 +
                                        +
                                        + Parameters: +
                                          + + + source1 + + : + TaskSeq<'T1> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'T2> + - + The second input task sequence. + +
                                          + + + source3 + + : + TaskSeq<'T3> + - + The third input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'T1 * 'T2 * 'T3> + + The result task sequence of triples. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines the three task sequences into a new task sequence of triples. The three sequences need not have equal lengths: + when one sequence is exhausted any remaining elements in the other sequences are ignored. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + source1 + + : + TaskSeq<'T1> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T2> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        + + source3 + + : + TaskSeq<'T3> +
                                        +
                                        +

                                        + The third input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'T1 * 'T2 * 'T3> +
                                        +
                                        +

                                        + The result task sequence of triples. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when any of the three input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.zipWith mapping source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.zipWith mapping source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + mapping + + : + 'T -> 'U -> 'V + - + A function to apply to each element pair. + +
                                          + + + source1 + + : + TaskSeq<'T> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'U> + - + The second input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'V> + + The result task sequence of mapped values. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines two task sequences and applies the given function mapping to corresponding + element pairs. The sequences need not have equal lengths: when one is exhausted any remaining elements in + the other are ignored. + If the mapping function is asynchronous, consider using zipWithAsync. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapping + + : + 'T -> 'U -> 'V +
                                        +
                                        +

                                        + A function to apply to each element pair. +

                                        +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'U> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'V> +
                                        +
                                        +

                                        + The result task sequence of mapped values. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the two input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.zipWith3 mapping source1 source2 source3 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.zipWith3 mapping source1 source2 source3 +
                                        +
                                        + Parameters: +
                                          + + + mapping + + : + 'T1 -> 'T2 -> 'T3 -> 'V + - + A function to apply to each element triple. + +
                                          + + + source1 + + : + TaskSeq<'T1> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'T2> + - + The second input task sequence. + +
                                          + + + source3 + + : + TaskSeq<'T3> + - + The third input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'V> + + The result task sequence of mapped values. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines three task sequences and applies the given function mapping to corresponding + element triples. The sequences need not have equal lengths: when one is exhausted any remaining elements in + the others are ignored. + If the mapping function is asynchronous, consider using zipWithAsync3. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapping + + : + 'T1 -> 'T2 -> 'T3 -> 'V +
                                        +
                                        +

                                        + A function to apply to each element triple. +

                                        +
                                        +
                                        + + source1 + + : + TaskSeq<'T1> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T2> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        + + source3 + + : + TaskSeq<'T3> +
                                        +
                                        +

                                        + The third input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'V> +
                                        +
                                        +

                                        + The result task sequence of mapped values. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when any of the three input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.zipWithAsync mapping source1 source2 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.zipWithAsync mapping source1 source2 +
                                        +
                                        + Parameters: +
                                          + + + mapping + + : + 'T -> 'U -> 'a + - + An asynchronous function to apply to each element pair. + +
                                          + + + source1 + + : + TaskSeq<'T> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'U> + - + The second input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'V> + + The result task sequence of mapped values. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines two task sequences and applies the given asynchronous function mapping to + corresponding element pairs. The sequences need not have equal lengths: when one is exhausted any remaining + elements in the other are ignored. + If the mapping function is synchronous, consider using zipWith. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapping + + : + 'T -> 'U -> 'a +
                                        +
                                        +

                                        + An asynchronous function to apply to each element pair. +

                                        +
                                        +
                                        + + source1 + + : + TaskSeq<'T> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'U> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'V> +
                                        +
                                        +

                                        + The result task sequence of mapped values. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when either of the two input task sequences is null. +
                                        +
                                        +
                                        +
                                        + +

                                        + + + TaskSeq.zipWithAsync3 mapping source1 source2 source3 + + +

                                        +                                         +
                                        +
                                        + Full Usage: + TaskSeq.zipWithAsync3 mapping source1 source2 source3 +
                                        +
                                        + Parameters: +
                                          + + + mapping + + : + 'T1 -> 'T2 -> 'T3 -> 'a + - + An asynchronous function to apply to each element triple. + +
                                          + + + source1 + + : + TaskSeq<'T1> + - + The first input task sequence. + +
                                          + + + source2 + + : + TaskSeq<'T2> + - + The second input task sequence. + +
                                          + + + source3 + + : + TaskSeq<'T3> + - + The third input task sequence. + +
                                          +
                                        +
                                        + + Returns: + TaskSeq<'V> + + The result task sequence of mapped values. +
                                        +
                                        +
                                        +
                                        +                                         		+
                                        + +
                                        +
                                        +

                                        + + Combines three task sequences and applies the given asynchronous function mapping to + corresponding element triples. The sequences need not have equal lengths: when one is exhausted any remaining + elements in the others are ignored. + If the mapping function is synchronous, consider using zipWith3. + +

                                        +
                                        +
                                        + + + +
                                        + +
                                        +
                                        + +
                                        +
                                        +
                                        +                                         +
                                        +
                                        + + mapping + + : + 'T1 -> 'T2 -> 'T3 -> 'a +
                                        +
                                        +

                                        + An asynchronous function to apply to each element triple. +

                                        +
                                        +
                                        + + source1 + + : + TaskSeq<'T1> +
                                        +
                                        +

                                        + The first input task sequence. +

                                        +
                                        +
                                        + + source2 + + : + TaskSeq<'T2> +
                                        +
                                        +

                                        + The second input task sequence. +

                                        +
                                        +
                                        + + source3 + + : + TaskSeq<'T3> +
                                        +
                                        +

                                        + The third input task sequence. +

                                        +
                                        +
                                        +
                                        +
                                        + + Returns: + + TaskSeq<'V> +
                                        +
                                        +

                                        + The result task sequence of mapped values. +

                                        +
                                        +
                                        + + + + + +
                                        + + ArgumentNullException + + + Thrown when any of the three input task sequences is null. +
                                        +
                                        +
                                        +
                                        +
                                        + +
                                        +
                                        + + + +
                                        +
                                          +

                                          Type something to start searching.

                                          +
                                          +                                           + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqbase-1.html b/reference/fsharp-control-taskseqbase-1.html new file mode 100644 index 00000000..855ec344 --- /dev/null +++ b/reference/fsharp-control-taskseqbase-1.html @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + TaskSeqBase<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                          +
                                          + + + Header menu logo + FSharp.Control.TaskSeq + +
                                          +
                                          + + + + + +
                                          +
                                          + +
                                          +
                                          +
                                          +

                                          + TaskSeqBase<'T> Type +

                                          +
                                          +
                                          + Namespace: + + FSharp.Control + +
                                          +
                                          + Assembly: FSharp.Control.TaskSeq.dll +
                                          +
                                          + Base Type: + obj +
                                          +
                                          + All Interfaces: + IAsyncEnumerator<'T> + , + IAsyncDisposable + , + IAsyncEnumerable<'T> + , + IAsyncStateMachine + , + IValueTaskSource + , + IValueTaskSource<bool> +
                                          +
                                          +
                                          +
                                          +
                                          +

                                          + + Abstract base class for TaskSeq<'Machine, 'T>. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + +

                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +

                                          + Constructors +

                                          + + + + + + + + + + + + + +
                                          + Constructor + + Description + +
                                          +
                                          + +

                                          + + + TaskSeqBase() + + +

                                          +                                           +
                                          +
                                          + Full Usage: + TaskSeqBase() +
                                          +
                                          + + Returns: + TaskSeqBase<'T> + +
                                          +
                                          +
                                          +
                                          +                                           		+
                                          +
                                          + + + +
                                          +
                                          +
                                          + + Returns: + + TaskSeqBase<'T> +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +

                                          + Instance members +

                                          + + + + + + + + + + + + + +
                                          + Instance member + + Description + +
                                          +
                                          + +

                                          + + + this.MoveNextAsyncResult + + +

                                          +                                           +
                                          +
                                          + Full Usage: + this.MoveNextAsyncResult +
                                          +
                                          + + Returns: + ValueTask<bool> + +
                                          + Modifiers: + abstract +
                                          +
                                          +
                                          +
                                          +                                           		+
                                          +
                                          + + + +
                                          +
                                          +
                                          + + Returns: + + ValueTask<bool> +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          +
                                          + +
                                          +
                                          + + + +
                                          +
                                            +

                                            Type something to start searching.

                                            +
                                            +                                             + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqbuilder.html b/reference/fsharp-control-taskseqbuilder.html new file mode 100644 index 00000000..82e7dd97 --- /dev/null +++ b/reference/fsharp-control-taskseqbuilder.html @@ -0,0 +1,1136 @@ + + + + + + + + + + + + + + + + + + TaskSeqBuilder (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                            +
                                            + + + Header menu logo + FSharp.Control.TaskSeq + +
                                            +
                                            + + + + + +
                                            +
                                            + +
                                            +
                                            +
                                            +

                                            + TaskSeqBuilder Type +

                                            +
                                            +
                                            + Namespace: + + FSharp.Control + +
                                            +
                                            + Assembly: FSharp.Control.TaskSeq.dll +
                                            +
                                            + Base Type: + obj +
                                            +
                                            +
                                            +
                                            +
                                            +

                                            + + Main builder class for the taskSeq computation expression. + +

                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +

                                            + Instance members +

                                            + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                            + Instance member + + Description + +
                                            +
                                            + +

                                            + + + this.Combine + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.Combine +
                                            +
                                            + Parameters: + +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + task1 + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            + + task2 + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.Delay + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.Delay +
                                            +
                                            + Parameters: + +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + f + + : + unit -> ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.Run + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.Run +
                                            +
                                            + Parameters: + +
                                            + + Returns: + TaskSeq<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + code + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + TaskSeq<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.TryFinally + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.TryFinally +
                                            +
                                            + Parameters: +
                                              + + + body + + : + ResumableTSC<'T> + +
                                              + + + compensationAction + + : + unit -> unit + +
                                              +
                                            +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + body + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            + + compensationAction + + : + unit -> unit +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.TryFinallyAsync + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.TryFinallyAsync +
                                            +
                                            + Parameters: +
                                              + + + body + + : + ResumableTSC<'T> + +
                                              + + + compensationAction + + : + unit -> Task + +
                                              +
                                            +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + body + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            + + compensationAction + + : + unit -> Task +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.TryWith + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.TryWith +
                                            +
                                            + Parameters: + +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + body + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            + + catch + + : + exn -> ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.Using + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.Using +
                                            +
                                            + Parameters: +
                                              + + + disp + + : + 'Disp + +
                                              + + + body + + : + 'Disp -> ResumableTSC<'T> + +
                                              +
                                            +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'Disp, 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + disp + + : + 'Disp +
                                            +
                                            +
                                            + + body + + : + 'Disp -> ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.While + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.While +
                                            +
                                            + Parameters: +
                                              + + + condition + + : + unit -> bool + +
                                              + + + body + + : + ResumableTSC<'T> + +
                                              +
                                            +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + condition + + : + unit -> bool +
                                            +
                                            +
                                            + + body + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.WhileAsync + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.WhileAsync +
                                            +
                                            + Parameters: + +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            + +
                                            +
                                            +

                                            + Used by `For`. F# currently doesn't support `while!`, so this cannot be called directly from the CE +

                                            +
                                            +
                                            + + + +
                                            + +
                                            +
                                            + +
                                            +
                                            +
                                            +                                             +
                                            +
                                            + + condition + + : + unit -> ValueTask<bool> +
                                            +
                                            +
                                            + + body + + : + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.Yield + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.Yield +
                                            +
                                            + Parameters: +
                                              + + + value + + : + 'T + +
                                              +
                                            +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + value + + : + 'T +
                                            +
                                            +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +

                                            + + + this.Zero + + +

                                            +                                             +
                                            +
                                            + Full Usage: + this.Zero +
                                            +
                                            + + Returns: + ResumableTSC<'T> + +
                                            + Modifiers: + inline +
                                            + Type parameters: + 'T +
                                            +
                                            +
                                            +                                             		+
                                            +
                                            + + + +
                                            +
                                            +
                                            + + Returns: + + ResumableTSC<'T> +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            +
                                            + +
                                            +
                                            + + + +
                                            +
                                              +

                                              Type something to start searching.

                                              +
                                              +                                               + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqbuildermodule.html b/reference/fsharp-control-taskseqbuildermodule.html new file mode 100644 index 00000000..6e11fdd8 --- /dev/null +++ b/reference/fsharp-control-taskseqbuildermodule.html @@ -0,0 +1,285 @@ + + + + + + + + + + + + + + + + + + TaskSeqBuilder (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                              +
                                              + + + Header menu logo + FSharp.Control.TaskSeq + +
                                              +
                                              + + + + + +
                                              +
                                              + +
                                              +
                                              +
                                              +

                                              + TaskSeqBuilder Module +

                                              +
                                              +
                                              + Namespace: + + FSharp.Control + +
                                              +
                                              + Assembly: FSharp.Control.TaskSeq.dll +
                                              +
                                              +
                                              +
                                              +
                                              +

                                              + +

                                              +
                                              +
                                              +
                                              +
                                              +

                                              + Functions and values +

                                              + + + + + + + + + + + + + +
                                              + Function or value + + Description + +
                                              +
                                              + +

                                              + + + taskSeq + + +

                                              +                                               +
                                              +
                                              + Full Usage: + taskSeq +
                                              +
                                              + + Returns: + TaskSeqBuilder + +
                                              +
                                              +
                                              +
                                              +                                               		+
                                              + +
                                              +
                                              +

                                              + + Builds an asynchronous task sequence based on IAsyncEnumerable<'T> using computation expression syntax. + +

                                              +
                                              +
                                              + + + +
                                              + +
                                              +
                                              + +
                                              +
                                              +
                                              +                                               +
                                              +
                                              + + Returns: + + TaskSeqBuilder +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              +
                                              + +
                                              +
                                              + + + +
                                              +
                                                +

                                                Type something to start searching.

                                                +
                                                +                                                 + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqdynamic-1.html b/reference/fsharp-control-taskseqdynamic-1.html new file mode 100644 index 00000000..be9106ac --- /dev/null +++ b/reference/fsharp-control-taskseqdynamic-1.html @@ -0,0 +1,480 @@ + + + + + + + + + + + + + + + + + + TaskSeqDynamic<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                +
                                                + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                +
                                                + + + + + +
                                                +
                                                + +
                                                +
                                                +
                                                +

                                                + TaskSeqDynamic<'T> Type +

                                                +
                                                +
                                                + Namespace: + + FSharp.Control + +
                                                +
                                                + Assembly: FSharp.Control.TaskSeq.dll +
                                                +
                                                + Base Type: + TaskSeqBase<'T> +
                                                +
                                                + All Interfaces: + IValueTaskSource + , + IValueTaskSource<bool> + , + IAsyncStateMachine + , + IAsyncEnumerable<'T> + , + IAsyncEnumerator<'T> + , + IAsyncDisposable +
                                                +
                                                +
                                                +
                                                +
                                                +

                                                + + Dynamic (FSI-compatible) implementation of IAsyncEnumerable<'T> for taskSeq + computation expressions. Used when the F# compiler cannot generate static resumable code (e.g., in FSI). + For use by this library only. + +

                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +

                                                + Record fields +

                                                + + + + + + + + + + + + + + + + + +
                                                + Record Field + + Description + +
                                                +
                                                + +

                                                + + + _initialResumptionFunc + + +

                                                +                                                 +
                                                +
                                                + Full Usage: + _initialResumptionFunc +
                                                +
                                                + + Field type: + TaskSeqResumptionFunc<'T> + +
                                                + Modifiers: + mutable +
                                                +
                                                +
                                                +
                                                +                                                 		+
                                                +
                                                + + + +
                                                +
                                                +
                                                + + Field type: + + TaskSeqResumptionFunc<'T> +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                + +

                                                + + + _machine + + +

                                                +                                                 +
                                                +
                                                + Full Usage: + _machine +
                                                +
                                                + + Field type: + TaskSeqStateMachine<'T> + +
                                                + Modifiers: + mutable +
                                                +
                                                +
                                                +
                                                +                                                 		+
                                                +
                                                + + + +
                                                +
                                                +
                                                + + Field type: + + TaskSeqStateMachine<'T> +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +

                                                + Constructors +

                                                + + + + + + + + + + + + + +
                                                + Constructor + + Description + +
                                                +
                                                + +

                                                + + + TaskSeqDynamic() + + +

                                                +                                                 +
                                                +
                                                + Full Usage: + TaskSeqDynamic() +
                                                +
                                                + + Returns: + TaskSeqDynamic<'T> + +
                                                +
                                                +
                                                +
                                                +                                                 		+
                                                +
                                                + + + +
                                                +
                                                +
                                                + + Returns: + + TaskSeqDynamic<'T> +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +

                                                + Instance members +

                                                + + + + + + + + + + + + + +
                                                + Instance member + + Description + +
                                                +
                                                + +

                                                + + + this.InitDynamicMachineData + + +

                                                +                                                 +
                                                +
                                                + Full Usage: + this.InitDynamicMachineData +
                                                +
                                                + Parameters: + +
                                                +
                                                +
                                                +
                                                +                                                 		+
                                                +
                                                + + + +
                                                +
                                                +
                                                + + ct + + : + CancellationToken +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                +
                                                + +
                                                +
                                                + + + +
                                                +
                                                  +

                                                  Type something to start searching.

                                                  +
                                                  +                                                   + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqdynamicbuilder.html b/reference/fsharp-control-taskseqdynamicbuilder.html new file mode 100644 index 00000000..e2fa1a69 --- /dev/null +++ b/reference/fsharp-control-taskseqdynamicbuilder.html @@ -0,0 +1,276 @@ + + + + + + + + + + + + + + + + + + TaskSeqDynamicBuilder (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                  +
                                                  + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                  +
                                                  + + + + + +
                                                  +
                                                  + +
                                                  +
                                                  +
                                                  +

                                                  + TaskSeqDynamicBuilder Type +

                                                  +
                                                  +
                                                  + Namespace: + + FSharp.Control + +
                                                  +
                                                  + Assembly: FSharp.Control.TaskSeq.dll +
                                                  +
                                                  + Base Type: + TaskSeqBuilder +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +

                                                  + + Builder class for the taskSeqDynamic computation expression. Inherits all members + from TaskSeqBuilder, using the dynamic resumable code path as fallback when the + F# compiler cannot generate static resumable code (e.g., in F# Interactive / FSI). + +

                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +

                                                  + Constructors +

                                                  + + + + + + + + + + + + + +
                                                  + Constructor + + Description + +
                                                  +
                                                  + +

                                                  + + + TaskSeqDynamicBuilder() + + +

                                                  +                                                   +
                                                  +
                                                  + Full Usage: + TaskSeqDynamicBuilder() +
                                                  +
                                                  + + Returns: + TaskSeqDynamicBuilder + +
                                                  +
                                                  +
                                                  +
                                                  +                                                   		+
                                                  +
                                                  + + + +
                                                  +
                                                  +
                                                  + + Returns: + + TaskSeqDynamicBuilder +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  +
                                                  + +
                                                  +
                                                  + + + +
                                                  +
                                                    +

                                                    Type something to start searching.

                                                    +
                                                    +                                                     + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqdynamicbuildermodule.html b/reference/fsharp-control-taskseqdynamicbuildermodule.html new file mode 100644 index 00000000..a473478f --- /dev/null +++ b/reference/fsharp-control-taskseqdynamicbuildermodule.html @@ -0,0 +1,284 @@ + + + + + + + + + + + + + + + + + + TaskSeqDynamicBuilder (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                    +
                                                    + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                    +
                                                    + + + + + +
                                                    +
                                                    + +
                                                    +
                                                    +
                                                    +

                                                    + TaskSeqDynamicBuilder Module +

                                                    +
                                                    +
                                                    + Namespace: + + FSharp.Control + +
                                                    +
                                                    + Assembly: FSharp.Control.TaskSeq.dll +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +

                                                    + +

                                                    +
                                                    +
                                                    +
                                                    +
                                                    +

                                                    + Functions and values +

                                                    + + + + + + + + + + + + + +
                                                    + Function or value + + Description + +
                                                    +
                                                    + +

                                                    + + + taskSeqDynamic + + +

                                                    +                                                     +
                                                    +
                                                    + Full Usage: + taskSeqDynamic +
                                                    +
                                                    + + Returns: + TaskSeqDynamicBuilder + +
                                                    +
                                                    +
                                                    +
                                                    +                                                     		+
                                                    + +
                                                    +
                                                    +

                                                    + Builds an asynchronous task sequence, with a dynamic resumable code fallback for scenarios + where the F# compiler cannot generate static resumable code (e.g., in F# Interactive / FSI). +

                                                    +
                                                    +
                                                    + + + +
                                                    + +
                                                    +
                                                    + +
                                                    +
                                                    +
                                                    +                                                     +
                                                    +
                                                    + + Returns: + + TaskSeqDynamicBuilder +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    +
                                                    + +
                                                    +
                                                    + + + +
                                                    +
                                                      +

                                                      Type something to start searching.

                                                      +
                                                      +                                                       + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqdynamicinfo-1.html b/reference/fsharp-control-taskseqdynamicinfo-1.html new file mode 100644 index 00000000..abd45df6 --- /dev/null +++ b/reference/fsharp-control-taskseqdynamicinfo-1.html @@ -0,0 +1,299 @@ + + + + + + + + + + + + + + + + + + TaskSeqDynamicInfo<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                      +
                                                      + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                      +
                                                      + + + + + +
                                                      +
                                                      + +
                                                      +
                                                      +
                                                      +

                                                      + TaskSeqDynamicInfo<'T> Type +

                                                      +
                                                      +
                                                      + Namespace: + + FSharp.Control + +
                                                      +
                                                      + Assembly: FSharp.Control.TaskSeq.dll +
                                                      +
                                                      + Base Type: + TaskSeqResumptionDynamicInfo<'T> +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +

                                                      + + Concrete implementation of TaskSeqResumptionDynamicInfo<'T> for taskSeq computation + expressions, used in the dynamic (FSI) path. Handles state-machine transitions when the F# compiler + cannot generate static resumable code. + For use by this library only. + +

                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +

                                                      + Constructors +

                                                      + + + + + + + + + + + + + +
                                                      + Constructor + + Description + +
                                                      +
                                                      + +

                                                      + + + TaskSeqDynamicInfo(initialResumptionFunc) + + +

                                                      +                                                       +
                                                      +
                                                      + Full Usage: + TaskSeqDynamicInfo(initialResumptionFunc) +
                                                      +
                                                      + Parameters: + +
                                                      + + Returns: + TaskSeqDynamicInfo<'T> + +
                                                      +
                                                      +
                                                      +
                                                      +                                                       		+
                                                      +
                                                      + + + +
                                                      +
                                                      +
                                                      + + initialResumptionFunc + + : + TaskSeqResumptionFunc<'T> +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      + + Returns: + + TaskSeqDynamicInfo<'T> +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      +
                                                      + +
                                                      +
                                                      + + + +
                                                      +
                                                        +

                                                        Type something to start searching.

                                                        +
                                                        +                                                         + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqextensions-taskseq.html b/reference/fsharp-control-taskseqextensions-taskseq.html new file mode 100644 index 00000000..f5924107 --- /dev/null +++ b/reference/fsharp-control-taskseqextensions-taskseq.html @@ -0,0 +1,1099 @@ + + + + + + + + + + + + + + + + + + TaskSeq (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                        +
                                                        + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                        +
                                                        + + + + + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +

                                                        + TaskSeq Module +

                                                        +
                                                        +
                                                        + Namespace: + + FSharp.Control + +
                                                        +
                                                        + Assembly: FSharp.Control.TaskSeq.dll +
                                                        +
                                                        + Parent Module: + + TaskSeqExtensions + +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +

                                                        + +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        +

                                                        + Functions and values +

                                                        + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                        + Function or value + + Description + +
                                                        +
                                                        + +

                                                        + + + average source + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + average source +
                                                        +
                                                        + Parameters: +
                                                          + + + source + + : + TaskSeq<^T> + - + The input task sequence. + +
                                                          +
                                                        +
                                                        + + Returns: + Task<^T> + + The average of the elements in the sequence. +
                                                        + Modifiers: + inline +
                                                        + Type parameters: + ^T +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + + Returns the average of all elements of the task sequence. The elements must support the + operator + and DivideByInt, which is the case for all built-in F# floating-point types. + For sequences with a projection, consider using averageBy. + +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + source + + : + TaskSeq<^T> +
                                                        +
                                                        +

                                                        + The input task sequence. +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        + + Returns: + + Task<^T> +
                                                        +
                                                        +

                                                        + The average of the elements in the sequence. +

                                                        +
                                                        +
                                                        + + + + + + + + + +
                                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        + + + averageBy projection source + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + averageBy projection source +
                                                        +
                                                        + Parameters: +
                                                          + + + projection + + : + 'T -> ^U + - + A function to transform items from the input sequence into averageable values. + +
                                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                                          +
                                                        +
                                                        + + Returns: + Task<^U> + + The average of the projected values. +
                                                        + Modifiers: + inline +
                                                        + Type parameters: + 'T, ^U +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + + Returns the average of the results generated by applying the projection function to each element + of the task sequence. The result type must support the + operator and DivideByInt, which is the case + for all built-in F# floating-point types. + If projection is asynchronous, consider using averageByAsync. + +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + projection + + : + 'T -> ^U +
                                                        +
                                                        +

                                                        + A function to transform items from the input sequence into averageable values. +

                                                        +
                                                        +
                                                        + + source + + : + TaskSeq<'T> +
                                                        +
                                                        +

                                                        + The input task sequence. +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        + + Returns: + + Task<^U> +
                                                        +
                                                        +

                                                        + The average of the projected values. +

                                                        +
                                                        +
                                                        + + + + + + + + + +
                                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        + + + averageByAsync projection source + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + averageByAsync projection source +
                                                        +
                                                        + Parameters: +
                                                          + + + projection + + : + 'T -> Task<^U> + - + An async function to transform items from the input sequence into averageable values. + +
                                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                                          +
                                                        +
                                                        + + Returns: + Task<^U> + + The average of the projected values. +
                                                        + Modifiers: + inline +
                                                        + Type parameters: + 'T, ^U +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + + Returns the average of the results generated by applying the asynchronous projection function to + each element of the task sequence. The result type must support the + operator and DivideByInt, which + is the case for all built-in F# floating-point types. + If projection is synchronous, consider using averageBy. + +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + projection + + : + 'T -> Task<^U> +
                                                        +
                                                        +

                                                        + An async function to transform items from the input sequence into averageable values. +

                                                        +
                                                        +
                                                        + + source + + : + TaskSeq<'T> +
                                                        +
                                                        +

                                                        + The input task sequence. +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        + + Returns: + + Task<^U> +
                                                        +
                                                        +

                                                        + The average of the projected values. +

                                                        +
                                                        +
                                                        + + + + + + + + + +
                                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                                        + + ArgumentException + + + Thrown when the input task sequence is empty. +
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        + + + empty + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + empty +
                                                        +
                                                        + + Returns: + TaskSeq<'T> + +
                                                        +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + Initialize an empty task sequence. +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + Returns: + + TaskSeq<'T> +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        + + + sum source + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + sum source +
                                                        +
                                                        + Parameters: +
                                                          + + + source + + : + TaskSeq<^T> + - + The input task sequence. + +
                                                          +
                                                        +
                                                        + + Returns: + Task<^T> + + The sum of all elements in the sequence, starting from Unchecked.defaultof as zero. +
                                                        + Modifiers: + inline +
                                                        + Type parameters: + ^T +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + + Returns the sum of all elements of the task sequence. The elements must support the + operator, + which is the case for all built-in numeric types. For sequences with a projection, use sumBy. + +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + source + + : + TaskSeq<^T> +
                                                        +
                                                        +

                                                        + The input task sequence. +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        + + Returns: + + Task<^T> +
                                                        +
                                                        +

                                                        + The sum of all elements in the sequence, starting from Unchecked.defaultof as zero. +

                                                        +
                                                        +
                                                        + + + + + +
                                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        + + + sumBy projection source + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + sumBy projection source +
                                                        +
                                                        + Parameters: +
                                                          + + + projection + + : + 'T -> ^U + - + A function to transform items from the input sequence into summable values. + +
                                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                                          +
                                                        +
                                                        + + Returns: + Task<^U> + + The sum of the projected values. +
                                                        + Modifiers: + inline +
                                                        + Type parameters: + 'T, ^U +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + + Returns the sum of the results generated by applying the projection function to each element + of the task sequence. The result type must support the + operator, which is the case for all built-in numeric types. + If projection is asynchronous, consider using sumByAsync. + +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + projection + + : + 'T -> ^U +
                                                        +
                                                        +

                                                        + A function to transform items from the input sequence into summable values. +

                                                        +
                                                        +
                                                        + + source + + : + TaskSeq<'T> +
                                                        +
                                                        +

                                                        + The input task sequence. +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        + + Returns: + + Task<^U> +
                                                        +
                                                        +

                                                        + The sum of the projected values. +

                                                        +
                                                        +
                                                        + + + + + +
                                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                                        +
                                                        +
                                                        +
                                                        + +

                                                        + + + sumByAsync projection source + + +

                                                        +                                                         +
                                                        +
                                                        + Full Usage: + sumByAsync projection source +
                                                        +
                                                        + Parameters: +
                                                          + + + projection + + : + 'T -> Task<^U> + - + An async function to transform items from the input sequence into summable values. + +
                                                          + + + source + + : + TaskSeq<'T> + - + The input task sequence. + +
                                                          +
                                                        +
                                                        + + Returns: + Task<^U> + + The sum of the projected values. +
                                                        + Modifiers: + inline +
                                                        + Type parameters: + 'T, ^U +
                                                        +
                                                        +
                                                        +                                                         		+
                                                        + +
                                                        +
                                                        +

                                                        + + Returns the sum of the results generated by applying the asynchronous projection function to + each element of the task sequence. The result type must support the + operator, which is the case for all + built-in numeric types. + If projection is synchronous, consider using sumBy. + +

                                                        +
                                                        +
                                                        + + + +
                                                        + +
                                                        +
                                                        + +
                                                        +
                                                        +
                                                        +                                                         +
                                                        +
                                                        + + projection + + : + 'T -> Task<^U> +
                                                        +
                                                        +

                                                        + An async function to transform items from the input sequence into summable values. +

                                                        +
                                                        +
                                                        + + source + + : + TaskSeq<'T> +
                                                        +
                                                        +

                                                        + The input task sequence. +

                                                        +
                                                        +
                                                        +
                                                        +
                                                        + + Returns: + + Task<^U> +
                                                        +
                                                        +

                                                        + The sum of the projected values. +

                                                        +
                                                        +
                                                        + + + + + +
                                                        + + ArgumentNullException + + + Thrown when the input task sequence is null. +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        +
                                                        + +
                                                        +
                                                        + + + +
                                                        +
                                                          +

                                                          Type something to start searching.

                                                          +
                                                          +                                                           + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqextensions.html b/reference/fsharp-control-taskseqextensions.html new file mode 100644 index 00000000..8f825329 --- /dev/null +++ b/reference/fsharp-control-taskseqextensions.html @@ -0,0 +1,244 @@ + + + + + + + + + + + + + + + + + + TaskSeqExtensions (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                          +
                                                          + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                          +
                                                          + + + + + +
                                                          +
                                                          + +
                                                          +
                                                          +
                                                          +

                                                          + TaskSeqExtensions Module +

                                                          +
                                                          +
                                                          + Namespace: + + FSharp.Control + +
                                                          +
                                                          + Assembly: FSharp.Control.TaskSeq.dll +
                                                          +
                                                          +
                                                          +
                                                          +
                                                          +

                                                          + +

                                                          +
                                                          +
                                                          +
                                                          +
                                                          +

                                                          + Nested modules +

                                                          + + + + + + + + + + + + + +
                                                          + Modules + + Description +
                                                          +

                                                          + + + TaskSeq + + +

                                                          +                                                           		+
                                                          +
                                                          +

                                                          + +

                                                          +
                                                          +
                                                          + + + +
                                                          + +
                                                          +
                                                          + +
                                                          +
                                                          +
                                                          +
                                                          +
                                                          +
                                                          + +
                                                          +
                                                          + + + +
                                                          +
                                                            +

                                                            Type something to start searching.

                                                            +
                                                            +                                                             + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqresumptiondynamicinfo-1.html b/reference/fsharp-control-taskseqresumptiondynamicinfo-1.html new file mode 100644 index 00000000..1e0ddfb4 --- /dev/null +++ b/reference/fsharp-control-taskseqresumptiondynamicinfo-1.html @@ -0,0 +1,316 @@ + + + + + + + + + + + + + + + + + + TaskSeqResumptionDynamicInfo<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                            +
                                                            + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                            +
                                                            + + + + + +
                                                            +
                                                            + +
                                                            +
                                                            +
                                                            +

                                                            + TaskSeqResumptionDynamicInfo<'T> Type +

                                                            +
                                                            +
                                                            + Namespace: + + FSharp.Control + +
                                                            +
                                                            + Assembly: FSharp.Control.TaskSeq.dll +
                                                            +
                                                            + Abbreviation For: + ResumptionDynamicInfo<TaskSeqStateMachineData<'T>> +
                                                            +
                                                            + Base Type: + obj +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +

                                                            + +

                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +

                                                            + Instance members +

                                                            + + + + + + + + + + + + + + + + + +
                                                            + Instance member + + Description + +
                                                            +
                                                            + +

                                                            + + + this.ResumptionData + + +

                                                            +                                                             +
                                                            +
                                                            + Full Usage: + this.ResumptionData +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +                                                             		+
                                                            +
                                                            +

                                                            + +

                                                            +
                                                            +
                                                            + + + +
                                                            + +
                                                            +
                                                            + +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            + +

                                                            + + + this.ResumptionFunc + + +

                                                            +                                                             +
                                                            +
                                                            + Full Usage: + this.ResumptionFunc +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +                                                             		+
                                                            +
                                                            +

                                                            + +

                                                            +
                                                            +
                                                            + + + +
                                                            + +
                                                            +
                                                            + +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            +
                                                            + +
                                                            +
                                                            + + + +
                                                            +
                                                              +

                                                              Type something to start searching.

                                                              +
                                                              +                                                               + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqresumptionfunc-1.html b/reference/fsharp-control-taskseqresumptionfunc-1.html new file mode 100644 index 00000000..b4b6b56a --- /dev/null +++ b/reference/fsharp-control-taskseqresumptionfunc-1.html @@ -0,0 +1,208 @@ + + + + + + + + + + + + + + + + + + TaskSeqResumptionFunc<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                              +
                                                              + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                              +
                                                              + + + + + +
                                                              +
                                                              + +
                                                              +
                                                              +
                                                              +

                                                              + TaskSeqResumptionFunc<'T> Type +

                                                              +
                                                              +
                                                              + Namespace: + + FSharp.Control + +
                                                              +
                                                              + Assembly: FSharp.Control.TaskSeq.dll +
                                                              +
                                                              + Abbreviation For: + ResumptionFunc<TaskSeqStateMachineData<'T>> +
                                                              +
                                                              + Base Type: + MulticastDelegate +
                                                              +
                                                              + All Interfaces: + ICloneable + , + ISerializable +
                                                              +
                                                              +
                                                              +
                                                              +
                                                              +

                                                              + +

                                                              +
                                                              +
                                                              +
                                                              +
                                                              + +
                                                              +
                                                              + + + +
                                                              +
                                                                +

                                                                Type something to start searching.

                                                                +
                                                                +                                                                 + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqstatemachine-1.html b/reference/fsharp-control-taskseqstatemachine-1.html new file mode 100644 index 00000000..45889541 --- /dev/null +++ b/reference/fsharp-control-taskseqstatemachine-1.html @@ -0,0 +1,211 @@ + + + + + + + + + + + + + + + + + + TaskSeqStateMachine<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                                +
                                                                + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                                +
                                                                + + + + + +
                                                                +
                                                                + +
                                                                +
                                                                +
                                                                +

                                                                + TaskSeqStateMachine<'T> Type +

                                                                +
                                                                +
                                                                + Namespace: + + FSharp.Control + +
                                                                +
                                                                + Assembly: FSharp.Control.TaskSeq.dll +
                                                                +
                                                                + Abbreviation For: + ResumableStateMachine<TaskSeqStateMachineData<'T>> +
                                                                +
                                                                + Base Type: + ValueType +
                                                                +
                                                                + All Interfaces: + IAsyncStateMachine + , + IResumableStateMachine<TaskSeqStateMachineData<'T>> +
                                                                +
                                                                +
                                                                +
                                                                +
                                                                +

                                                                + + Contains the state data for the taskSeq computation expression builder. + For use in this library only. Required by the Run method. + +

                                                                +
                                                                +
                                                                +
                                                                +
                                                                + +
                                                                +
                                                                + + + +
                                                                +
                                                                  +

                                                                  Type something to start searching.

                                                                  +
                                                                  +                                                                   + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-taskseqstatemachinedata-1.html b/reference/fsharp-control-taskseqstatemachinedata-1.html new file mode 100644 index 00000000..6ccf4cfc --- /dev/null +++ b/reference/fsharp-control-taskseqstatemachinedata-1.html @@ -0,0 +1,848 @@ + + + + + + + + + + + + + + + + + + TaskSeqStateMachineData<'T> (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                                  +
                                                                  + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                                  +
                                                                  + + + + + +
                                                                  +
                                                                  + +
                                                                  +
                                                                  +
                                                                  +

                                                                  + TaskSeqStateMachineData<'T> Type +

                                                                  +
                                                                  +
                                                                  + Namespace: + + FSharp.Control + +
                                                                  +
                                                                  + Assembly: FSharp.Control.TaskSeq.dll +
                                                                  +
                                                                  + Base Type: + obj +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +

                                                                  + + Contains the state data for the taskSeq computation expression builder. + For use in this library only. Required by the Run method. + +

                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +

                                                                  + Record fields +

                                                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                  + Record Field + + Description + +
                                                                  +
                                                                  + +

                                                                  + + + awaiter + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + awaiter +
                                                                  +
                                                                  + + Field type: + ICriticalNotifyCompletion + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +
                                                                  + + Field type: + + ICriticalNotifyCompletion +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + boxedSelf + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + boxedSelf +
                                                                  +
                                                                  + + Field type: + TaskSeqBase<'T> + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  + +
                                                                  +
                                                                  +

                                                                  + A reference to 'self', because otherwise we can't use byref in the resumable code. +

                                                                  +
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +                                                                   +
                                                                  +
                                                                  + + Field type: + + TaskSeqBase<'T> +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + builder + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + builder +
                                                                  +
                                                                  + + Field type: + AsyncIteratorMethodBuilder + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  + +
                                                                  +
                                                                  +

                                                                  + Helper struct providing methods for awaiting 'next' in async iteration scenarios. +

                                                                  +
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +                                                                   +
                                                                  +
                                                                  + + Field type: + + AsyncIteratorMethodBuilder +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + cancellationToken + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + cancellationToken +
                                                                  +
                                                                  + + Field type: + CancellationToken + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +
                                                                  + + Field type: + + CancellationToken +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + completed + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + completed +
                                                                  +
                                                                  + + Field type: + bool + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  + +
                                                                  +
                                                                  +

                                                                  + Whether or not a full iteration through the IAsyncEnumerator has completed +

                                                                  +
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +                                                                   +
                                                                  +
                                                                  + + Field type: + + bool +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + current + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + current +
                                                                  +
                                                                  + + Field type: + ValueOption<'T> + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  + +
                                                                  +
                                                                  +

                                                                  + Used by the AsyncEnumerator interface to return the Current value when + IAsyncEnumerator.Current is called +

                                                                  +
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +                                                                   +
                                                                  +
                                                                  + + Field type: + + ValueOption<'T> +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + disposalStack + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + disposalStack +
                                                                  +
                                                                  + + Field type: + ResizeArray<(unit -> Task)> + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  + +
                                                                  +
                                                                  +

                                                                  + Keeps track of the objects that need to be disposed off on IAsyncDispose. +

                                                                  +
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +                                                                   +
                                                                  +
                                                                  + + Field type: + + ResizeArray<(unit -> Task)> +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + promiseOfValueOrEnd + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + promiseOfValueOrEnd +
                                                                  +
                                                                  + + Field type: + ManualResetValueTaskSourceCore<bool> + +
                                                                  + Modifiers: + mutable +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +
                                                                  + + Field type: + + ManualResetValueTaskSourceCore<bool> +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +

                                                                  + Constructors +

                                                                  + + + + + + + + + + + + + +
                                                                  + Constructor + + Description + +
                                                                  +
                                                                  + +

                                                                  + + + TaskSeqStateMachineData() + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + TaskSeqStateMachineData() +
                                                                  +
                                                                  + + Returns: + TaskSeqStateMachineData<'T> + +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +
                                                                  + + Returns: + + TaskSeqStateMachineData<'T> +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +

                                                                  + Instance members +

                                                                  + + + + + + + + + + + + + + + + + +
                                                                  + Instance member + + Description + +
                                                                  +
                                                                  + +

                                                                  + + + this.PopDispose + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + this.PopDispose +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  +
                                                                  +

                                                                  + +

                                                                  +
                                                                  +
                                                                  + + + +
                                                                  + +
                                                                  +
                                                                  + +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +

                                                                  + + + this.PushDispose + + +

                                                                  +                                                                   +
                                                                  +
                                                                  + Full Usage: + this.PushDispose +
                                                                  +
                                                                  + Parameters: +
                                                                    + + + disposer + + : + unit -> Task + +
                                                                    +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +                                                                   		+
                                                                  +
                                                                  + + + +
                                                                  +
                                                                  +
                                                                  + + disposer + + : + unit -> Task +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  +
                                                                  + +
                                                                  +
                                                                  + + + +
                                                                  +
                                                                    +

                                                                    Type something to start searching.

                                                                    +
                                                                    +                                                                     + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-valuetask.html b/reference/fsharp-control-valuetask.html new file mode 100644 index 00000000..a5e77d2b --- /dev/null +++ b/reference/fsharp-control-valuetask.html @@ -0,0 +1,713 @@ + + + + + + + + + + + + + + + + + + ValueTask (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                                    +
                                                                    + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                                    +
                                                                    + + + + + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +

                                                                    + ValueTask Module +

                                                                    +
                                                                    +
                                                                    + Namespace: + + FSharp.Control + +
                                                                    +
                                                                    + Assembly: FSharp.Control.TaskSeq.dll +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +

                                                                    + +

                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +

                                                                    + Functions and values +

                                                                    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                    + Function or value + + Description + +
                                                                    +
                                                                    + +

                                                                    + + + False + + +

                                                                    +                                                                     +
                                                                    +
                                                                    + Full Usage: + False +
                                                                    +
                                                                    + + Returns: + ValueTask<bool> + +
                                                                    +
                                                                    +
                                                                    +
                                                                    +                                                                     		+
                                                                    + +
                                                                    +
                                                                    +

                                                                    + A successfully completed ValueTask of boolean that has the value false. +

                                                                    +
                                                                    +
                                                                    + + + +
                                                                    + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +                                                                     +
                                                                    +
                                                                    + + Returns: + + ValueTask<bool> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + +

                                                                    + + + True + + +

                                                                    +                                                                     +
                                                                    +
                                                                    + Full Usage: + True +
                                                                    +
                                                                    + + Returns: + ValueTask<bool> + +
                                                                    +
                                                                    +
                                                                    +
                                                                    +                                                                     		+
                                                                    + +
                                                                    +
                                                                    +

                                                                    + A successfully completed ValueTask of boolean that has the value true. +

                                                                    +
                                                                    +
                                                                    + + + +
                                                                    + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +                                                                     +
                                                                    +
                                                                    + + Returns: + + ValueTask<bool> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + +

                                                                    + + + fromResult value + + +

                                                                    +                                                                     +
                                                                    +
                                                                    + Full Usage: + fromResult value +
                                                                    +
                                                                    + Parameters: +
                                                                      + + + value + + : + 'T + +
                                                                      +
                                                                    +
                                                                    + + Returns: + ValueTask<'T> + +
                                                                    + Modifiers: + inline +
                                                                    + Type parameters: + 'T +
                                                                    +
                                                                    +
                                                                    +                                                                     		+
                                                                    + +
                                                                    +
                                                                    +

                                                                    + Creates a ValueTask with the supplied result of the successful operation. +

                                                                    +
                                                                    +
                                                                    + + + +
                                                                    + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +                                                                     +
                                                                    +
                                                                    + + value + + : + 'T +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + + Returns: + + ValueTask<'T> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + +

                                                                    + + + ignore valueTask + + +

                                                                    +                                                                     +
                                                                    +
                                                                    + Full Usage: + ignore valueTask +
                                                                    +
                                                                    + Parameters: +
                                                                      + + + valueTask + + : + ValueTask<'T> + +
                                                                      +
                                                                    +
                                                                    + + Returns: + ValueTask + +
                                                                    + Modifiers: + inline +
                                                                    + Type parameters: + 'T +
                                                                    +
                                                                    +
                                                                    +                                                                     		+
                                                                    + +
                                                                    +
                                                                    +

                                                                    + Convert a ValueTask<'T> into a non-generic ValueTask, ignoring the result +

                                                                    +
                                                                    +
                                                                    + + + +
                                                                    + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +                                                                     +
                                                                    +
                                                                    + + valueTask + + : + ValueTask<'T> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + + Returns: + + ValueTask +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + +

                                                                    + + + ofSource taskSource version + + +

                                                                    +                                                                     +
                                                                    +
                                                                    + Full Usage: + ofSource taskSource version +
                                                                    +
                                                                    + Parameters: +
                                                                      + + + taskSource + + : + IValueTaskSource<bool> + +
                                                                      + + + version + + : + int16 + +
                                                                      +
                                                                    +
                                                                    + + Returns: + ValueTask<bool> + +
                                                                    + Modifiers: + inline +
                                                                    +
                                                                    +
                                                                    +
                                                                    +                                                                     		+
                                                                    + +
                                                                    +
                                                                    +

                                                                    + + Initializes a new instance of ValueTask with an IValueTaskSource + representing its operation. + +

                                                                    +
                                                                    +
                                                                    + + + +
                                                                    + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +                                                                     +
                                                                    +
                                                                    + + taskSource + + : + IValueTaskSource<bool> +
                                                                    +
                                                                    +
                                                                    + + version + + : + int16 +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + + Returns: + + ValueTask<bool> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + +

                                                                    + + + ofTask task + + +

                                                                    +                                                                     +
                                                                    +
                                                                    + Full Usage: + ofTask task +
                                                                    +
                                                                    + Parameters: +
                                                                      + + + task + + : + Task<'T> + +
                                                                      +
                                                                    +
                                                                    + + Returns: + ValueTask<'T> + +
                                                                    + Modifiers: + inline +
                                                                    + Type parameters: + 'T +
                                                                    +
                                                                    +
                                                                    +                                                                     		+
                                                                    + +
                                                                    +
                                                                    +

                                                                    + Creates a ValueTask from a Task<'T> +

                                                                    +
                                                                    +
                                                                    + + + +
                                                                    + +
                                                                    +
                                                                    + +
                                                                    +
                                                                    +
                                                                    +                                                                     +
                                                                    +
                                                                    + + task + + : + Task<'T> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + + Returns: + + ValueTask<'T> +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    +
                                                                    + +
                                                                    +
                                                                    + + + +
                                                                    +
                                                                      +

                                                                      Type something to start searching.

                                                                      +
                                                                      +                                                                       + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control-valuetaskextensions.html b/reference/fsharp-control-valuetaskextensions.html new file mode 100644 index 00000000..ef0a587e --- /dev/null +++ b/reference/fsharp-control-valuetaskextensions.html @@ -0,0 +1,312 @@ + + + + + + + + + + + + + + + + + + ValueTaskExtensions (FSharp.Control.TaskSeq) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                                      +
                                                                      + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                                      +
                                                                      + + + + + +
                                                                      +
                                                                      + +
                                                                      +
                                                                      +
                                                                      +

                                                                      + ValueTaskExtensions Module +

                                                                      +
                                                                      +
                                                                      + Namespace: + + FSharp.Control + +
                                                                      +
                                                                      + Assembly: FSharp.Control.TaskSeq.dll +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +

                                                                      + +

                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +

                                                                      + Type extensions +

                                                                      + + + + + + + + + + + + + +
                                                                      + Type extension + + Description + +
                                                                      +
                                                                      + +

                                                                      + + + ValueTask.CompletedTask() + + +

                                                                      +                                                                       +
                                                                      +
                                                                      + Full Usage: + ValueTask.CompletedTask() +
                                                                      +
                                                                      + Parameters: +
                                                                        + + + () + + : + unit + +
                                                                        +
                                                                      +
                                                                      + + Returns: + ValueTask + +
                                                                      + Modifiers: + inline +
                                                                      +
                                                                      +
                                                                      +
                                                                      +                                                                       		+
                                                                      + +
                                                                      +
                                                                      +

                                                                      + (Extension member) Gets a ValueTask that has already completed successfully. +

                                                                      +
                                                                      +
                                                                      + + + +
                                                                      + +
                                                                      +
                                                                      + +
                                                                      +
                                                                      +
                                                                      +                                                                       +

                                                                      + Extended Type: + ValueTask +

                                                                      +
                                                                      +
                                                                      + + () + + : + unit +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      + + Returns: + + ValueTask +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      +
                                                                      + +
                                                                      +
                                                                      + + + +
                                                                      +
                                                                        +

                                                                        Type something to start searching.

                                                                        +
                                                                        +                                                                         + + + + + + + + \ No newline at end of file diff --git a/reference/fsharp-control.html b/reference/fsharp-control.html new file mode 100644 index 00000000..0b607409 --- /dev/null +++ b/reference/fsharp-control.html @@ -0,0 +1,1069 @@ + + + + + + + + + + + + + + + + + + FSharp.Control | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                                        +
                                                                        + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                                        +
                                                                        + + + + + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +

                                                                        + FSharp.Control Namespace +

                                                                        +
                                                                        + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                                                        + Type/Module + + Description +
                                                                        +

                                                                        + + + Async + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + AsyncExtensions + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + Debug + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + HighPriority + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Contains low priority extension methods for the main builder class for the taskSeq computation expression. + The LowPriority, MediumPriority and HighPriority modules are not meant to be + accessed directly from user code. They solely serve to disambiguate overload resolution inside the taskSeq computation expression. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + Internal + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + LowPriority + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Contains low priority extension methods for the main builder class for the taskSeq computation expression. + The LowPriority, MediumPriority and HighPriority modules are not meant to be + accessed directly from user code. They solely serve to disambiguate overload resolution inside the taskSeq computation expression. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + MediumPriority + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Contains low priority extension methods for the main builder class for the taskSeq computation expression. + The LowPriority, MediumPriority and HighPriority modules are not meant to be + accessed directly from user code. They solely serve to disambiguate overload resolution inside the taskSeq computation expression. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + ResumableTSC<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + TaskSeqCode type alias of ResumableCode delegate type, specially recognized by the F# compiler +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + Task + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskExtensions + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeq + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeq<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Represents a task sequence and is the output of using the taskSeq{...} + computation expression from this library. It is an alias for IAsyncEnumerable<_>. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeq<'Machine, 'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Main implementation of generic IAsyncEnumerable<'T> and related interfaces, + which forms the meat of the logic behind taskSeq computation expresssions. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqBase<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Abstract base class for TaskSeq<'Machine, 'T>. + For use by this library only, should not be used directly in user code. Its operation depends highly on resumable state. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqBuilder (Module) + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqBuilder (Type) + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Main builder class for the taskSeq computation expression. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqDynamic<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Dynamic (FSI-compatible) implementation of IAsyncEnumerable<'T> for taskSeq + computation expressions. Used when the F# compiler cannot generate static resumable code (e.g., in FSI). + For use by this library only. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqDynamicBuilder (Module) + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqDynamicBuilder (Type) + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Builder class for the taskSeqDynamic computation expression. Inherits all members + from TaskSeqBuilder, using the dynamic resumable code path as fallback when the + F# compiler cannot generate static resumable code (e.g., in F# Interactive / FSI). + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqDynamicInfo<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Concrete implementation of TaskSeqResumptionDynamicInfo<'T> for taskSeq computation + expressions, used in the dynamic (FSI) path. Handles state-machine transitions when the F# compiler + cannot generate static resumable code. + For use by this library only. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqExtensions + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqResumptionDynamicInfo<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqResumptionFunc<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqStateMachine<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Contains the state data for the taskSeq computation expression builder. + For use in this library only. Required by the Run method. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + TaskSeqStateMachineData<'T> + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + + Contains the state data for the taskSeq computation expression builder. + For use in this library only. Required by the Run method. + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + ValueTask + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +

                                                                        + + + ValueTaskExtensions + + +

                                                                        +                                                                         		+
                                                                        +
                                                                        +

                                                                        + +

                                                                        +
                                                                        +
                                                                        + + + +
                                                                        + +
                                                                        +
                                                                        + +
                                                                        +
                                                                        +
                                                                        +
                                                                        +
                                                                        + +
                                                                        +
                                                                        + + + +
                                                                        +
                                                                          +

                                                                          Type something to start searching.

                                                                          +
                                                                          +                                                                           + + + + + + + + \ No newline at end of file diff --git a/reference/index.html b/reference/index.html new file mode 100644 index 00000000..60278f21 --- /dev/null +++ b/reference/index.html @@ -0,0 +1,199 @@ + + + + + + + + + + + + + + + + + + FSharp.Control.TaskSeq (API Reference) | FSharp.Control.TaskSeq + + + + + + + + + + + + + +
                                                                          +
                                                                          + + + Header menu logo + FSharp.Control.TaskSeq + +
                                                                          +
                                                                          + + + + + +
                                                                          +
                                                                          + +
                                                                          +
                                                                          +
                                                                          +

                                                                          + API Reference +

                                                                          +

                                                                          + Available Namespaces: +

                                                                          + + + + + + + + + + + + + +
                                                                          + Namespace + + Description +
                                                                          + + FSharp.Control + +
                                                                          +
                                                                          + +
                                                                          +
                                                                          + + + +
                                                                          +
                                                                            +

                                                                            Type something to start searching.

                                                                            +
                                                                            +                                                                             + + + + + + + + \ No newline at end of file