From 15fff461626fbc0046ca7ab0e4a800a6fbff35e3 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 08:34:44 +0200 Subject: [PATCH 01/59] docs --- docs/index.md | 1 + docs/runtime-async.md | 235 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 236 insertions(+) create mode 100644 docs/runtime-async.md diff --git a/docs/index.md b/docs/index.md index 7eca2572ae2..dd84774305d 100644 --- a/docs/index.md +++ b/docs/index.md @@ -15,6 +15,7 @@ Welcome to [the F# compiler and tools repository](https://github.com/dotnet/fsha * [Memory usage](memory-usage.md) * [Optimizations](optimizations.md) * [Equality optimizations](optimizations-equality.md) +* [Runtime async](runtime-async.md) * [Project builds](project-builds.md) * [Tooling features](tooling-features.md) diff --git a/docs/runtime-async.md b/docs/runtime-async.md new file mode 100644 index 00000000000..90d22b803de --- /dev/null +++ b/docs/runtime-async.md @@ -0,0 +1,235 @@ +--- +title: Runtime async +category: Compiler Internals +categoryindex: 200 +index: 375 +--- + +# Runtime async + +This document describes the current proof-of-concept implementation of F# +support for the .NET runtime-async feature. It describes the code as +implemented, not an aspirational design. The .NET design is still evolving: + +* [Runtime-async specification](https://github.com/dotnet/runtime/blob/main/docs/design/specs/runtime-async.md) +* [Runtime-async code-generation contract](https://github.com/dotnet/runtime/blob/main/docs/design/coreclr/botr/runtime-async-codegen.md) +* [Roslyn runtime async design](https://github.com/dotnet/roslyn/blob/main/docs/compilers/CSharp/Runtime%20Async%20Design.md) — + how C# lowers `await` (including the exception-handling hoisting described below) + +The implementation targets functions, lambdas, and members returning +`System.Threading.Tasks.Task<'T>`. A computation-expression builder exists in +the component tests and works for a subset of the surface, but is not part of +FSharp.Core. + +## Runtime contract + +Runtime-async methods are CIL methods marked with +`MethodImplOptions.Async` (`0x2000`). The runtime, rather than a compiler +generated state machine and method builder, owns suspension and resumption. + +Only the generic return shape `System.Threading.Tasks.Task<'T>` is supported. +Non-generic `Task` and `ValueTask`/`ValueTask<'T>` returns are not. + +Suspension is explicit, via `System.Runtime.CompilerServices.AsyncHelpers`: + +* `Await` for `Task`, `ValueTask`, and configured awaitables +* `AwaitAwaiter` for awaiters (used by the test builder's SRTP `Bind`) + +The compiler emits the adjacent IL sequence the runtime specification expects: + +```il +call Task SomeAsyncMethod(...) +call int32 AsyncHelpers::Await(Task) +``` + +Known runtime restrictions (currently **not** diagnosed by the F# compiler): + +* `tail.` and `localloc` are forbidden. +* suspension cannot occur inside exception-handling regions. Awaiting in a + `try` body now works on the current runtime; awaiting inside a `finally` + handler compiles and then terminates the process at execution + (`0xC0000409`). See `RuntimeTasksAsyncDisposalException.fs`, which is + compile-only for this reason. + + C# avoids this by rewriting EH-region awaits at lowering time (see the + Roslyn design doc): `try B finally { await x }` becomes + `try B catch-all { pend e }`, then `await x` outside the region, then + rethrow the pending exception. The test `RuntimeTaskBuilder.Using` + prototypes this pattern in F# source: it captures the body result/exception + in a `Choice`, runs `DisposeAsync` (possibly suspending) *outside* the + `try`, then restores a pending exception. This makes `use` on an + `IAsyncDisposable` work under runtime async (`testUsingAsyncDisposableSync` + executes). +* Byref, byref-like, and pinned locals cannot be preserved across suspension. + +## F# surface + +The source-level marker is the compiler intrinsic +`Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers.__runtimeAsync`, +declared in `resumable.fsi` alongside the other compiler intrinsics: + +```fsharp +val __runtimeAsync<'T> : 'T -> System.Threading.Tasks.Task<'T> +``` + +Its FSharp.Core implementation throws; the compiler consumes every +occurrence before code generation, so the body is never executed. It is +marked `NoInlining` so a missed consumption does not silently fold into a +caller. + +The feature is gated on `langversion:preview` +(`LanguageFeature.RuntimeAsync`) and on the target reference assemblies +exposing `MethodImplOptions.Async` (see "Runtime capability check" below). +Without the language version the checker reports error 3350; without runtime +support it reports 3351. + +Typical forms: + +```fsharp +let add (x: int) (y: int) : Task = + __runtimeAsync ( + let first = AsyncHelpers.Await (getTask x) + first + y) + +type C() = + member _.Add(x: int, y: int) : Task = + __runtimeAsync ( + AsyncHelpers.Await (getTask x) + y) + +// Let-bound value (not a function): also supported. +let answer : Task = __runtimeAsync 42 +``` + +There is no implicit awaiting: the argument of `__runtimeAsync` is checked +as the logical `'T` result, and flattening requires an explicit +`AsyncHelpers.Await`. + +## Type checking + +`__runtimeAsync` is an ordinary generic value in the typed tree; no new +expression node or `Val` flag is added. Type checking special-cases its +application in two places in `CheckExpressions.fs`: + +* `Propagate` skips function-type propagation for the intrinsic so the + argument is not checked against a function domain. +* `TcApplicationThen` (`tryTcRuntimeAsyncApplication`) recognises the + intrinsic (possibly type-applied), gates the language feature and runtime + capability, extracts the result type `'T` from the intrinsic's own + instantiated signature `'T -> Task<'T>`, and checks the argument against + `'T` with `TcExprFlex2`. The result type of the application is `Task<'T>`, + which unifies with the declared return type of the enclosing binding in + the usual way. A non-`Task<'T>` declared return type therefore fails with + the ordinary FS0001 type-mismatch error. + +User code that defines its own `__runtimeAsync` is unaffected: the intrinsic +is only recognised when the `ValRef` resolves (via `valRefEq`) to the +FSharp.Core declaration. + +## Optimization + +`Optimizer.fs` preserves the marker application as-is, optimizing only its +argument. The marked expression is forced to `HasEffect = true` and +`UnknownValue`, so the optimizer never inlines, duplicates, or discards it. +The marker therefore survives optimization as an ordinary `Expr.App` node; +nothing else in the typed tree records that a method is runtime-async. + +## Code generation + +`IlxGen.fs` recognises the marker in three placements +(`TryUnwrapRuntimeAsyncExpr`, which strips `DebugPoint` wrappers): + +1. **Method body** (`GenMethodForBinding`): the marker is unwrapped from the + top of the method lambda body; the generated `ILMethodDef` gets + `.WithAsync(true)`, which sets impl attribute bit `0x2000` + (`MethodImplOptions.Async`, written as a literal because older reference + assemblies do not define the enum member). `NoInlining` is forced on the + method. +2. **Closure body** (`GenClosureAsLocalTypeFunction` and + `GenClosureAsFirstClassFunction`): the same unwrapping marks the closure + `Invoke` method's IL body (`ILMethodBody.IsRuntimeAsync`). + `EraseClosures.convIlxClosureDef` copies that flag onto the emitted + method, again with `NoInlining`. +3. **Any other expression position** (`GenRuntimeAsyncAsStartedTask`), e.g. + a `let`-bound value initializer: the marker application is wrapped in a + fresh `fun () -> ...` lambda that is immediately applied to `unit` and + regenerated. The lambda flows through the closure path (2), producing a + generated runtime-async helper method whose call starts the task. This + relies on `GenApp` never beta-reducing a lambda application (it always + emits a closure plus an indirect call); see the comment at + `GenRuntimeAsyncAsStartedTask`. + +A marker that ends up wrapped in anything other than `DebugPoint` at the top +of a method or closure body is not detected there, but still reaches the +catch-all case (3), so compilation stays correct — the cost is an extra +nested runtime-async helper method rather than marking the enclosing method +directly. + +## Runtime capability check + +`InfoReader` gates `LanguageFeature.RuntimeAsync` on the target reference +assemblies: it looks up the `Async` field on +`System.Runtime.CompilerServices.MethodImplOptions`. This is a metadata-only +probe of the *reference* assemblies; it does not prove the *executing* host +JIT supports runtime-async. Compiling against new reference assemblies and +running on an older runtime is not a supported configuration. + +## Test infrastructure + +Tests live in `tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync*`: + +* The component test project sets `runtime-async=on` + (the .NET runtime opt-in), as does the project template in + `FSharp.Test.Utilities` used by `compileExeAndRun`. +* Type-check tests assert the preview gate (3350) and the unsupported-runtime + gate (3351, on non-.NET-Core targets). +* IL tests verify direct `AsyncHelpers.Await` calls appear without + intervening delegates. +* Execution tests (`RuntimeAsyncBasic.fs`, `RuntimeTasks.fs` with the shared + `RuntimeTaskBuilder.fs`) run with `compileExeAndRun`, so they compile with + the compiler under test and execute on the host runtime. +* `RuntimeTasksAsyncDisposalException.fs` documents the known + EH-region-suspension crash: it is compiled but not executed. + +### Test builder + +`RuntimeTaskBuilder.fs` is a quasi-synchronous builder aiming for feature +parity with FSharp.Core's `task` builder: `Delay` is the identity on +`unit -> 'T`, so all combinators are plain inline functions over delayed +code; only `Run` introduces `__runtimeAsync` and returns `Task<'T>`. +`Bind` lowers directly to `AsyncHelpers.Await` with SRTP fallbacks +(`AwaitAwaiter`) for arbitrary task-likes, as do `ReturnFrom` and +`MergeSources`. `MergeSources` awaits its sources sequentially, matching the +task builder — concurrency comes from the sources being hot tasks. +`Async<'T>` binds via `Async.StartImmediateAsTask`, matching `task {}`'s +current-thread semantics. + +`RuntimeTasks.fs` ports the TaskBuilder test suite +(`tests/FSharp.Core.UnitTests/.../Tasks.fs`) test-for-test with +`task {` replaced by `runtimeTask {`. Tests that hit the known runtime-async +restrictions or divergences are kept in the file with `knownFailing_` / +`knownDivergent_` prefixes, compiled but not run: + +* suspension in `try/finally`, or in `try/with` in non-tail position + (forbidden by the runtime contract; crashes with `0xC0000409` or loses the + finally); +* `use`/`use!` whose disposal awaits an `IAsyncDisposable` (the `Using` + compensation suspends in a `finally`); +* tests requiring synchronous (hot) start of the body before the first + suspension — on the current runtime build the body is not observably run + before the returned `Task` is awaited; +* `SynchronizationContext` capture: with a sync context installed, the task + completes without the body observably running. + +Two `task {}` inference behaviors are not matched by the overload set: +element-type propagation through `Bind` without an annotation, and unannotated +`return! failwith ...` (both need explicit annotations in the port). + +## Not yet implemented + +* Diagnostics for suspension in exception-handling regions, byref/byref-like + or pinned locals across suspension, `tail.`, and `localloc`. +* Non-generic `Task` and `ValueTask`/`ValueTask<'T>` return shapes. +* Any FSharp.Core builder (the test builder is test-only). +* Compile-time enforcement that the marker was actually consumed before + code generation (a missed marker throws only when its FSharp.Core stub is + reached at run time, or produces invalid IL as described above). From 0cc21082d2cf901048ea868ad8d67059e194a60b Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 08:40:52 +0200 Subject: [PATCH 02/59] feature --- src/Compiler/AbstractIL/il.fs | 7 ++ src/Compiler/AbstractIL/il.fsi | 3 + src/Compiler/AbstractIL/ilread.fs | 2 + .../Checking/Expressions/CheckExpressions.fs | 69 +++++++++++++++++-- src/Compiler/Checking/InfoReader.fs | 10 +++ src/Compiler/CodeGen/EraseClosures.fs | 1 + src/Compiler/CodeGen/IlxGen.fs | 53 +++++++++++++- src/Compiler/FSComp.txt | 1 + src/Compiler/Facilities/LanguageFeatures.fs | 3 + src/Compiler/Facilities/LanguageFeatures.fsi | 1 + src/Compiler/Optimize/Optimizer.fs | 11 ++- src/Compiler/TypedTree/TcGlobals.fs | 5 ++ src/Compiler/TypedTree/TcGlobals.fsi | 4 ++ src/FSharp.Core/resumable.fs | 7 ++ src/FSharp.Core/resumable.fsi | 5 ++ 15 files changed, 173 insertions(+), 9 deletions(-) diff --git a/src/Compiler/AbstractIL/il.fs b/src/Compiler/AbstractIL/il.fs index e2002731aa8..cf143ad80a1 100644 --- a/src/Compiler/AbstractIL/il.fs +++ b/src/Compiler/AbstractIL/il.fs @@ -1585,6 +1585,7 @@ type ILMethodBody = MaxStack: int32 NoInlining: bool AggressiveInlining: bool + IsRuntimeAsync: bool Locals: ILLocals Code: ILCode DebugRange: ILDebugPoint option @@ -2225,6 +2226,11 @@ type ILMethodDef member x.WithRuntime(condition) = x.With(implAttributes = (x.ImplAttributes |> conditionalAdd condition MethodImplAttributes.Runtime)) + member x.WithAsync(condition) = + // MethodImplOptions.Async is not present in all target reference assemblies. + let asyncFlag = enum 0x2000 + x.With(implAttributes = (x.ImplAttributes |> conditionalAdd condition asyncFlag)) + [] member x.DebugText = x.ToString() @@ -3923,6 +3929,7 @@ let mkILMethodBody (initlocals, locals, maxstack, code, tag, imports) : ILMethod MaxStack = maxstack NoInlining = false AggressiveInlining = false + IsRuntimeAsync = false Locals = locals Code = code DebugRange = tag diff --git a/src/Compiler/AbstractIL/il.fsi b/src/Compiler/AbstractIL/il.fsi index 050921650c3..ce32a48563e 100644 --- a/src/Compiler/AbstractIL/il.fsi +++ b/src/Compiler/AbstractIL/il.fsi @@ -808,6 +808,7 @@ type internal ILMethodBody = MaxStack: int32 NoInlining: bool AggressiveInlining: bool + IsRuntimeAsync: bool Locals: ILLocals Code: ILCode DebugRange: ILDebugPoint option @@ -1241,6 +1242,8 @@ type ILMethodDef = member internal WithRuntime: bool -> ILMethodDef + member internal WithAsync: bool -> ILMethodDef + /// Tables of methods. Logically equivalent to a list of methods but /// the table is kept in a form optimized for looking up methods by /// name and arity. diff --git a/src/Compiler/AbstractIL/ilread.fs b/src/Compiler/AbstractIL/ilread.fs index 09fc311367a..7be919293e6 100644 --- a/src/Compiler/AbstractIL/ilread.fs +++ b/src/Compiler/AbstractIL/ilread.fs @@ -3819,6 +3819,7 @@ and seekReadMethodRVA (pectxt: PEReader) (ctxt: ILMetadataReader) (nm, noinline, MaxStack = 8 NoInlining = noinline AggressiveInlining = aggressiveinline + IsRuntimeAsync = false Locals = List.empty Code = code DebugRange = None @@ -3967,6 +3968,7 @@ and seekReadMethodRVA (pectxt: PEReader) (ctxt: ILMetadataReader) (nm, noinline, MaxStack = maxstack NoInlining = noinline AggressiveInlining = aggressiveinline + IsRuntimeAsync = false Locals = locals Code = code DebugRange = None diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index e4b3e755841..687ee49daf6 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -8687,8 +8687,18 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl | DelayedApp (atomicFlag, isSugar, synLeftExprOpt, synArg, mExprAndArg) :: delayedList' -> let denv = env.DisplayEnv - match UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with - | ValueSome (_, resultTy) -> + + let isRuntimeAsync = + match expr.Expr with + | Expr.Val(vref, _, _) + | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [], _) + when valRefEq g vref g.cgh__runtimeAsync_vref -> true + | _ -> false + + match isRuntimeAsync, UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with + | true, _ -> + () + | false, ValueSome (_, resultTy) -> // We add tag parameter to the return type for "&x" and 'NativePtr.toByRef' // See RFC FS-1053.md @@ -8701,7 +8711,7 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl propagate isAddrOf delayedList' mExprAndArg resultTy - | _ -> + | false, _ -> let mArg = synArg.Range match synArg with // async { ... } @@ -8997,10 +9007,57 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg else None + let tryTcRuntimeAsyncApplication () = + let intrinsic = + match leftExpr with + | ApplicableExpr(expr=Expr.Val (vref, flags, m)) + when valRefEq g vref g.cgh__runtimeAsync_vref -> + Some(vref, flags, m) + | ApplicableExpr(expr=Expr.App (Expr.Val (vref, flags, m), _, [ _ ], [], _)) + when valRefEq g vref g.cgh__runtimeAsync_vref -> + Some(vref, flags, m) + | _ -> + None + + match intrinsic with + | None -> + None + | Some(vref, flags, m) -> + checkLanguageFeatureAndRecover g.langVersion LanguageFeature.RuntimeAsync m + + let _, carrierTy = stripFunTy g exprTy + + // The intrinsic's signature is 'T -> Task<'T>, so the carrier is always Task<'T>. + let bodyResultTy = + match stripTyEqns g carrierTy with + | AppTy g (_, [ resultTy ]) -> resultTy + | _ -> NewInferenceType g + + checkLanguageFeatureRuntimeAndRecover cenv.infoReader LanguageFeature.RuntimeAsync m + + let arg, tpenv = TcExprFlex2 cenv bodyResultTy env false tpenv synArg + let marker = + Expr.App(Expr.Val(vref, flags, m), vref.Type, [ bodyResultTy ], [ arg ], mExprAndArg) + + Some( + TcDelayed + cenv + overallTy + env + tpenv + mExprAndArg + (MakeApplicableExprNoFlex cenv marker) + carrierTy + atomicFlag + delayed + ) + // If the type of 'synArg' unifies as a function type, then this is a function application, otherwise // it is an error or a computation expression or indexer or delegate invoke - match UnifyFunctionTypeUndoIfFailed cenv denv mLeftExpr exprTy with - | ValueSome (domainTy, resultTy) -> + match tryTcRuntimeAsyncApplication (), UnifyFunctionTypeUndoIfFailed cenv denv mLeftExpr exprTy with + | Some result, _ -> + result + | None, ValueSome (domainTy, resultTy) -> // atomicLeftExpr[idx] unifying as application gives a warning if not isSugar then @@ -9066,7 +9123,7 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let exprAndArg, resultTy = buildApp cenv leftExpr resultTy arg mExprAndArg TcDelayed cenv overallTy env tpenv mExprAndArg exprAndArg resultTy atomicFlag delayed - | ValueNone -> + | None, ValueNone -> // Type-directed invocables match synArg with diff --git a/src/Compiler/Checking/InfoReader.fs b/src/Compiler/Checking/InfoReader.fs index 2a4e75135f1..57a4847f213 100644 --- a/src/Compiler/Checking/InfoReader.fs +++ b/src/Compiler/Checking/InfoReader.fs @@ -860,6 +860,15 @@ type InfoReader(g: TcGlobals, amap: ImportMap) as this = let isRuntimeFeatureVirtualStaticsInInterfacesSupported = lazy isRuntimeFeatureSupported "VirtualStaticsInInterfaces" + let isRuntimeAsyncSupported = + lazy ( + match g.System_Runtime_CompilerServices_MethodImplOptions_ty with + | Some methodImplOptionsTy -> + GetIntrinsicILFieldInfosUncached ((None, AccessorDomain.AccessibleFromEverywhere), range0, methodImplOptionsTy) + |> List.exists (fun (ilFieldInfo: ILFieldInfo) -> ilFieldInfo.FieldName = "Async") + | _ -> + false) + member _.g = g member _.amap = amap @@ -924,6 +933,7 @@ type InfoReader(g: TcGlobals, amap: ImportMap) as this = // Both default and static interface method consumption features are tied to the runtime support of DIMs. | LanguageFeature.DefaultInterfaceMemberConsumption -> isRuntimeFeatureDefaultImplementationsOfInterfacesSupported.Value | LanguageFeature.InterfacesWithAbstractStaticMembers -> isRuntimeFeatureVirtualStaticsInInterfacesSupported.Value + | LanguageFeature.RuntimeAsync -> isRuntimeAsyncSupported.Value | _ -> true /// Get the declared constructors of any F# type diff --git a/src/Compiler/CodeGen/EraseClosures.fs b/src/Compiler/CodeGen/EraseClosures.fs index 9aad82b0521..77fee73c948 100644 --- a/src/Compiler/CodeGen/EraseClosures.fs +++ b/src/Compiler/CodeGen/EraseClosures.fs @@ -722,6 +722,7 @@ let rec convIlxClosureDef cenv encl (td: ILTypeDef) clo = mkILReturn fixedNowReturnTy, MethodBody.IL(notlazy convil) ) + |> fun mdef -> mdef.WithAsync(clo.cloCode.Value.IsRuntimeAsync).WithNoInlining(clo.cloCode.Value.IsRuntimeAsync) let ctorMethodDef = mkILStorageCtor ( diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index c4fbea22a66..44f133736e1 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3127,6 +3127,19 @@ let ComputeDebugPointForBinding g bind = | _, (Expr.Lambda _ | Expr.TyLambda _) -> false, None | DebugPointAtBinding.Yes m, _ -> false, Some m +let IsRuntimeAsyncVref (g: TcGlobals) (vref: ValRef) = + valRefEq g vref g.cgh__runtimeAsync_vref + +let rec TryUnwrapRuntimeAsyncExpr (g: TcGlobals) expr = + + match expr with + | Expr.DebugPoint(_, innerExpr) -> + match TryUnwrapRuntimeAsyncExpr g innerExpr with + | true, body -> true, body + | false, _ -> false, expr + | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncVref g vref -> true, body + | _ -> false, expr + //------------------------------------------------------------------------- // Generate expressions //------------------------------------------------------------------------- @@ -3271,6 +3284,9 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = // application of local type functions with type parameters = measure types and body = local value - inline the body GenExpr cenv cgbuf eenv v sequel + | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ _ ], _) when IsRuntimeAsyncVref g vref -> + GenRuntimeAsyncAsStartedTask cenv cgbuf eenv expr sequel + | Expr.App(f, fty, tyargs, curriedArgs, m) -> GenApp cenv cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel | Expr.Val(v, _, m) -> GenGetVal cenv cgbuf eenv (v, m) sequel @@ -3372,6 +3388,21 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = | Expr.TyChoose(_, _, m) -> error (InternalError("Unexpected Expr.TyChoose", m)) +// A __runtimeAsync marker that is not at the top of a method or closure body is lowered +// as a "started task": the marked expression becomes the body of a fresh closure whose +// Invoke method is the runtime-async method, and the closure is invoked immediately. +// This relies on GenApp never beta-reducing a lambda application - it always emits a +// closure value followed by an indirect call (the "worst case" path), which routes the +// lambda through the closure generation that consumes the marker. If that invariant ever +// changes, the marker expression would reach GenExprAux again and recurse without bound. +and GenRuntimeAsyncAsStartedTask cenv cgbuf eenv expr sequel = + let m = expr.Range + let unitVal, _ = mkLocal m "unit" cenv.g.unit_ty + let lambdaExpr = mkLambda m unitVal (expr, tyOfExpr cenv.g expr) + let lambdaTy = tyOfExpr cenv.g lambdaExpr + let application = mkApps cenv.g ((lambdaExpr, lambdaTy), [], [ mkUnit cenv.g m ], m) + GenExpr cenv cgbuf eenv application sequel + and GenExprs cenv cgbuf eenv es = List.iter (fun e -> GenExpr cenv cgbuf eenv e Continue) es @@ -7102,9 +7133,17 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr strip cloinfo.ilCloLambdas + let isRuntimeAsync, body = TryUnwrapRuntimeAsyncExpr g body + let ilCloBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) + let ilCloBody = + if isRuntimeAsync then + { ilCloBody with IsRuntimeAsync = true } + else + ilCloBody + let ilCtorBody = mkILMethodBody (true, [], 8, nonBranchingInstrsToCode (mkCallBaseConstructor (g.ilg.typ_Object, [])), None, eenv.imports) @@ -7119,6 +7158,7 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr mkILReturn ilCloFormalReturnTy, MethodBody.IL(InterruptibleLazy.FromValue ilCloBody) ) + |> fun mdef -> mdef.WithAsync(isRuntimeAsync).WithNoInlining(isRuntimeAsync) ] let cloTypeDefs = @@ -7149,9 +7189,17 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e let ilCloTypeRef = cloinfo.cloSpec.TypeRef + let isRuntimeAsync, body = TryUnwrapRuntimeAsyncExpr g body + let ilCloBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) + let ilCloBody = + if isRuntimeAsync then + { ilCloBody with IsRuntimeAsync = true } + else + ilCloBody + let cloTypeDefs = GenClosureTypeDefs cenv @@ -9797,6 +9845,8 @@ and GenMethodForBinding | h :: t -> [ h ], t, true | _ -> [], methLambdaVars, false + let isRuntimeAsync, methLambdaBody = TryUnwrapRuntimeAsyncExpr g methLambdaBody + let nonUnitNonSelfMethodVars, body = BindUnitVars cenv.g (nonSelfMethodVars, paramInfos, methLambdaBody) @@ -10229,8 +10279,9 @@ and GenMethodForBinding .WithPInvoke(hasDllImport) .WithPreserveSig(hasPreserveSigImplFlag || hasPreserveSigNamedArg) .WithSynchronized(hasSynchronizedImplFlag) - .WithNoInlining(hasNoInliningFlag) .WithAggressiveInlining(hasAggressiveInliningImplFlag) + .WithAsync(isRuntimeAsync) + .WithNoInlining(hasNoInliningFlag || isRuntimeAsync) .With(isEntryPoint = isExplicitEntryPoint, securityDecls = secDecls) let mdef = diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt index 26699fa4d9b..83bc970001a 100644 --- a/src/Compiler/FSComp.txt +++ b/src/Compiler/FSComp.txt @@ -1576,6 +1576,7 @@ featureFixedIndexSlice3d4d,"fixed-index slice 3d/4d" featureAndBang,"applicative computation expressions" featureNullnessChecking,"nullness checking" featureResumableStateMachines,"resumable state machines" +featureRuntimeAsync,"runtime async" featureNullableOptionalInterop,"nullable optional interop" featureDefaultInterfaceMemberConsumption,"default interface member consumption" featureStringInterpolation,"string interpolation" diff --git a/src/Compiler/Facilities/LanguageFeatures.fs b/src/Compiler/Facilities/LanguageFeatures.fs index c7b75365c60..699f127e95e 100644 --- a/src/Compiler/Facilities/LanguageFeatures.fs +++ b/src/Compiler/Facilities/LanguageFeatures.fs @@ -29,6 +29,7 @@ type LanguageFeature = | FixedIndexSlice3d4d | AndBang | ResumableStateMachines + | RuntimeAsync | NullableOptionalInterop | DefaultInterfaceMemberConsumption | WitnessPassing @@ -257,6 +258,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) LanguageFeature.ExceptionFieldSerializationSupport, languageVersion110 LanguageFeature.NotNullIfNotNull, languageVersion110 LanguageFeature.ImprovedImpliedArgumentNamesPartTwo, languageVersion110 + LanguageFeature.RuntimeAsync, previewVersion // Difference between languageVersion110 and preview - 11.0 gets turned on automatically by picking a preview .NET 11 SDK // previewVersion is only when "preview" is specified explicitly in project files and users also need a preview SDK @@ -377,6 +379,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) | LanguageFeature.AndBang -> FSComp.SR.featureAndBang () | LanguageFeature.NullnessChecking -> FSComp.SR.featureNullnessChecking () | LanguageFeature.ResumableStateMachines -> FSComp.SR.featureResumableStateMachines () + | LanguageFeature.RuntimeAsync -> FSComp.SR.featureRuntimeAsync () | LanguageFeature.NullableOptionalInterop -> FSComp.SR.featureNullableOptionalInterop () | LanguageFeature.DefaultInterfaceMemberConsumption -> FSComp.SR.featureDefaultInterfaceMemberConsumption () | LanguageFeature.WitnessPassing -> FSComp.SR.featureWitnessPassing () diff --git a/src/Compiler/Facilities/LanguageFeatures.fsi b/src/Compiler/Facilities/LanguageFeatures.fsi index 8c7ebd7e3c3..adec3cf897c 100644 --- a/src/Compiler/Facilities/LanguageFeatures.fsi +++ b/src/Compiler/Facilities/LanguageFeatures.fsi @@ -19,6 +19,7 @@ type LanguageFeature = | FixedIndexSlice3d4d | AndBang | ResumableStateMachines + | RuntimeAsync | NullableOptionalInterop | DefaultInterfaceMemberConsumption | WitnessPassing diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index a6b21b577eb..a74adc7400c 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2496,6 +2496,13 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App (f, fty, tyargs, argsl, m) -> match expr with + | Expr.App(Expr.Val(vref, flags, _), fty, [ _ ], [ body ], _) + when valRefEq g vref g.cgh__runtimeAsync_vref -> + let bodyR, bodyInfo = OptimizeExpr cenv env body + Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), + { bodyInfo with + HasEffect = true + Info = UnknownValue } | DelegateInvokeExpr g (delInvokeRef, delInvokeTy, tyargs, delExpr, delInvokeArg, m) -> OptimizeFSharpDelegateInvoke cenv env (delInvokeRef, delExpr, delInvokeTy, tyargs, delInvokeArg, m) | _ -> @@ -4383,8 +4390,8 @@ and OptimizeBinding cenv isRec env (TBind(vref, expr, spBind)) = let env = if vref.IsCompilerGenerated && Option.isSome env.latestBoundId then env else {env with latestBoundId=Some vref.Id} let cenv = if vref.InlineInfo.ShouldInline then { cenv with optimizing=false} else cenv let arityInfo = InferValReprInfoOfBinding g AllowTypeDirectedDetupling.No vref expr - let exprOptimized, einfo = OptimizeLambdas (Some vref) cenv env arityInfo expr vref.Type - let size = localVarSize + let exprOptimized, einfo = OptimizeLambdas (Some vref) cenv env arityInfo expr vref.Type + let size = localVarSize exprOptimized, {einfo with FunctionSize=einfo.FunctionSize+size; TotalSize = einfo.TotalSize+size} // Trim out optimization information for large lambdas we'll never inline diff --git a/src/Compiler/TypedTree/TcGlobals.fs b/src/Compiler/TypedTree/TcGlobals.fs index 3f983633574..9140b620a25 100644 --- a/src/Compiler/TypedTree/TcGlobals.fs +++ b/src/Compiler/TypedTree/TcGlobals.fs @@ -393,6 +393,7 @@ type TcGlobals( let v_tcref_IObservable = findSysTyconRef sys "IObservable`1" let v_tcref_IObserver = findSysTyconRef sys "IObserver`1" let v_fslib_IDelegateEvent_tcr = mk_MFControl_tcref fslibCcu "IDelegateEvent`1" + let v_task_tcr = findSysTyconRef ["System"; "Threading"; "Tasks"] "Task`1" let v_option_tcr_nice = mk_MFCore_tcref fslibCcu "option`1" let v_valueoption_tcr_nice = mk_MFCore_tcref fslibCcu "voption`1" @@ -884,6 +885,7 @@ type TcGlobals( let v_cgh__resumeAt_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__resumeAt" , None , None , [vara], ([[v_int_ty]; [varaTy]], varaTy)) let v_cgh__stateMachine_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__stateMachine" , None , None , [vara; varb], ([[varaTy]], varbTy)) // inaccurate type but it doesn't matter for linking let v_cgh__resumableEntry_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__resumableEntry" , None , None , [vara], ([[v_int_ty --> varaTy]; [v_unit_ty --> varaTy]], varaTy)) + let v_cgh__runtimeAsync_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsync" , None , None , [vara], ([[varaTy]], TType_app(v_task_tcr, [varaTy], v_knownWithoutNull))) // handled specially by the checker let v_seq_to_array_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "toArray" , None , Some "ToArray", [varb], ([[mkSeqTy varbTy]], mkArrayType 1 varbTy)) let v_seq_to_list_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "toList" , None , Some "ToList" , [varb], ([[mkSeqTy varbTy]], mkListTy varbTy)) let v_seq_map_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "map" , None , Some "Map" , [vara;varb], ([[varaTy --> varbTy]; [mkSeqTy varaTy]], mkSeqTy varbTy)) @@ -1463,6 +1465,8 @@ type TcGlobals( // Review: Does this need to be an option type? member val System_Runtime_CompilerServices_RuntimeFeature_ty = tryFindSysTyconRef sysCompilerServices "RuntimeFeature" |> Option.map mkNonGenericTy + member val System_Runtime_CompilerServices_MethodImplOptions_ty = + tryFindSysTyconRef sysCompilerServices "MethodImplOptions" |> Option.map mkNonGenericTy member val iltyp_StreamingContext = tryFindSysILTypeRef tname_StreamingContext |> Option.map mkILNonGenericValueTy member val iltyp_SerializationInfo = tryFindSysILTypeRef tname_SerializationInfo |> Option.map mkILNonGenericBoxedTy @@ -1771,6 +1775,7 @@ type TcGlobals( member val cgh__stateMachine_vref = ValRefForIntrinsic v_cgh__stateMachine_info + member val cgh__runtimeAsync_vref = ValRefForIntrinsic v_cgh__runtimeAsync_info member val cgh__useResumableCode_vref = ValRefForIntrinsic v_cgh__useResumableCode_info member val cgh__debugPoint_vref = ValRefForIntrinsic v_cgh__debugPoint_info member val cgh__resumeAt_vref = ValRefForIntrinsic v_cgh__resumeAt_info diff --git a/src/Compiler/TypedTree/TcGlobals.fsi b/src/Compiler/TypedTree/TcGlobals.fsi index 709abfc5b18..096bbf585b2 100644 --- a/src/Compiler/TypedTree/TcGlobals.fsi +++ b/src/Compiler/TypedTree/TcGlobals.fsi @@ -270,6 +270,8 @@ type internal TcGlobals = member System_Runtime_CompilerServices_RuntimeFeature_ty: TypedTree.TType option + member System_Runtime_CompilerServices_MethodImplOptions_ty: TypedTree.TType option + member addrof2_vref: TypedTree.ValRef member addrof_vref: TypedTree.ValRef @@ -434,6 +436,8 @@ type internal TcGlobals = member cgh__stateMachine_vref: TypedTree.ValRef + member cgh__runtimeAsync_vref: TypedTree.ValRef + member cgh__useResumableCode_vref: TypedTree.ValRef member char_operator_info: IntrinsicValRef diff --git a/src/FSharp.Core/resumable.fs b/src/FSharp.Core/resumable.fs index 1ace0d12241..2fc9a0d21ab 100644 --- a/src/FSharp.Core/resumable.fs +++ b/src/FSharp.Core/resumable.fs @@ -11,6 +11,7 @@ namespace Microsoft.FSharp.Core.CompilerServices open System open System.Runtime.CompilerServices +open System.Threading.Tasks open Microsoft.FSharp.Core open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators open Microsoft.FSharp.Collections @@ -110,6 +111,12 @@ module StateMachineHelpers = failwith "__stateMachine should always be guarded by __useResumableCode and only used in valid state machine implementations" + [] + let __runtimeAsync<'T> (value: 'T) : Task<'T> = + ignore value + + failwith "__runtimeAsync is a compiler intrinsic and should only be used in runtime-async method bodies" + module ResumableCode = open System.Runtime.ExceptionServices diff --git a/src/FSharp.Core/resumable.fsi b/src/FSharp.Core/resumable.fsi index e62a6597729..73c08775d05 100644 --- a/src/FSharp.Core/resumable.fsi +++ b/src/FSharp.Core/resumable.fsi @@ -194,6 +194,11 @@ module StateMachineHelpers = afterCode: AfterCode<'Data, 'Result> -> 'Result + /// Marks an expression result for lowering as a .NET runtime-async method. + /// This function is compiler-recognised and must not be called directly. + [] + val __runtimeAsync<'T> : 'T -> System.Threading.Tasks.Task<'T> + /// Adding this attribute to the method adjusts the processing of some generic methods /// during overload resolution. /// From 719d00fbb5100de267125fe60196576944e31635 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 08:41:21 +0200 Subject: [PATCH 03/59] tests --- .../FSharp.Compiler.ComponentTests.fsproj | 2 + .../RuntimeAsync/RuntimeAsyncBasic.fs | 68 + .../RuntimeAsync/RuntimeTaskBuilder.fs | 206 +++ .../Language/RuntimeAsync/RuntimeTasks.fs | 1292 +++++++++++++++++ .../RuntimeTasksAsyncDisposalException.fs | 25 + .../Language/RuntimeAsyncTests.fs | 178 +++ 6 files changed, 1771 insertions(+) create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs diff --git a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj index 476b903efcf..5df4af18719 100644 --- a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj +++ b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj @@ -17,6 +17,7 @@ $(DefineConstants);DEBUG true + runtime-async=on true @@ -385,6 +386,7 @@ + diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs new file mode 100644 index 00000000000..2df7b814a47 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs @@ -0,0 +1,68 @@ +module RuntimeAsyncBasic + +open System +open System.Runtime.CompilerServices +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let private delayed value = + Task.Delay(1).ContinueWith(fun (_: Task) -> value) + +let add (x: int) (y: int) : Task = + StateMachineHelpers.__runtimeAsync ( + let first = AsyncHelpers.Await(delayed x) + first + y) + +let lambdaAdd : int -> Task = + fun value -> + StateMachineHelpers.__runtimeAsync ( + let result = AsyncHelpers.Await(delayed value) + result + 1) + +let makeAdder (offset: int) : int -> Task = + fun value -> + StateMachineHelpers.__runtimeAsync ( + let result = AsyncHelpers.Await(delayed value) + result + offset) + +let inline apply ([] operation: int -> int) (value: int) = + operation value + +let inline awaitAndAdd (value: int) = + let result = + AsyncHelpers.Await(Task.Delay(1).ContinueWith(fun (_: Task) -> value)) + + apply (fun current -> current + 1) result + +let addWithInline (value: int) : Task = + StateMachineHelpers.__runtimeAsync (awaitAndAdd value) + +type Calculator() = + member _.Add(x: int, y: int) : Task = + StateMachineHelpers.__runtimeAsync ( + let first = AsyncHelpers.Await(delayed x) + first + y) + + static member Double(value: int) : Task = + StateMachineHelpers.__runtimeAsync (value * 2) + +let private resultOf (task: Task) = + task.GetAwaiter().GetResult() + +[] +let main _ = + let calculator = Calculator() + let capturedAdder = makeAdder 10 + + let results = + [ + add 20 22 + lambdaAdd 41 + capturedAdder 32 + addWithInline 41 + calculator.Add(20, 22) + Calculator.Double 21 + ] + |> List.map resultOf + + if results = [ 42; 42; 42; 42; 42; 42 ] then 0 else 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs new file mode 100644 index 00000000000..a37691833f8 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs @@ -0,0 +1,206 @@ +module RuntimeTaskBuilder + +open System +open System.Runtime.CompilerServices +open System.Threading.Tasks +open Microsoft.FSharp.Control +open Microsoft.FSharp.Core.CompilerServices + +type RuntimeTask<'T> = unit -> 'T + +let inline bindAwaiter + ([] getAwaiter: unit -> 'Awaiter) + ([] getResult: 'Awaiter -> 'T) + ([] continuation: 'T -> 'U) + = + let awaiter = getAwaiter() + AsyncHelpers.AwaitAwaiter awaiter + let result = getResult awaiter + continuation result + +type RuntimeTaskBuilder() = + member inline _.Delay([] generator: unit -> 'T) : unit -> 'T = generator + member inline _.Run([] code: unit -> 'T) : Task<'T> = + StateMachineHelpers.__runtimeAsync (code()) + member inline _.Zero() = () + member inline _.Return(value: 'T) = value + member inline _.ReturnFrom(task: Task<'T>) = AsyncHelpers.Await task + member inline _.ReturnFrom(task: Task) = AsyncHelpers.Await task + member inline _.ReturnFrom(task: ValueTask<'T>) = AsyncHelpers.Await task + member inline _.ReturnFrom(task: ValueTask) = AsyncHelpers.Await task + member inline _.ReturnFrom(computation: Async<'T>) = AsyncHelpers.Await(Async.StartImmediateAsTask computation) + member inline _.Bind(task: Task, [] continuation: unit -> 'U) = + AsyncHelpers.Await task + continuation() + member inline _.Bind(task: Task<'T>, [] continuation: 'T -> 'U) = + continuation (AsyncHelpers.Await task) + member inline _.Bind(code: struct ('T1 * 'T2), [] continuation: struct ('T1 * 'T2) -> 'U) = + continuation code + member inline _.Bind(computation: RuntimeTask<'T>, [] continuation: 'T -> 'U) = + continuation (computation ()) + member inline _.Bind(task: ValueTask, [] continuation: unit -> 'U) = + AsyncHelpers.Await task + continuation() + member inline _.Bind(task: ValueTask<'T>, [] continuation: 'T -> 'U) = + continuation (AsyncHelpers.Await task) + member inline _.Bind(computation: Async<'T>, [] continuation: 'T -> 'U) = + continuation (AsyncHelpers.Await(Async.StartImmediateAsTask computation)) + member inline _.Combine(first, [] second) = + first() + second() + member inline _.Combine(first: unit, [] second: unit -> 'T) = second() + member inline _.TryWith([] body: unit -> 'T, [] handler: exn -> 'T) = + try body() with error -> handler error + member inline _.TryFinally([] body: unit -> 'T, compensation: unit -> unit) = + try body() finally compensation() + member inline _.Using(resource: 'Resource, [] body: 'Resource -> 'T) = + // Awaiting in a finally region is forbidden by the runtime-async contract. + // Hoist the DisposeAsync suspension out of the region: capture any exception + // from the body in a catch-all, run disposal (possibly suspending) outside + // the handler, then restore the pending exception. Mirrors the Roslyn + // runtime-async lowering for `await` in `finally`. + let mutable pendingException: exn = null + + let result = + try + Choice1Of2(body resource) + with error -> + pendingException <- error + Choice2Of2() + + match box resource with + | :? IAsyncDisposable as disposable -> AsyncHelpers.Await(disposable.DisposeAsync()) + | :? IDisposable as disposable -> disposable.Dispose() + | _ -> () + + match pendingException with + | null -> () + | error -> raise error + + match result with + | Choice1Of2 value -> value + | Choice2Of2() -> Unchecked.defaultof<'T> + member inline _.While(guard: unit -> bool, [] body: unit -> unit) = + while guard() do body() + member inline _.For(sequence: seq<'T>, [] body: 'T -> unit) = + for item in sequence do body item + member inline _.MergeSources(left: Task<'T1>, right: Task<'T2>) = + struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: ValueTask<'T2>) = + struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: Task<'T1>, right: ValueTask<'T2>) = + struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: Task<'T2>) = + struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: Task<'T1>, right: Async<'T2>) = + struct (AsyncHelpers.Await left, AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: Async<'T1>, right: Task<'T2>) = + struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), AsyncHelpers.Await right) + member inline _.MergeSources(left: Async<'T1>, right: Async<'T2>) = + struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: Async<'T1>, right: ValueTask<'T2>) = + struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: Async<'T2>) = + struct (AsyncHelpers.Await left, AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: YieldAwaitable, right: Task<'T2>) = + AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) + struct ((), AsyncHelpers.Await right) + member inline _.MergeSources(left: Task<'T1>, right: YieldAwaitable) = + let leftResult = AsyncHelpers.Await left + AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) + struct (leftResult, ()) + member inline _.MergeSources(left: YieldAwaitable, right: ValueTask<'T2>) = + AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) + struct ((), AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: YieldAwaitable) = + let leftResult = AsyncHelpers.Await left + AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) + struct (leftResult, ()) + member inline _.MergeSources(left: YieldAwaitable, right: Async<'T2>) = + AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) + struct ((), AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: Async<'T1>, right: YieldAwaitable) = + let leftResult = AsyncHelpers.Await(Async.StartImmediateAsTask left) + AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) + struct (leftResult, ()) + member inline _.MergeSources(left: YieldAwaitable, right: struct ('T2 * 'T3)) = + AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) + struct ((), right) + member inline _.MergeSources(left: struct ('T1 * 'T2), right: YieldAwaitable) = + AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) + struct (left, ()) + member inline _.MergeSources(left: Task<'T1>, right: struct ('T2 * 'T3)) = + struct (AsyncHelpers.Await left, right) + member inline _.MergeSources(left: ValueTask<'T1>, right: struct ('T2 * 'T3)) = + struct (AsyncHelpers.Await left, right) + member inline _.MergeSources(left: Async<'T1>, right: struct ('T2 * 'T3)) = + struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), right) + member inline _.MergeSources(left: struct ('T1 * 'T2), right: Task<'T3>) = + struct (left, AsyncHelpers.Await right) + member inline _.MergeSources(left: struct ('T1 * 'T2), right: ValueTask<'T3>) = + struct (left, AsyncHelpers.Await right) + member inline _.MergeSources(left: struct ('T1 * 'T2), right: Async<'T3>) = + struct (left, AsyncHelpers.Await(Async.StartImmediateAsTask right)) + +module RuntimeTaskAwaitableExtensions = + type RuntimeTaskBuilder with + // SRTP fallbacks mirroring the task builder's task-like Bind/ReturnFrom/MergeSources, + // so custom awaitables compose without dedicated overloads. + [] + member inline _.ReturnFrom< ^TaskLike, ^Awaiter, 'T + when ^TaskLike: (member GetAwaiter: unit -> ^Awaiter) + and ^Awaiter :> ICriticalNotifyCompletion + and ^Awaiter: (member get_IsCompleted: unit -> bool) + and ^Awaiter: (member GetResult: unit -> 'T)> + (task: ^TaskLike) + : 'T = + bindAwaiter + (fun () -> (^TaskLike: (member GetAwaiter: unit -> ^Awaiter) task)) + (fun awaiter -> (^Awaiter: (member GetResult: unit -> 'T) awaiter)) + id + + [] + member inline _.MergeSources< ^TaskLike1, ^TaskLike2, ^Awaiter1, ^Awaiter2, 'T1, 'T2 + when ^TaskLike1: (member GetAwaiter: unit -> ^Awaiter1) + and ^TaskLike2: (member GetAwaiter: unit -> ^Awaiter2) + and ^Awaiter1 :> ICriticalNotifyCompletion + and ^Awaiter2 :> ICriticalNotifyCompletion + and ^Awaiter1: (member get_IsCompleted: unit -> bool) + and ^Awaiter1: (member GetResult: unit -> 'T1) + and ^Awaiter2: (member get_IsCompleted: unit -> bool) + and ^Awaiter2: (member GetResult: unit -> 'T2)> + (task1: ^TaskLike1, task2: ^TaskLike2) + : struct ('T1 * 'T2) = + let await1 () = + bindAwaiter + (fun () -> (^TaskLike1: (member GetAwaiter: unit -> ^Awaiter1) task1)) + (fun awaiter -> (^Awaiter1: (member GetResult: unit -> 'T1) awaiter)) + id + + let await2 () = + bindAwaiter + (fun () -> (^TaskLike2: (member GetAwaiter: unit -> ^Awaiter2) task2)) + (fun awaiter -> (^Awaiter2: (member GetResult: unit -> 'T2) awaiter)) + id + // Sequential awaits, matching the task builder's MergeSources; concurrency + // comes from the sources being already-started hot tasks. + struct (await1 (), await2 ()) + + [] + member inline _.Bind< ^TaskLike, ^Awaiter, 'T, 'U + when ^TaskLike: (member GetAwaiter: unit -> ^Awaiter) + and ^Awaiter :> ICriticalNotifyCompletion + and ^Awaiter: (member get_IsCompleted: unit -> bool) + and ^Awaiter: (member GetResult: unit -> 'T)> + (task: ^TaskLike, [] continuation: 'T -> 'U) + : 'U = + bindAwaiter + (fun () -> (^TaskLike: (member GetAwaiter: unit -> ^Awaiter) task)) + (fun awaiter -> (^Awaiter: (member GetResult: unit -> 'T) awaiter)) + continuation + +open RuntimeTaskAwaitableExtensions + +[] +module RuntimeTask = + let runtimeTask = RuntimeTaskBuilder() diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs new file mode 100644 index 00000000000..0a5f91d4a3d --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs @@ -0,0 +1,1292 @@ +// Tests for the runtime-async RuntimeTaskBuilder, ported from the TaskBuilder tests in +// tests/FSharp.Core.UnitTests/FSharp.Core/Microsoft.FSharp.Control/Tasks.fs +// with `task {` replaced by `runtimeTask {`. Test names and bodies are kept as +// close to the originals as possible. +// +// Tests that require suspending inside an exception-handling region are in the +// "Known failing" section at the bottom and are NOT called from main: the .NET +// runtime-async contract forbids suspension in EH regions, and depending on the +// case this currently either loses the finally or terminates the process +// (0xC0000409). `backgroundTask` tests have no runtimeTask equivalent and are +// omitted. + +module RuntimeTasks + +open System +open System.Collections +open System.Collections.Generic +open System.Diagnostics +open System.Threading +open System.Threading.Tasks +open Microsoft.FSharp.Control +open Microsoft.FSharp.Core.CompilerServices + +open RuntimeTaskBuilder.RuntimeTask +open RuntimeTaskBuilder.RuntimeTaskAwaitableExtensions + +exception TestException of string + +let BIG = 10 +let require x msg = if not x then failwith msg +let failtest str = raise (TestException str) +let resultOf (task: Task<'T>) = task.GetAwaiter().GetResult() + +let private delayed value = + Task.Delay(1).ContinueWith(fun (_: Task) -> value) + +// --------------------------------------------------------------------------- +// SmokeTestsForCompilation +// --------------------------------------------------------------------------- + +let tinyTask () = + runtimeTask { + return 1 + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let tbind () = + runtimeTask { + let! x = Task.FromResult(1) + return 1 + x + } + |> fun t -> + t.Wait() + if t.Result <> 2 then failwith "failed" + +let tnested () = + runtimeTask { + let! x = runtimeTask { return 1 } + return x + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let tcatch0 () = + runtimeTask { + try + return 1 + with e -> + return 2 + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let tcatch1 () = + runtimeTask { + try + let! x = Task.FromResult 1 + return x + with e -> + return 2 + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let t3 () = + let t2() = + runtimeTask { + System.Console.WriteLine("hello") + return 1 + } + runtimeTask { + System.Console.WriteLine("hello") + let! x = t2() + System.Console.WriteLine("world") + return 1 + x + } + |> fun t -> + t.Wait() + if t.Result <> 2 then failwith "failed" + +let t3b () = + runtimeTask { + System.Console.WriteLine("hello") + let! x = Task.FromResult(1) + System.Console.WriteLine("world") + return 1 + x + } + |> fun t -> + t.Wait() + if t.Result <> 2 then failwith "failed" + +let t3c () = + runtimeTask { + System.Console.WriteLine("hello") + do! Task.Delay(100) + System.Console.WriteLine("world") + return 1 + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +// This tests an exception match +let t67 () = + runtimeTask { + try + do! Task.Delay(0) + with + | :? ArgumentException -> + () + | _ -> + () + } + |> fun t -> + t.Wait() + if t.Result <> () then failwith "failed" + +// This tests compiling an incomplete exception match +let t68 () = + runtimeTask { + try + do! Task.Delay(0) + with + | :? ArgumentException -> + () + } + |> fun t -> + t.Wait() + if t.Result <> () then failwith "failed" + +let testCompileAsyncWhileLoop () = + runtimeTask { + let mutable i = 0 + while i < 5 do + i <- i + 1 + do! Task.Yield() + return i + } + |> fun t -> + t.Wait() + if t.Result <> 5 then failwith "failed" + +let merge2tasks () = + runtimeTask { + let! x = Task.FromResult(1) + and! y = Task.FromResult(2) + return x + y + } + |> fun t -> + t.Wait() + if t.Result <> 3 then failwith "failed" + +let merge3tasks () = + runtimeTask { + let! x = Task.FromResult(1) + and! y = Task.FromResult(2) + and! z = Task.FromResult(3) + return x + y + z + } + |> fun t -> + t.Wait() + if t.Result <> 6 then failwith "failed" + +let mergeYieldAndTask () = + runtimeTask { + let! _ = Task.Yield() + and! y = Task.FromResult(1) + return y + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let mergeTaskAndYield () = + runtimeTask { + let! x = Task.FromResult(1) + and! _ = Task.Yield() + return x + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let merge2valueTasks () = + runtimeTask { + let! x = ValueTask(Task.FromResult(1)) + and! y = ValueTask(Task.FromResult(2)) + return x + y + } + |> fun t -> + t.Wait() + if t.Result <> 3 then failwith "failed" + +let merge2valueTasksAndYield () = + runtimeTask { + let! x = ValueTask(Task.FromResult(1)) + and! y = ValueTask(Task.FromResult(2)) + and! _ = Task.Yield() + return x + y + } + |> fun t -> + t.Wait() + if t.Result <> 3 then failwith "failed" + +let mergeYieldAnd2tasks () = + runtimeTask { + let! _ = Task.Yield() + and! x = Task.FromResult(1) + and! y = Task.FromResult(2) + return x + y + } + |> fun t -> + t.Wait() + if t.Result <> 3 then failwith "failed" + +let merge2tasksAndValueTask () = + runtimeTask { + let! x = Task.FromResult(1) + and! y = Task.FromResult(2) + and! z = ValueTask(Task.FromResult(3)) + return x + y + z + } + |> fun t -> + t.Wait() + if t.Result <> 6 then failwith "failed" + +let merge2asyncs () = + runtimeTask { + let! x = async { return 1 } + and! y = async { return 2 } + return x + y + } + |> fun t -> + t.Wait() + if t.Result <> 3 then failwith "failed" + +let merge3asyncs () = + runtimeTask { + let! x = async { return 1 } + and! y = async { return 2 } + and! z = async { return 3 } + return x + y + z + } + |> fun t -> + t.Wait() + if t.Result <> 6 then failwith "failed" + +let mergeYieldAndAsync () = + runtimeTask { + let! _ = Task.Yield() + and! y = async { return 1 } + return y + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let mergeAsyncAndYield () = + runtimeTask { + let! x = async { return 1 } + and! _ = Task.Yield() + return x + } + |> fun t -> + t.Wait() + if t.Result <> 1 then failwith "failed" + +let mergeYieldAnd2asyncs () = + runtimeTask { + let! _ = Task.Yield() + and! x = async { return 1 } + and! y = async { return 2 } + return x + y + } + |> fun t -> + t.Wait() + if t.Result <> 3 then failwith "failed" + +let merge2asyncsAndValueTask () = + runtimeTask { + let! x = async { return 1 } + and! y = async { return 2 } + and! z = ValueTask(Task.FromResult(3)) + return x + y + z + } + |> fun t -> + t.Wait() + if t.Result <> 6 then failwith "failed" + +// --------------------------------------------------------------------------- +// Basics +// --------------------------------------------------------------------------- + +let testShortCircuitResult () = + let t = + runtimeTask { + let! x = Task.FromResult(1) + let! y = Task.FromResult(2) + return x + y + } + require t.IsCompleted "didn't short-circuit already completed tasks" + require (t.Result = 3) "wrong result" + +let testDelay () = + let mutable x = 0 + let t = + runtimeTask { + do! Task.Delay(50) + x <- x + 1 + } + require (x = 0) "task already ran" + t.Wait() + +// KNOWN DIVERGENCE: moved to the known-failing section; the current runtime +// build does not run a runtime-async body synchronously up to its first real +// suspension, so "first part didn't run yet" fails. + +let testNonBlocking () = + let allowContinue = new SemaphoreSlim(0) + let continueToFinish = new ManualResetEventSlim(false) + let finished = new ManualResetEventSlim() + let t = + runtimeTask { + do! allowContinue.WaitAsync() + continueToFinish.Wait() + finished.Set() + } + allowContinue.Release() |> ignore + require (not finished.IsSet) "sleep blocked caller" + continueToFinish.Set() + t.Wait() + +// The knownFailing_* tests below suspend inside try/with in non-tail position +// (or require synchronous start before the first suspension). Suspension in +// exception-handling regions is forbidden by the runtime-async contract; these +// compile but are not run from main. + +let knownFailing_testCatching1 () = + let mutable x = 0 + let mutable y = 0 + let t = + runtimeTask { + try + do! Task.Delay(0) + failtest "hello" + x <- 1 + do! Task.Delay(100) + with + | TestException msg -> + require (msg = "hello") "message tampered" + | _ -> + require false "other exn type" + y <- 1 + } + t.Wait() + require (y = 1) "bailed after exn" + require (x = 0) "ran past failure" + +let knownFailing_testCatching2 () = + let mutable x = 0 + let mutable y = 0 + let t = + runtimeTask { + try + do! Task.Yield() // can't skip through this + failtest "hello" + x <- 1 + do! Task.Delay(100) + with + | TestException msg -> + require (msg = "hello") "message tampered" + | _ -> + require false "other exn type" + y <- 1 + } + t.Wait() + require (y = 1) "bailed after exn" + require (x = 0) "ran past failure" + +let knownFailing_testCatchingInApplicative () = + let mutable x = 0 + let mutable y = 0 + let t = + runtimeTask { + try + let! _ = runtimeTask { + do! Task.Delay(100) + x <- 1 + } + and! _ = runtimeTask { + failtest "hello" + } + () + with + | TestException msg -> + require (msg = "hello") "message tampered" + | _ -> + require false "other exn type" + y <- 1 + } + t.Wait() + require (y = 1) "bailed after exn" + require (x = 1) "exit too early" + +let knownFailing_testNestedCatching () = + let mutable counter = 1 + let mutable caughtInner = 0 + let mutable caughtOuter = 0 + let t1() = + runtimeTask { + try + do! Task.Yield() + failtest "hello" + with + | TestException msg as exn -> + caughtInner <- counter + counter <- counter + 1 + raise exn + } + let t2 = + runtimeTask { + try + do! t1() + with + | TestException msg as exn -> + caughtOuter <- counter + raise exn + | e -> + require false (sprintf "invalid msg type %s" e.Message) + } + try + t2.Wait() + require false "ran past failed task wait" + with + | :? AggregateException as exn -> + require (exn.InnerExceptions.Count = 1) "more than 1 exn" + require (caughtInner = 1) "didn't catch inner" + require (caughtOuter = 2) "didn't catch outer" + +let testWhileLoopSync () = + let t = + runtimeTask { + let mutable i = 0 + while i < 10 do + i <- i + 1 + return i + } + //t.Wait() no wait required for sync loop + require (t.IsCompleted) "didn't do sync while loop properly - not completed" + require (t.Result = 10) "didn't do sync while loop properly - wrong result" + +let testWhileLoopAsyncZeroIteration () = + for i in 1 .. 5 do + let t = + runtimeTask { + let mutable i = 0 + while i < 0 do + i <- i + 1 + do! Task.Yield() + return i + } + t.Wait() + require (t.Result = 0) "didn't do while loop properly" + +let testWhileLoopAsyncOneIteration () = + for i in 1 .. 5 do + let t = + runtimeTask { + let mutable i = 0 + while i < 1 do + i <- i + 1 + do! Task.Yield() + return i + } + t.Wait() + require (t.Result = 1) "didn't do while loop properly" + +let testWhileLoopAsync () = + for i in 1 .. 5 do + let t = + runtimeTask { + let mutable i = 0 + while i < 10 do + i <- i + 1 + do! Task.Yield() + return i + } + t.Wait() + require (t.Result = 10) "didn't do while loop properly" + +let testForLoopA () = + let list = ["a"; "b"; "c"] |> Seq.ofList + let t = + runtimeTask { + let mutable x = Unchecked.defaultof<_> + let e = list.GetEnumerator() + while e.MoveNext() do + x <- e.Current + do! Task.Yield() + } + t.Wait() + +let testForLoopComplex () = + let mutable disposed = false + let wrapList = + let raw = ["a"; "b"; "c"] |> Seq.ofList + let getEnumerator() = + let raw = raw.GetEnumerator() + { new IEnumerator with + member _.MoveNext() = + require (not disposed) "moved next after disposal" + raw.MoveNext() + member _.Current = + require (not disposed) "accessed current after disposal" + raw.Current + member _.Current = + require (not disposed) "accessed current (boxed) after disposal" + box raw.Current + member _.Dispose() = + require (not disposed) "disposed twice" + disposed <- true + raw.Dispose() + member _.Reset() = + require (not disposed) "reset after disposal" + raw.Reset() + } + { new IEnumerable with + member _.GetEnumerator() : IEnumerator = getEnumerator() + member _.GetEnumerator() : IEnumerator = upcast getEnumerator() + } + let t = + runtimeTask { + let mutable index = 0 + do! Task.Yield() + for x in wrapList do + do! Task.Yield() + do! Task.Yield() + match index with + | 0 -> require (x = "a") "wrong first value" + | 1 -> require (x = "b") "wrong second value" + | 2 -> require (x = "c") "wrong third value" + | _ -> require false "iterated too far!" + index <- index + 1 + do! Task.Yield() + do! Task.Yield() + do! Task.Yield() + return 1 + } + t.Wait() + require disposed "never disposed D" + require (t.Result = 1) "wrong result" + +let testForLoopSadPath () = + for i in 1 .. 5 do + let wrapList = ["a"; "b"; "c"] + let t = + runtimeTask { + let mutable index = 0 + do! Task.Yield() + for x in wrapList do + do! Task.Yield() + index <- index + 1 + return 1 + } + require (t.Result = 1) "wrong result" + +let knownFailing_testForLoopSadPathComplex () = + for i in 1 .. 5 do + let mutable disposed = false + let wrapList = + let raw = ["a"; "b"; "c"] |> Seq.ofList + let getEnumerator() = + let raw = raw.GetEnumerator() + { new IEnumerator with + member _.MoveNext() = + require (not disposed) "moved next after disposal" + raw.MoveNext() + member _.Current = + require (not disposed) "accessed current after disposal" + raw.Current + member _.Current = + require (not disposed) "accessed current (boxed) after disposal" + box raw.Current + member _.Dispose() = + require (not disposed) "disposed twice" + disposed <- true + raw.Dispose() + member _.Reset() = + require (not disposed) "reset after disposal" + raw.Reset() + } + { new IEnumerable with + member _.GetEnumerator() : IEnumerator = getEnumerator() + member _.GetEnumerator() : IEnumerator = upcast getEnumerator() + } + let mutable caught = false + let t = + runtimeTask { + try + let mutable index = 0 + do! Task.Yield() + for x in wrapList do + do! Task.Yield() + match index with + | 0 -> require (x = "a") "wrong first value" + | _ -> failtest "uhoh" + index <- index + 1 + do! Task.Yield() + do! Task.Yield() + return 1 + with + | TestException "uhoh" -> + caught <- true + return 2 + } + require (t.Result = 2) "wrong result" + require caught "didn't catch exception" + require disposed "never disposed A" + +let knownFailing_testExceptionAttachedToTaskWithoutAwait () = + for i in 1 .. 5 do + let mutable ranA = false + let mutable ranB = false + let t = + runtimeTask { + ranA <- true + failtest "uhoh" + ranB <- true + } + require ranA "didn't run immediately" + require (not ranB) "ran past exception" + require (not (isNull t.Exception)) "didn't capture exception" + require (t.Exception.InnerExceptions.Count = 1) "captured more exceptions" + require (t.Exception.InnerException = TestException "uhoh") "wrong exception" + let mutable caught = false + let mutable ranCatcher = false + let catcher = + runtimeTask { + try + ranCatcher <- true + let! result = t + return false + with + | TestException "uhoh" -> + caught <- true + return true + } + require ranCatcher "didn't run" + require catcher.Result "didn't catch" + require caught "didn't catch" + +let knownFailing_testExceptionAttachedToTaskWithAwait () = + for i in 1 .. 5 do + let mutable ranA = false + let mutable ranB = false + let t = + runtimeTask { + ranA <- true + failtest "uhoh" + do! Task.Delay(100) + ranB <- true + } + require ranA "didn't run immediately" + require (not ranB) "ran past exception" + require (not (isNull t.Exception)) "didn't capture exception" + require (t.Exception.InnerExceptions.Count = 1) "captured more exceptions" + require (t.Exception.InnerException = TestException "uhoh") "wrong exception" + let mutable caught = false + let mutable ranCatcher = false + let catcher = + runtimeTask { + try + ranCatcher <- true + let! result = t + return false + with + | TestException "uhoh" -> + caught <- true + return true + } + require ranCatcher "didn't run" + require catcher.Result "didn't catch" + require caught "didn't catch" + +let testFixedStackWhileLoop () = + for i in 1 .. 100 do + let t = + runtimeTask { + let mutable maxDepth = Nullable() + let mutable i = 0 + while i < BIG do + i <- i + 1 + do! Task.Yield() + if i % 100 = 0 then + let stackDepth = StackTrace().FrameCount + if maxDepth.HasValue && stackDepth > maxDepth.Value then + failwith "Stack depth increased!" + maxDepth <- Nullable(stackDepth) + return i + } + t.Wait() + require (t.Result = BIG) "didn't get to big number" + +let knownFailing_testFixedStackForLoop () = // needs investigation: code after a suspending for loop is not run + for i in 1 .. 100 do + let mutable ran = false + let t = + runtimeTask { + let mutable maxDepth = Nullable() + for i in Seq.init BIG id do + do! Task.Yield() + if i % 100 = 0 then + let stackDepth = StackTrace().FrameCount + if maxDepth.HasValue && stackDepth > maxDepth.Value then + failwith "Stack depth increased!" + maxDepth <- Nullable(stackDepth) + ran <- true + return () + } + t.Wait() + require ran "didn't run all" + +let testTypeInference () = + let t1 : string Task = + runtimeTask { + return "hello" + } + let t2 = + runtimeTask { + // Divergence from task {}: the runtimeTask Bind overload set does not + // propagate the element type here, so the annotation is required. + let! (s: string) = t1 + return s.Length + } + t2.Wait() + +let testNoStackOverflowWithImmediateResult () = + let longLoop = + runtimeTask { + let mutable n = 0 + while n < BIG do + n <- n + 1 + return! Task.FromResult(()) + } + longLoop.Wait() + +let testNoStackOverflowWithYieldResult () = + let longLoop = + runtimeTask { + let mutable n = 0 + while n < BIG do + let! _ = + runtimeTask { + do! Task.Yield() + let! _ = Task.FromResult(0) + n <- n + 1 + } + n <- n + 1 + } + longLoop.Wait() + +let testSmallTailRecursion () = + let rec loop n = + runtimeTask { + if n < 100 then + do! Task.Yield() + let! _ = Task.FromResult(0) + return! loop (n + 1) + else + return () + } + let shortLoop = + runtimeTask { + return! loop 0 + } + shortLoop.Wait() + +let testTryOverReturnFrom () = + let inner() = + runtimeTask { + do! Task.Yield() + failtest "inner" + return 1 + } + let t = + runtimeTask { + try + do! Task.Yield() + return! inner() + with + | TestException "inner" -> return 2 + } + require (t.Result = 2) "didn't catch" + +let testAsyncsMixedWithTasks () = + let t = + runtimeTask { + do! Task.Delay(1) + do! Async.Sleep(1) + let! x = + async { + do! Async.Sleep(1) + return 5 + } + return! async { return x + 3 } + } + let result = t.Result + require (result = 8) "something weird happened" + +let testAsyncsMixedWithTasks_ShouldNotSwitchContext () = + let t = runtimeTask { + let a = Thread.CurrentThread.ManagedThreadId + let! b = async { + return Thread.CurrentThread.ManagedThreadId + } + let c = Thread.CurrentThread.ManagedThreadId + return $"Before: {a}, in async: {b}, after async: {c}" + } + let d = Thread.CurrentThread.ManagedThreadId + let actual = $"{t.Result}, after task: {d}" + + require (actual = $"Before: {d}, in async: {d}, after async: {d}, after task: {d}") actual + +// no need to call this, we just want to check that it compiles w/o warnings +let testTrivialReturnCompiles (x : 'a) : 'a Task = + runtimeTask { + do! Task.Yield() + return x + } + +// no need to call this, we just want to check that it compiles w/o warnings +let testTrivialTransformedReturnCompiles (x : 'a) (f : 'a -> 'b) : 'b Task = + runtimeTask { + do! Task.Yield() + return f x + } + +// no need to call this, we just want to check that it compiles w/o warnings +let testDefaultInferenceForReturnFrom () = + let t = runtimeTask { return Some "x" } + runtimeTask { + let! r = t + if r = None then + // Divergence from task {}: ReturnFrom is overloaded, so the generic + // failwithf result needs an explicit Task<_> annotation. + return! (failwithf "Could not find x" : string option Task) + else + return r + } + |> ignore + +// no need to call this, just check that it compiles +let testCompilerInfersArgumentOfReturnFrom () = + runtimeTask { + if true then return 1 + else return! (failwith "" : int Task) + } + |> ignore + +// Overload-resolution cases from the bottom of Tasks.fs (Issue12184*), compile-only. +type Issue12184() = + member this.TaskMethod() = + runtimeTask { + // The overload resolution for Bind commits to 'Async' since the type annotation is present. + let! result = this.AsyncMethod(21) + return result + } + + member _.AsyncMethod(value: int) : Async = + async { + return (value * 2) + } + +type Issue12184b() = + member this.TaskMethod() = + runtimeTask { + // The overload resolution for Bind commits to 'YieldAwaitable' since the type annotation is present. + let! result = this.AsyncMethod(21) + return result + } + + member _.AsyncMethod(_value: int) : System.Runtime.CompilerServices.YieldAwaitable = + Task.Yield() + +// Issue12184c from Tasks.fs is omitted: it relies on task {}'s Bind overload +// resolution committing to Task<_> for an unannotated argument, which the +// runtimeTask builder's overload set does not support. + +module Issue12184d = + let TaskMethod(t: ValueTask) = + runtimeTask { + let! result = t + return result + } + +module Issue12184e = + let TaskMethod(t: ValueTask) = + runtimeTask { + let! result = t + return result + } + +module Issue12184f = + let TaskMethod(t: Task) = + runtimeTask { + let! result = t + return result + } + +// --------------------------------------------------------------------------- +// Known failing: these tests suspend inside an exception-handling region +// (try/finally or an `Using` finally that awaits an IAsyncDisposable), which +// the runtime-async contract forbids. Today they either lose the finally or +// terminate the process (0xC0000409), so they are compiled but not run. +// RuntimeTasksAsyncDisposalException.fs keeps the minimal crash repro. +// +// A second group relies on synchronous (hot) start of the task body up to the +// first suspension. On the current runtime build a runtime-async body does not +// observably run before the returned Task is awaited, so these are not run +// either. +// --------------------------------------------------------------------------- + +let knownDivergent_testNoDelay () = + let mutable x = 0 + let t = + runtimeTask { + x <- x + 1 + do! Task.Delay(5) + x <- x + 1 + } + require (x = 1) "first part didn't run yet" + t.Wait() + +let knownFailing_testTryFinallyHappyPath () = + for i in 1 .. 5 do + let mutable ran = false + let t = + runtimeTask { + try + require (not ran) "ran way early" + do! Task.Delay(100) + require (not ran) "ran kinda early" + finally + ran <- true + } + t.Wait() + require ran "never ran" + +let knownFailing_testTryFinallySadPath () = + for i in 1 .. 5 do + let mutable ran = false + let t = + runtimeTask { + try + require (not ran) "ran way early" + do! Task.Delay(100) + require (not ran) "ran kinda early" + failtest "uhoh" + finally + ran <- true + } + try + t.Wait() + with + | _ -> () + require ran "never ran" + +let knownFailing_testTryFinallyCaught () = + for i in 1 .. 5 do + let mutable ran = false + let t = + runtimeTask { + try + try + require (not ran) "ran way early" + do! Task.Delay(100) + require (not ran) "ran kinda early" + failtest "uhoh" + finally + ran <- true + return 1 + with + | _ -> return 2 + } + require (t.Result = 2) "wrong return" + require ran "never ran" + +let knownFailing_testUsing () = + for i in 1 .. 5 do + let mutable disposed = false + let t = + runtimeTask { + use d = { new IDisposable with member _.Dispose() = disposed <- true } + require (not disposed) "disposed way early" + do! Task.Delay(100) + require (not disposed) "disposed kinda early" + } + t.Wait() + require disposed "never disposed B" + +let knownFailing_testUsingFromTask () = + let mutable disposedInner = false + let mutable disposed = false + let t = + runtimeTask { + use! d = + runtimeTask { + do! Task.Delay(50) + use i = { new IDisposable with member _.Dispose() = disposedInner <- true } + require (not disposed && not disposedInner) "disposed inner early" + return { new IDisposable with member _.Dispose() = disposed <- true } + } + require disposedInner "did not dispose inner after task completion" + require (not disposed) "disposed way early" + do! Task.Delay(50) + require (not disposed) "disposed kinda early" + } + t.Wait() + require disposed "never disposed C" + +let knownFailing_testUsingSadPath () = + let mutable disposedInner = false + let mutable disposed = false + let t = + runtimeTask { + try + use! d = + runtimeTask { + do! Task.Delay(50) + use i = { new IDisposable with member _.Dispose() = disposedInner <- true } + failtest "uhoh" + require (not disposed && not disposedInner) "disposed inner early" + return { new IDisposable with member _.Dispose() = disposed <- true } + } + () + with + | TestException msg -> + require disposedInner "did not dispose inner after task completion" + require (not disposed) "disposed way early" + do! Task.Delay(50) + require (not disposed) "disposed kinda early" + } + t.Wait() + require (not disposed) "disposed thing that never should've existed" + +let testUsingAsyncDisposableSync () = + for i in 1 .. 5 do + let mutable disposed = 0 + let t = + runtimeTask { + use d = + { new IAsyncDisposable with + member _.DisposeAsync() = + runtimeTask { + disposed <- disposed + 1 } + |> ValueTask + } + require (disposed = 0) "disposed way early" + do! Task.Delay(100) + require (disposed = 0) "disposed kinda early" + } + t.Wait() + require (disposed >= 1) "never disposed B" + require (disposed <= 1) "too many dispose on B" + +let knownFailing_testExceptionThrownInFinally () = + for i in 1 .. 5 do + use stepOutside = new SemaphoreSlim(0) + use ranInitial = new ManualResetEventSlim() + use ranNext = new ManualResetEventSlim() + let mutable ranFinally = 0 + let t = + runtimeTask { + try + ranInitial.Set() + do! Task.Yield() + do! stepOutside.WaitAsync() + ranNext.Set() + finally + ranFinally <- ranFinally + 1 + failtest "finally exn!" + } + require ranInitial.IsSet "didn't run initial" + require (not ranNext.IsSet) "ran next too early" + stepOutside.Release() |> ignore + try + t.Wait() + require false "shouldn't get here" + with + | _ -> () + require ranNext.IsSet "didn't run next" + require (ranFinally = 1) "didn't run finally exactly once" + +let knownFailing_test2ndExceptionThrownInFinally () = + for i in 1 .. 5 do + use ranInitial = new ManualResetEventSlim() + use continueTask = new SemaphoreSlim(0) + use ranNext = new ManualResetEventSlim() + let mutable ranFinally = 0 + let t = + runtimeTask { + try + ranInitial.Set() + do! continueTask.WaitAsync() + ranNext.Set() + do! Task.Yield() + failtest "uhoh" + finally + ranFinally <- ranFinally + 1 + failtest "2nd exn!" + } + ranInitial.Wait() + continueTask.Release() |> ignore + try + t.Wait() + require false "shouldn't get here" + with + | _ -> () + require ranNext.IsSet "didn't run next" + require (ranFinally = 1) "didn't run finally exactly once" + +let knownFailing_testTryFinallyOverReturnFromWithException () = + let inner() = + runtimeTask { + do! Task.Yield() + failtest "inner" + return 1 + } + let mutable m = 0 + let t = + runtimeTask { + try + do! Task.Yield() + return! inner() + finally + m <- 1 + } + try + t.Wait() + with + | :? AggregateException -> () + require (m = 1) "didn't run finally" + +let knownFailing_testTryFinallyOverReturnFromWithoutException () = + let inner() = + runtimeTask { + do! Task.Yield() + return 1 + } + let mutable m = 0 + let t = + runtimeTask { + try + do! Task.Yield() + return! inner() + finally + m <- 1 + } + try + t.Wait() + with + | :? AggregateException -> () + require (m = 1) "didn't run finally" + +// A minimal custom awaitable, exercising the SRTP Bind/ReturnFrom/MergeSources +// fallbacks (task {} supports arbitrary task-likes the same way). +type CustomAwaitable(result: int) = + member _.GetAwaiter() = (Task.FromResult result).GetAwaiter() + +let testCustomAwaitable () = + let t = + runtimeTask { + let! x = CustomAwaitable 20 + let! y = CustomAwaitable 20 + return x + y + } + require (t.Result = 40) "custom awaitable bind" + + let t2 = + runtimeTask { + return! CustomAwaitable 42 + } + require (t2.Result = 42) "custom awaitable return from" + + let t3 = + runtimeTask { + let! x = CustomAwaitable 20 + and! y = CustomAwaitable 22 + return x + y + } + require (t3.Result = 42) "custom awaitable merge sources" + +let knownFailing_testTaskUsesSyncContext () = // task completes without the body observably running when a SynchronizationContext is installed + for i in 1 .. 5 do + let mutable ran = false + let mutable posted = false + let oldSyncContext = SynchronizationContext.Current + let syncContext = { new SynchronizationContext() with member _.Post(d,state) = posted <- true; d.Invoke(state) } + try + SynchronizationContext.SetSynchronizationContext syncContext + let tid = System.Threading.Thread.CurrentThread.ManagedThreadId + require (not (isNull SynchronizationContext.Current)) "need sync context non null on foreground thread A" + require (SynchronizationContext.Current = syncContext) "need sync context known on foreground thread A" + let t = + runtimeTask { + let tid2 = System.Threading.Thread.CurrentThread.ManagedThreadId + require (not (isNull SynchronizationContext.Current)) "need sync context non null on foreground thread B" + require (SynchronizationContext.Current = syncContext) "need sync context known on foreground thread B" + do! Task.Yield() + require (not (isNull SynchronizationContext.Current)) "need sync context non null on foreground thread C" + require (SynchronizationContext.Current = syncContext) "need sync context known on foreground thread C" + ran <- true + } + t.Wait() + require ran "never ran" + require posted "never posted" + finally + SynchronizationContext.SetSynchronizationContext oldSyncContext + +[] +let main _ = + tinyTask() + tbind() + tnested() + tcatch0() + tcatch1() + t3() + t3b() + t3c() + t67() + t68() + testCompileAsyncWhileLoop() + merge2tasks() + merge3tasks() + mergeYieldAndTask() + mergeTaskAndYield() + merge2valueTasks() + merge2valueTasksAndYield() + mergeYieldAnd2tasks() + merge2tasksAndValueTask() + merge2asyncs() + merge3asyncs() + mergeYieldAndAsync() + mergeAsyncAndYield() + mergeYieldAnd2asyncs() + merge2asyncsAndValueTask() + testShortCircuitResult() + testDelay() + testNonBlocking() + testWhileLoopSync() + testWhileLoopAsyncZeroIteration() + testWhileLoopAsyncOneIteration() + testWhileLoopAsync() + testForLoopA() + testForLoopComplex() + testForLoopSadPath() + testFixedStackWhileLoop() + testTypeInference() + testNoStackOverflowWithImmediateResult() + testNoStackOverflowWithYieldResult() + testSmallTailRecursion() + testTryOverReturnFrom() + testAsyncsMixedWithTasks() + testAsyncsMixedWithTasks_ShouldNotSwitchContext() + testCustomAwaitable() + testUsingAsyncDisposableSync() + 0 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs new file mode 100644 index 00000000000..61feac5e73d --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs @@ -0,0 +1,25 @@ +// Minimal repro: suspending with AsyncHelpers.Await inside the *handler* of an +// exception-handling region of a __runtimeAsync method. This is what `use` on an +// IAsyncDisposable lowers to (the DisposeAsync await sits in the finally). +// +// Today this compiles cleanly but terminates the process at execution +// (0xC0000409), so the component test compiles this file without running it. +// Awaiting in the try *body* with a plain finally works; awaiting inside the +// finally itself does not. +module RuntimeAsyncAwaitInExceptionRegion + +open System.Runtime.CompilerServices +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let run () : Task = + StateMachineHelpers.__runtimeAsync ( + try + 1 + finally + AsyncHelpers.Await(Task.Delay(1)) + ) + +[] +let main _ = + if (run ()).GetAwaiter().GetResult() = 1 then 0 else 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs new file mode 100644 index 00000000000..6aec6ffaec2 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -0,0 +1,178 @@ +module Language.RuntimeAsyncTests + +open Xunit +open FSharp.Test.Compiler +open System.IO + +let private runtimeAsyncSource = """ +module RuntimeAsyncTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +let add (x: int) (y: int) : Task = + StateMachineHelpers.__runtimeAsync ( + AsyncHelpers.Await(Task.Delay(1)) + x + y) + +let rawBody () : Task = + StateMachineHelpers.__runtimeAsync 1 + +type Calculator() = + member _.Add(x: int, y: int) : Task = + StateMachineHelpers.__runtimeAsync ( + AsyncHelpers.Await(Task.Delay(1)) + x + y) + + member _.AddRaw(x: int) : Task = + StateMachineHelpers.__runtimeAsync (x + 1) +""" + +let private runtimeAsyncRawSource = """ +module RuntimeAsyncRawTest + +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices +open System.Runtime.CompilerServices + +type RuntimeTaskBuilder() = + member inline _.Delay([] generator: unit -> 'T) = + generator + + member inline _.Run([] code: unit -> 'T) : Task<'T> = + StateMachineHelpers.__runtimeAsync (code()) + + member inline _.Zero() = () + + member inline _.Return(value: 'T) = value + + member inline _.Bind(task: Task, [] continuation: unit -> 'U) = + AsyncHelpers.Await task + continuation() + + member inline _.Combine( + [] first: unit -> unit, + [] second: unit -> 'T + ) = + first() + second() + +[] +module RuntimeTask = + let runtimeTask = RuntimeTaskBuilder() + +type ICalculator = + abstract Combined: unit -> Task + +type Calculator() = + member _.Combined() : Task = + runtimeTask { + do! Task.Delay(1) + do! Task.Delay(1) + return 42 + } + + interface ICalculator with + member this.Combined() = this.Combined() + +""" + +[] +let ``runtime async requires preview language version`` () = + FSharp """ +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let f : Task = + StateMachineHelpers.__runtimeAsync 1 +""" + |> typecheck + |> shouldFail + |> withErrorCode 3350 + +[] +let ``runtime async rejects non Task result carriers`` () = + FSharp """ +open Microsoft.FSharp.Core.CompilerServices + +let f : string = + StateMachineHelpers.__runtimeAsync "result" +""" + |> withLangVersionPreview + |> typecheck + |> shouldFail + |> withErrorCode 1 + +[] +let ``runtime async intrinsic does not capture user-defined same-named values`` () = + FSharp """ +let __runtimeAsync value = value +let result = __runtimeAsync 1 +""" + |> typecheck + |> shouldSucceed + +#if NETCOREAPP +[] +let ``runtime async compiles functions and members`` () = + FSharp runtimeAsyncSource + |> withLangVersionPreview + |> compile + |> shouldSucceed + +[] +let ``runtime async combines awaited chunks without delegates`` () = + FSharp runtimeAsyncRawSource + |> withLangVersionPreview + |> compile + |> verifyILContains [ + "Task::Delay(int32)" + "AsyncHelpers::Await(class [runtime]System.Threading.Tasks.Task)" + ] + |> shouldSucceed + +[] +let ``runtime task builder fixture executes through runtime async`` () = + FsFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTaskBuilder.fs")) + |> withAdditionalSourceFile ( + SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasks.fs")) + ) + |> withLangVersionPreview + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async direct intrinsic fixture executes`` () = + Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncBasic.fs") + |> FsFromPath + |> withLangVersionPreview + |> compileExeAndRun + |> shouldSucceed + +[] +// Minimal repro: awaiting inside an exception-handling region. Compilation +// succeeds, but executing the fixture currently terminates the process with +// 0xC0000409 (suspension in EH regions is forbidden by the runtime contract). +let ``runtime async suspension in exception region compiles (runtime execution is failing)`` () = + Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasksAsyncDisposalException.fs") + |> FsFromPath + |> withLangVersionPreview + |> compileExeAndRun + |> shouldSucceed + +#else +[] +let ``runtime async reports unsupported target runtime`` () = + FSharp """ +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let f : Task = + StateMachineHelpers.__runtimeAsync 1 +""" + |> withLangVersionPreview + |> typecheck + |> shouldFail + |> withErrorCode 3351 +#endif From f9bb48341c9948f831b25de6e93e99f3fe12f4fb Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 08:41:34 +0200 Subject: [PATCH 04/59] surface area --- .../FSharp.Core.SurfaceArea.netstandard21.release.bsl | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl index ed913ea04d3..411ac2e63e0 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl @@ -964,6 +964,7 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsync[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName From dfe4109390e728b75a64ea215663c78050738a0a Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 08:41:58 +0200 Subject: [PATCH 05/59] rns --- docs/release-notes/.FSharp.Compiler.Service/11.0.100.md | 1 + docs/release-notes/.FSharp.Core/11.0.100.md | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md index 0f816258bbf..2b7f464b9e4 100644 --- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md +++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md @@ -137,6 +137,7 @@ * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289)) * Symbols: add ObsoleteDiagnosticInfo ([PR #19359](https://github.com/dotnet/fsharp/pull/19359)) * FCS: add FSharpCheckFileResults.HasErrors ([PR #19892](https://github.com/dotnet/fsharp/pull/19892)) +* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsync` intrinsic, including carrier validation and target-runtime capability checks. * Add `#version;;` directive to F# Interactive to display version and environment information. ([Issue #13307](https://github.com/dotnet/fsharp/issues/13307), [PR #19332](https://github.com/dotnet/fsharp/pull/19332)) * Add diagnostic FS3889 when a namespace and a type have the same fully-qualified name in the same assembly, replacing the misleading FS0247 "namespace and a module" error. ([Issue #17827](https://github.com/dotnet/fsharp/issues/17827), [PR #19802](https://github.com/dotnet/fsharp/pull/19802)) * Debug: rework for expressions stepping ([PR #19894](https://github.com/dotnet/fsharp/pull/19894)) diff --git a/docs/release-notes/.FSharp.Core/11.0.100.md b/docs/release-notes/.FSharp.Core/11.0.100.md index 3349ac75260..1941c8e9f6f 100644 --- a/docs/release-notes/.FSharp.Core/11.0.100.md +++ b/docs/release-notes/.FSharp.Core/11.0.100.md @@ -4,3 +4,7 @@ * Fix `Array.exists2` documentation examples to use equal-length arrays; the previous examples would throw `ArgumentException` at runtime instead of returning the documented `false`/`true` values. ([PR #19672](https://github.com/dotnet/fsharp/pull/19672)) * Move `Async.StartChild` to the "Starting Async Computations" docs category alongside `Async.StartChildAsTask`. ([Issue #19667](https://github.com/dotnet/fsharp/issues/19667)) * Add `InlineIfLambda` to `Array.init` ([PR #19869](https://github.com/dotnet/fsharp/pull/19869)) + +### Added + +* Add the compiler-recognized `StateMachineHelpers.__runtimeAsync` intrinsic for .NET runtime-async methods. From e4eb267327f51483c2034336f676efed6144877e Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 09:33:16 +0200 Subject: [PATCH 06/59] translations --- src/Compiler/xlf/FSComp.txt.cs.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.de.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.es.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.fr.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.it.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.ja.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.ko.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.pl.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.pt-BR.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.ru.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.tr.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.zh-Hans.xlf | 5 +++++ src/Compiler/xlf/FSComp.txt.zh-Hant.xlf | 5 +++++ 13 files changed, 65 insertions(+) diff --git a/src/Compiler/xlf/FSComp.txt.cs.xlf b/src/Compiler/xlf/FSComp.txt.cs.xlf index afb00396c5d..82911a6b995 100644 --- a/src/Compiler/xlf/FSComp.txt.cs.xlf +++ b/src/Compiler/xlf/FSComp.txt.cs.xlf @@ -652,6 +652,11 @@ Sdílení podkladových polí v rozlišeném sjednocení [<Struct>] za předpokladu, že mají stejný název a typ + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.de.xlf b/src/Compiler/xlf/FSComp.txt.de.xlf index 222cab682fd..4b5118178fc 100644 --- a/src/Compiler/xlf/FSComp.txt.de.xlf +++ b/src/Compiler/xlf/FSComp.txt.de.xlf @@ -652,6 +652,11 @@ Teilen sie zugrunde liegende Felder in einen [<Struct>]-diskriminierten Union, solange sie denselben Namen und Typ aufweisen. + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.es.xlf b/src/Compiler/xlf/FSComp.txt.es.xlf index d3cbfab11f1..17a49aefae0 100644 --- a/src/Compiler/xlf/FSComp.txt.es.xlf +++ b/src/Compiler/xlf/FSComp.txt.es.xlf @@ -652,6 +652,11 @@ Compartir campos subyacentes en una unión discriminada [<Struct>] siempre y cuando tengan el mismo nombre y tipo + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.fr.xlf b/src/Compiler/xlf/FSComp.txt.fr.xlf index 59712f7a2f5..d3e097f1da1 100644 --- a/src/Compiler/xlf/FSComp.txt.fr.xlf +++ b/src/Compiler/xlf/FSComp.txt.fr.xlf @@ -652,6 +652,11 @@ Partager les champs sous-jacents dans une union discriminée [<Struct>] tant qu’ils ont le même nom et le même type + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.it.xlf b/src/Compiler/xlf/FSComp.txt.it.xlf index 92de61c5737..df2d64bbedf 100644 --- a/src/Compiler/xlf/FSComp.txt.it.xlf +++ b/src/Compiler/xlf/FSComp.txt.it.xlf @@ -652,6 +652,11 @@ Condividi i campi sottostanti in un'unione discriminata di [<Struct>] purché abbiano lo stesso nome e tipo + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.ja.xlf b/src/Compiler/xlf/FSComp.txt.ja.xlf index b4f048784cb..8c2537747a0 100644 --- a/src/Compiler/xlf/FSComp.txt.ja.xlf +++ b/src/Compiler/xlf/FSComp.txt.ja.xlf @@ -652,6 +652,11 @@ 名前と型が同じである限り、[<Struct>] 判別可能な共用体で基になるフィールドを共有する + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.ko.xlf b/src/Compiler/xlf/FSComp.txt.ko.xlf index 9d12c1d82b0..4a14347838c 100644 --- a/src/Compiler/xlf/FSComp.txt.ko.xlf +++ b/src/Compiler/xlf/FSComp.txt.ko.xlf @@ -652,6 +652,11 @@ 이름과 형식이 같으면 [<Struct>] 구분된 공용 구조체에서 기본 필드 공유 + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.pl.xlf b/src/Compiler/xlf/FSComp.txt.pl.xlf index 4ecb28aa71f..d099556e076 100644 --- a/src/Compiler/xlf/FSComp.txt.pl.xlf +++ b/src/Compiler/xlf/FSComp.txt.pl.xlf @@ -652,6 +652,11 @@ Udostępnij pola źródłowe w unii rozłącznej [<Struct>], o ile mają taką samą nazwę i ten sam typ + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf index 736ab22b139..921a3f062e5 100644 --- a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf +++ b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf @@ -652,6 +652,11 @@ Compartilhar campos subjacentes em uma união discriminada [<Struct>], desde que tenham o mesmo nome e tipo + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.ru.xlf b/src/Compiler/xlf/FSComp.txt.ru.xlf index 170bcfc7385..50d8ade7920 100644 --- a/src/Compiler/xlf/FSComp.txt.ru.xlf +++ b/src/Compiler/xlf/FSComp.txt.ru.xlf @@ -652,6 +652,11 @@ Совместное использование базовых полей в дискриминируемом объединении [<Struct>], если они имеют одинаковое имя и тип. + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.tr.xlf b/src/Compiler/xlf/FSComp.txt.tr.xlf index 5595108617e..750c6cc3c31 100644 --- a/src/Compiler/xlf/FSComp.txt.tr.xlf +++ b/src/Compiler/xlf/FSComp.txt.tr.xlf @@ -652,6 +652,11 @@ Aynı ada ve türe sahip oldukları sürece temel alınan alanları [<Struct>] ayırt edici birleşim biçiminde paylaşın + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf index c020d652bf0..e99c8a1a981 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf @@ -652,6 +652,11 @@ 只要它们具有相同的名称和类型，即可在 [<Struct>] 中共享基础字段 + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf index 8ed6744afb6..7af11175f44 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf @@ -652,6 +652,11 @@ 只要 [<Struct>] 具有相同名稱和類型，就以強制聯集共用基礎欄位 + + runtime async + runtime async + + Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules From 38578d48e98e9ea7e9986f904b3e843de72a85b3 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 09:39:51 +0200 Subject: [PATCH 07/59] add pr numbers --- docs/release-notes/.FSharp.Compiler.Service/11.0.100.md | 2 +- docs/release-notes/.FSharp.Core/11.0.100.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md index 68421f83ba8..da68192887f 100644 --- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md +++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md @@ -138,7 +138,7 @@ * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289)) * Symbols: add ObsoleteDiagnosticInfo ([PR #19359](https://github.com/dotnet/fsharp/pull/19359)) * FCS: add FSharpCheckFileResults.HasErrors ([PR #19892](https://github.com/dotnet/fsharp/pull/19892)) -* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsync` intrinsic, including carrier validation and target-runtime capability checks. +* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsync` intrinsic, including carrier validation and target-runtime capability checks. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * Add `#version;;` directive to F# Interactive to display version and environment information. ([Issue #13307](https://github.com/dotnet/fsharp/issues/13307), [PR #19332](https://github.com/dotnet/fsharp/pull/19332)) * Add diagnostic FS3889 when a namespace and a type have the same fully-qualified name in the same assembly, replacing the misleading FS0247 "namespace and a module" error. ([Issue #17827](https://github.com/dotnet/fsharp/issues/17827), [PR #19802](https://github.com/dotnet/fsharp/pull/19802)) * Debug: rework for expressions stepping ([PR #19894](https://github.com/dotnet/fsharp/pull/19894)) diff --git a/docs/release-notes/.FSharp.Core/11.0.100.md b/docs/release-notes/.FSharp.Core/11.0.100.md index 2a17638c4d7..b873296b18b 100644 --- a/docs/release-notes/.FSharp.Core/11.0.100.md +++ b/docs/release-notes/.FSharp.Core/11.0.100.md @@ -7,5 +7,5 @@ ### Added -* Add the compiler-recognized `StateMachineHelpers.__runtimeAsync` intrinsic for .NET runtime-async methods. +* Add the compiler-recognized `StateMachineHelpers.__runtimeAsync` intrinsic for .NET runtime-async methods. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * `Async.RunSynchronouslyImmediate`: runs work on the calling thread until the first asynchronous suspension (as opposed to `RunSynchronously`, which immediately offloads if not on a background and/or threadpool thread). ([Issue #1042](https://github.com/fsharp/fslang-suggestions/issues/1042), [PR #19804](https://github.com/dotnet/fsharp/pull/19804)) From caaad4d4b08d3b0c5a31f1096ac88934f40785e2 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 10:41:40 +0200 Subject: [PATCH 08/59] Restore F# 11.0 feature registrations dropped when adding RuntimeAsync; add Language preview release notes The features dictionary lost ImplicitDIMCoverage, MethodOverloadsCache, ErrorOnMissingSignatureAttribute, DirectDelegateConstruction, AccessProtectedBaseFieldFromClosure and RecordSpreads entries, causing 54 CI test failures ('Unable to find feature' internal errors and preview features not enabled). Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- docs/release-notes/.Language/preview.md | 1 + src/Compiler/Facilities/LanguageFeatures.fs | 8 +++++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/release-notes/.Language/preview.md b/docs/release-notes/.Language/preview.md index 41ffd8cf6fb..1513c19bceb 100644 --- a/docs/release-notes/.Language/preview.md +++ b/docs/release-notes/.Language/preview.md @@ -1,5 +1,6 @@ ### Added +* Runtime async: `task`/`async`-style computation expressions can be compiled to use the .NET runtime async support (RuntimeAsync preview feature). ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * Allow constructing a record via its all-fields constructor, e.g. `MyRecord(a, b)`, with positional or named arguments (`RecordConstructorSyntax` preview feature). Accessibility matches `{ ... }` construction. ([Suggestion #722](https://github.com/fsharp/fslang-suggestions/issues/722), [RFC FS-1073](https://github.com/fsharp/fslang-design/blob/main/RFCs/FS-1073-record-constructors.md), [PR #19974](https://github.com/dotnet/fsharp/pull/19974)) ### Fixed diff --git a/src/Compiler/Facilities/LanguageFeatures.fs b/src/Compiler/Facilities/LanguageFeatures.fs index 28b2dd18b01..4074659eaf5 100644 --- a/src/Compiler/Facilities/LanguageFeatures.fs +++ b/src/Compiler/Facilities/LanguageFeatures.fs @@ -255,12 +255,18 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) LanguageFeature.ExceptionFieldSerializationSupport, languageVersion110 LanguageFeature.NotNullIfNotNull, languageVersion110 LanguageFeature.ImprovedImpliedArgumentNamesPartTwo, languageVersion110 - LanguageFeature.RuntimeAsync, previewVersion + LanguageFeature.ImplicitDIMCoverage, languageVersion110 + LanguageFeature.MethodOverloadsCache, languageVersion110 // Performance optimization for overload resolution + LanguageFeature.ErrorOnMissingSignatureAttribute, languageVersion110 // Turn FS3888 from warning into error + LanguageFeature.DirectDelegateConstruction, languageVersion110 + LanguageFeature.AccessProtectedBaseFieldFromClosure, languageVersion110 // #5302: read a protected base field from a closure + LanguageFeature.RecordSpreads, languageVersion110 // Difference between languageVersion110 and preview - 11.0 gets turned on automatically by picking a preview .NET 11 SDK // previewVersion is only when "preview" is specified explicitly in project files and users also need a preview SDK // F# preview + LanguageFeature.RuntimeAsync, previewVersion LanguageFeature.RecordConstructorSyntax, previewVersion // Allow constructing a record via its all-fields constructor, e.g. MyRecord(a, b) // Unfinished features that still need work before they can be assigned a release language version. From 48d1691df6714a316679df84b0e55df2df1b3c0c Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 8 Aug 2026 13:02:34 +0200 Subject: [PATCH 09/59] surface area --- .../FSharp.Core.SurfaceArea.netstandard20.release.bsl | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl index 6d29205d290..975302eea93 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl @@ -603,8 +603,8 @@ Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1 Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]]) Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) -Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T1],Microsoft.FSharp.Collections.FSharpSet`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState) @@ -671,8 +671,8 @@ Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_Def Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]]) -Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken() Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) @@ -961,6 +961,7 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsync[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) From 19619433a1d9a428e6592260c4ddae117a84a83c Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Thu, 13 Aug 2026 13:11:59 +0200 Subject: [PATCH 10/59] test: runtime-async edge-case suite (runtime behavior + emitted IL) Roslyn-async2-inspired edge cases for the runtime-async intrinsic, driven through the test-only runtimeTask CE (treated as a hypothetical library): * execution fixture (RuntimeAsync/RuntimeAsyncEdgeCases.fs): locals/loops across suspension, non-ref struct across suspension, ValueTask operand, exception propagation, IAsyncDisposable with genuinely-async DisposeAsync. * facts (RuntimeAsyncEdgeCaseTests.fs): Await overload selection per operand type, no compiler state machine (direct + CE), the C1 forbidden `tail.` prefix, and a parametrized set of currently-undiagnosed contract-forbidden patterns (await-in-finally/catch, ref-struct- and byref-across-suspension). Every asserted IL substring and runtime symptom was captured empirically on the pinned net11 preview; the forbidden patterns match docs/runtime-async.md. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 55dd72c8-46d3-4959-9677-c52d41779596 --- .../FSharp.Compiler.ComponentTests.fsproj | 1 + .../RuntimeAsync/ComposedRuntimeAsync.bsl | 114 ++++ .../RuntimeAsync/RuntimeAsyncEdgeCases.fs | 101 ++++ .../Language/RuntimeAsyncEdgeCaseTests.fs | 552 ++++++++++++++++++ 4 files changed, 768 insertions(+) create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs diff --git a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj index c985996247e..81ce6465df8 100644 --- a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj +++ b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj @@ -391,6 +391,7 @@ + diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl new file mode 100644 index 00000000000..9085a4e1425 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl @@ -0,0 +1,114 @@ +module M +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +let helper x = x * 2 + +let outer (n: int) : Task = + let inner y = y + helper n + let baseline = inner 10 + StateMachineHelpers.__runtimeAsync ( + let mutable total = baseline + for i in 1 .. n do + let d = AsyncHelpers.Await(Task.FromResult i) + total <- total + d + AsyncHelpers.Await(Task.Delay 1) + if total > 0 then total else -1) +-------------------------------------------------------------------------------- + +M::helper + (7,16-7,21) x * 2 + IL_0000: ldarg.0 + IL_0001: ldc.i4.2 + IL_0002: mul + IL_0003: ret + +M::outer + + IL_0000: ldarg.0 + IL_0001: newobj inner@10::.ctor + IL_0006: stloc.0 + + (11,5-11,28) let baseline = inner 10 + IL_0007: ldloc.0 + IL_0008: ldc.i4.s 10 + IL_000a: callvirt Invoke + IL_000f: stloc.1 + + (12,5-18,41) StateMachineHelpers.__runtimeAsync ( let mutable total = baseline for i in 1 .. n do let d = AsyncHelpers.Await(Task.FromResult i) total <- total + d AsyncHelpers.Await(Task.Delay 1) if total > 0 then total else -1) + IL_0010: ldarg.0 + IL_0011: ldloc.1 + IL_0012: newobj outer@12::.ctor + IL_0017: ldnull + IL_0018: tail. + IL_001a: callvirt Invoke + IL_001f: ret + +inner@10::Invoke + (10,19-10,31) y + helper n + IL_0000: ldarg.1 + IL_0001: ldarg.0 + IL_0002: ldfld inner@10::n + IL_0007: call M::helper + IL_000c: add + IL_000d: ret + +outer@12::Invoke + (13,9-13,37) let mutable total = baseline + IL_0000: ldarg.0 + IL_0001: ldfld outer@12::baseline + IL_0006: stloc.0 + + (14,9-14,12) for + IL_0007: ldc.i4.1 + IL_0008: stloc.2 + IL_0009: ldarg.0 + IL_000a: ldfld outer@12::n + IL_000f: stloc.1 + IL_0010: ldloc.1 + IL_0011: ldloc.2 + IL_0012: blt.s IL_002e + + (15,13-15,58) let d = AsyncHelpers.Await(Task.FromResult i) + IL_0014: ldloc.2 + IL_0015: call Task::FromResult + IL_001a: call AsyncHelpers::Await + IL_001f: stloc.3 + + (16,13-16,31) total <- total + d + IL_0020: ldloc.0 + IL_0021: ldloc.3 + IL_0022: add + IL_0023: stloc.0 + + + IL_0024: ldloc.2 + IL_0025: ldc.i4.1 + IL_0026: add + IL_0027: stloc.2 + + (14,15-14,17) in + IL_0028: ldloc.2 + IL_0029: ldloc.1 + IL_002a: ldc.i4.1 + IL_002b: add + IL_002c: bne.un.s IL_0014 + + (17,9-17,41) AsyncHelpers.Await(Task.Delay 1) + IL_002e: ldc.i4.1 + IL_002f: call Task::Delay + IL_0034: call AsyncHelpers::Await + + (18,9-18,26) if total > 0 then + IL_0039: ldloc.0 + IL_003a: ldc.i4.0 + IL_003b: ble.s IL_003f + + (18,27-18,32) total + IL_003d: ldloc.0 + IL_003e: ret + + (18,38-18,40) -1 + IL_003f: ldc.i4.m1 + IL_0040: ret diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs new file mode 100644 index 00000000000..c1efa0c48f7 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs @@ -0,0 +1,101 @@ +// Runtime-behavior edge cases for runtime-async, exercised through the runtimeTask CE builder +// (RuntimeTaskBuilder.fs, treated here as a hypothetical library). Verified to run green on the +// pinned net11 preview runtime. Referenced from RuntimeAsyncEdgeCaseTests.fs via compileExeAndRun. +module RuntimeAsyncEdgeCases + +open System +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices +open RuntimeTaskBuilder.RuntimeTask + +let private delayed v = Task.Delay(1).ContinueWith(fun (_: Task) -> v) +let private resultOf (t: Task<'T>) = t.GetAwaiter().GetResult() + +// locals: a normal local is hoisted by the JIT and preserved across a suspension. +let normalLocalAcross () : Task = + runtimeTask { + let captured = 40 + let! delta = delayed 2 + return captured + delta + } + +// loops: await inside both a while body and a for body; results checked separately. +let loopsAcrossAwait () : Task = + runtimeTask { + let mutable whileAcc = 0 + let mutable i = 0 + while i < 3 do + let! x = delayed 1 + whileAcc <- whileAcc + x + i <- i + 1 + let mutable forAcc = 0 + for x in [ 1; 2; 3 ] do + let! y = delayed x + forAcc <- forAcc + y + return (whileAcc, forAcc) + } + +// a non-ref (readonly) value struct is hoisted and keeps its fields across a suspension, unlike the +// ref-struct/ReadOnlySpan case which is contract-forbidden. +[] +type Pair = { A: int; B: int } + +let structAcross () : Task = + runtimeTask { + let p = { A = 20; B = 22 } + let! _ = delayed 0 + return p.A + p.B + } + +// operand: change a bound source from Task to ValueTask keeps working. +let awaitValueTask () : Task = + runtimeTask { + let! x = ValueTask(41) + return x + 1 + } + +// exception thrown after a suspension surfaces through the returned Task. +let exnAfterAwait () : Task = + runtimeTask { + let! _ = delayed 1 + return failwith "boom" + } + +// use on an IAsyncDisposable: the builder's Using hoists DisposeAsync out of the finally, +// so disposal (which suspends) never runs inside an EH region. DisposeAsync genuinely suspends +// before recording the disposal, so a passing `sink = 1` proves the builder awaited it. +type AsyncProbe(sink: int ref) = + interface IAsyncDisposable with + member _.DisposeAsync() = + ValueTask(Task.Delay(1).ContinueWith(fun (_: Task) -> sink.Value <- 1)) + +let useAsyncDisposable (sink: int ref) : Task = + runtimeTask { + use _p = new AsyncProbe(sink) + let! x = delayed 7 + return x + } + +[] +let main _ = + let mutable failures = 0 + let check name cond = if not cond then eprintfn "FAILED: %s" name; failures <- failures + 1 + + check "normalLocalAcross" (resultOf (normalLocalAcross ()) = 42) + let (whileAcc, forAcc) = resultOf (loopsAcrossAwait ()) + check "awaitInWhile" (whileAcc = 3) + check "awaitInFor" (forAcc = 6) + check "structAcross" (resultOf (structAcross ()) = 42) + check "awaitValueTask" (resultOf (awaitValueTask ()) = 42) + + let threw = + try resultOf (exnAfterAwait ()) |> ignore; false + with _ -> true + check "exnAfterAwait propagates" threw + + let sink = ref 0 + check "useAsyncDisposable result" (resultOf (useAsyncDisposable sink) = 7) + check "useAsyncDisposable disposed" (sink.Value = 1) + + if failures = 0 then 0 else 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs new file mode 100644 index 00000000000..b30b366df34 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -0,0 +1,552 @@ +module Language.RuntimeAsyncEdgeCaseTests + +// Edge-case tests for runtime-async, inspired by the Roslyn async2 test surface (try/catch, +// try/finally, loops, Task vs ValueTask, ref-struct/ReadOnlySpan, disposal). Two halves: +// * Execution facts (runtime behavior) — driven through the runtimeTask CE builder, which is +// treated as a hypothetical library (RuntimeAsync/RuntimeTaskBuilder.fs). +// * EmittedIL facts — assert the runtime-async codegen contract so dotnet/runtime folks can be +// pointed at concrete IL. Every asserted substring was captured from the PR's own fsc on the +// pinned net11 preview and normalized the way ILChecker does ([System.Runtime] -> [runtime]). +// +// IL facts that assert the *absence* of a token use direct StateMachineHelpers.__runtimeAsync +// sources (single async method, clean assembly), because ILChecker's NotPresent check is +// assembly-scoped and the CE builder's own inline members legitimately contain `tail.`/`MoveNext`. +// The CE `Run` lowers `do!`/`let!` to exactly this intrinsic form (see the execution facts). +// +// The "undiagnosed forbidden pattern" facts below pin restrictions that docs/runtime-async.md +// records as known and currently NOT diagnosed by the F# compiler (tail./localloc forbidden; +// suspension forbidden inside EH regions; byref/byref-like locals not preservable across a +// suspension). They compile clean today; the comments record the observed runtime outcome. + +open Xunit +open FSharp.Test.Compiler +open System.IO +open System.Reflection.Metadata + +let private runtimeAsyncDir = Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync") +let private builderPath = Path.Combine(runtimeAsyncDir, "RuntimeTaskBuilder.fs") + +// Builds a minimal direct-intrinsic compilation unit: the module header plus the opens every +// StateMachineHelpers.__runtimeAsync body needs, then the supplied one-liner body. Used for the +// shape / absence / undiagnosed-pattern assertions, which must run on a single-method assembly. +let private directIntrinsicSource body = + String.concat "\n" [ + "module M" + "open System" + "open System.Threading.Tasks" + "open System.Runtime.CompilerServices" + "open Microsoft.FSharp.Core.CompilerServices" + body + ] + +let private compileDirect body = + FSharp(directIntrinsicSource body) |> withLangVersionPreview |> compile + +// ---- CE-builder sources (compiled against RuntimeTaskBuilder.fs, the hypothetical library) ------- + +// ref-struct-across-suspension written through the CE builder: the `do!` desugars to a continuation +// lambda that captures the span, so F#'s byref-capture check rejects it (FS0406). +let private refStructAcrossAwaitCE = """ +module M +open System +open System.Threading.Tasks +open RuntimeTaskBuilder.RuntimeTask +let f () : Task = + runtimeTask { + let data = [| 10; 20; 30 |] + let span = ReadOnlySpan(data) + do! Task.Delay(1) + return span[0] + span[1] + span[2] + } +""" + +let private ceStateMachineSource = """ +module CeUser +open System.Threading.Tasks +open RuntimeTaskBuilder.RuntimeTask +let f () : Task = + runtimeTask { + let! x = Task.FromResult 41 + return x + 1 + } +""" + +#if NETCOREAPP + +// ============================ execution (runtime behavior) ============================ + +[] +let ``runtime async edge cases execute through the CE builder`` () = + FsFromPath builderPath + |> withAdditionalSourceFile (SourceFromPath (Path.Combine(runtimeAsyncDir, "RuntimeAsyncEdgeCases.fs"))) + |> withLangVersionPreview + |> compileExeAndRun + |> shouldSucceed + +// ============================ emitted IL (codegen contract) ============================ +// +// Each fact below pins the *entire* method body in scope (not a single line): the normalized +// `.method { ... }` block captured from the PR's own fsc on the pinned net11 preview. This hands +// dotnet/runtime reviewers the exact lowering to check against docs/runtime-async.md. The blocks +// are deliberately brittle across SDK/codegen bumps — a codegen exhibit is supposed to change when +// the codegen changes. ILChecker.compareIL normalizes both sides identically ([System.Runtime] -> +// [runtime], collapses the multi-line `.method` signature, strips comments), so the verbatim +// ildasm text is what we assert. + +// `Await(Task); 1` — direct call to the non-generic Await overload, then push 1 and ret. +let private simpleAwaitBody = """ + .method public static class [System.Runtime]System.Threading.Tasks.Task`1 + f() cil managed noinlining + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: call class [System.Runtime]System.Threading.Tasks.Task [System.Runtime]System.Threading.Tasks.Task::Delay(int32) + IL_0006: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task) + IL_000b: ldc.i4.1 + IL_000c: ret + } // end of method M::f +""" + +// `let x = Await(Task) in x + 1` — the generic Await overload; result feeds directly +// into `add` with no spill local (optimized). +let private genericAwaitBody = """ + .method public static class [System.Runtime]System.Threading.Tasks.Task`1 + f(class [System.Runtime]System.Threading.Tasks.Task`1 t) cil managed noinlining + { + // Code size 9 (0x9) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call !!0 [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task`1) + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: ret + } // end of method M::f +""" + +// `Await(ValueTask); 1` — the ValueTask (non-generic) Await overload bound by operand type. +let private valueTaskAwaitBody = """ + .method public static class [System.Runtime]System.Threading.Tasks.Task`1 + f(valuetype [System.Runtime]System.Threading.Tasks.ValueTask vt) cil managed noinlining + { + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(valuetype [System.Runtime]System.Threading.Tasks.ValueTask) + IL_0006: ldc.i4.1 + IL_0007: ret + } // end of method M::f +""" + +// The operand's type selects the AsyncHelpers.Await overload; pinning the whole body (not just the +// call line) shows the surrounding shape a runtime reviewer needs (arg load, no spill, no builder). +[] +let ``ValueTask operand binds the non-generic Await (full body)`` () = + compileDirect "let f (vt: ValueTask) : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(vt); 1)" + |> verifyILContains [ valueTaskAwaitBody ] + |> shouldSucceed + +[] +let ``Task<'T> operand binds the generic Await (full body)`` () = + compileDirect "let f (t: Task) : Task = StateMachineHelpers.__runtimeAsync (let x = AsyncHelpers.Await(t) in x + 1)" + |> verifyILContains [ genericAwaitBody ] + |> shouldSucceed + +[] +let ``suspension lowers to the full Await body with no compiler state machine`` () = + compileDirect "let f () : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(Task.Delay(1)); 1)" + |> verifyILContains [ simpleAwaitBody ] + |> verifyILNotPresent [ + "AsyncTaskMethodBuilder" + "IAsyncStateMachine" + ] + +[] +// The runtimeTask CE lowers `let!`/`do!` to Await calls without a compiler-generated state machine +// (unlike the task { } builder). This ties the hypothetical library to the runtime-async contract. +let ``the CE builder lowers to Await with no state machine`` () = + FsFromPath builderPath + |> withAdditionalSourceFile (FsSource ceStateMachineSource) + |> withLangVersionPreview + |> compile + |> verifyILContains [ "AsyncHelpers::Await(class [runtime]System.Threading.Tasks.Task`1)" ] + |> verifyILNotPresent [ + "AsyncTaskMethodBuilder" + "IAsyncStateMachine" + ] + +// CONTRACT VIOLATION (finding C1): the tail-position function-value call is emitted with a `tail.` +// prefix (IL_000d) inside a runtime-async body. The runtime-async contract forbids `tail.`, and +// ilverify reports `TailRetType` on this exact method. Pinning the whole body makes the offending +// prefix unambiguous; once IlxGen.CanTailcall learns about runtime-async the `IL_000d: tail.` line +// must disappear and this expected body must be updated. +let private tailPrefixBody = """ + .method public static class [System.Runtime]System.Threading.Tasks.Task`1 + f(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2 g, + int32 x) cil managed noinlining + { + .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: call class [System.Runtime]System.Threading.Tasks.Task [System.Runtime]System.Threading.Tasks.Task::Delay(int32) + IL_0006: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task) + IL_000b: ldarg.0 + IL_000c: ldarg.1 + IL_000d: tail. + IL_000f: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2::Invoke(!0) + IL_0014: ret + } // end of method M::f +""" + +[] +let ``runtime async currently emits a forbidden tail prefix (C1)`` () = + compileDirect "let f (g: int -> int) (x: int) : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(Task.Delay(1)); g x)" + |> verifyILContains [ tailPrefixBody ] + |> shouldSucceed + +// ============== async impl-flag placement — F# source layout is not authoritative ============== +// +// The async marking is a *method* impl flag (MethodImplAttributes 0x2000, MethodImplOptions.Async; +// il.fs WithAsync), written into the emitted PE method header. It is NOT rendered by the ildasm we +// use, so it can only be checked from metadata — hence withMetadataReader rather than verifyIL. +// +// This is the composed / non-trivial case the trivial single-method exhibits above do not cover: a +// larger user function (`outer`) that has a nested local function (`inner`), non-async code before +// and after, and a runtimeTask CE that itself combines control flow (`for`, `let!`, `use`, +// `try/finally`, `do!`, `if`). The property being pinned: the 0x2000 flag lands on the emitted IL +// method that actually holds the async body (a compiler-generated closure the CE body is lifted +// into), and NOT on the enclosing `outer` just because the CE is written lexically inside it. +// +// Empirically on the pinned net11 preview (implAttrs, async = 0x2000 bit): +// M::helper 0x0000 async=false +// M::outer 0x0000 async=false <- encloses the CE, but is NOT the async method +// outer@NN::Invoke 0x2008 async=true <- lifted async body carries the flag (+noinlining) +// RuntimeTaskBuilder::Run 0x2008 async=true (the intrinsic-bodied inline builder member) +let private composedLayoutProgram = """ +module M +open System +open System.Threading.Tasks +open RuntimeTaskBuilder.RuntimeTask + +let helper x = x * 2 + +let outer (n: int) : Task = + let inner y = y + helper n // nested, non-async local function + let baseline = inner 10 // non-async code BEFORE the async part + let work : Task = + runtimeTask { + let mutable total = baseline + for i in 1 .. n do + let! d = Task.FromResult i + total <- total + d + use _ = { new IDisposable with member _.Dispose() = () } + try + do! Task.Delay 1 + total <- total + 1 + finally + total <- total + 100 + if total > 0 then return total else return -1 + } + work // non-async code AFTER the async part +""" + +// Full emitted IL of the composed program, so dotnet/runtime reviewers can read the exact lowering. +// +// (1) `M::outer` -- the *enclosing* user function. It is a plain, non-async method: it runs the +// pre-async code (`baseline = inner 10`, i.e. `10 + helper n`) inline, constructs the closure that +// holds the async body, and tail-calls its `Invoke`. It returns `Task` but carries NO async +// impl flag -- proof that the async marking follows the emitted async method, not the F# function the +// CE is lexically written in. (It is even allowed `tail.` here precisely because it is not async.) +let private composedOuterBody = """ + .method public static class [System.Runtime]System.Threading.Tasks.Task`1 + outer(int32 n) cil managed + { + // Code size 23 (0x17) + .maxstack 5 + .locals init (int32 V_0) + IL_0000: ldc.i4.s 10 + IL_0002: ldarg.0 + IL_0003: ldc.i4.2 + IL_0004: mul + IL_0005: add + IL_0006: stloc.0 + IL_0007: ldarg.0 + IL_0008: ldloc.0 + IL_0009: newobj instance void M/outer@13::.ctor(int32, + int32) + IL_000e: ldnull + IL_000f: tail. + IL_0011: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2>::Invoke(!0) + IL_0016: ret + } // end of method M::outer +""" + +// (2) `outer@13::Invoke` -- the compiler-generated closure the CE body is lifted into: THIS is the +// runtime-async method (the one carrying MethodImplAttributes.Async, checked via metadata below). +// Its body is the full composed lowering the runtime must honour: +// * a `for` loop (blt.s / bne.un.s) around a suspension, +// * `AsyncHelpers::Await(Task)` -- the generic await intrinsic (the `let!`), +// * a try/finally where `do!` suspends via `AsyncHelpers::Await(Task)` INSIDE the try while the +// finally does only arithmetic (no await in a finally region -- that is forbidden), +// * the `use` disposal lowered as isinst IAsyncDisposable -> DisposeAsync(); Await(ValueTask), +// else isinst IDisposable -> Dispose(), emitted in straight-line code AFTER the protected region +// (the builder hoists the awaited DisposeAsync out of the finally, by design), and +// * the final `if total > 0 then ... else -1`. +let private composedAsyncClosureBody = """ + .method public strict virtual instance class [System.Runtime]System.Threading.Tasks.Task`1 + Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unit) cil managed noinlining + { + // Code size 231 (0xe7) + .maxstack 7 + .locals init (int32 V_0, + int32 V_1, + int32 V_2, + class [System.Runtime]System.Threading.Tasks.Task`1 V_3, + int32 V_4, + class [System.Runtime]System.IDisposable V_5, + class [System.Runtime]System.Exception V_6, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 V_7, + class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 V_8, + class [System.Runtime]System.Threading.Tasks.Task V_9, + class [System.Runtime]System.Exception V_10, + object V_11, + class [System.Runtime]System.IAsyncDisposable V_12, + class [System.Runtime]System.IAsyncDisposable V_13, + class [System.Runtime]System.IDisposable V_14, + class [System.Runtime]System.IDisposable V_15) + IL_0000: ldarg.0 + IL_0001: ldfld int32 M/outer@13::baseline + IL_0006: stloc.0 + IL_0007: ldc.i4.1 + IL_0008: stloc.2 + IL_0009: ldarg.0 + IL_000a: ldfld int32 M/outer@13::n + IL_000f: stloc.1 + IL_0010: ldloc.1 + IL_0011: ldloc.2 + IL_0012: blt.s IL_0032 + + IL_0014: ldloc.2 + IL_0015: call class [System.Runtime]System.Threading.Tasks.Task`1 [System.Runtime]System.Threading.Tasks.Task::FromResult(!!0) + IL_001a: stloc.3 + IL_001b: ldloc.3 + IL_001c: call !!0 [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task`1) + IL_0021: stloc.s V_4 + IL_0023: ldloc.0 + IL_0024: ldloc.s V_4 + IL_0026: add + IL_0027: stloc.0 + IL_0028: ldloc.2 + IL_0029: ldc.i4.1 + IL_002a: add + IL_002b: stloc.2 + IL_002c: ldloc.2 + IL_002d: ldloc.1 + IL_002e: ldc.i4.1 + IL_002f: add + IL_0030: bne.un.s IL_0014 + + IL_0032: newobj instance void M/'outer@18-1'::.ctor() + IL_0037: stloc.s V_5 + .try + { + .try + { + IL_0039: ldc.i4.1 + IL_003a: call class [System.Runtime]System.Threading.Tasks.Task [System.Runtime]System.Threading.Tasks.Task::Delay(int32) + IL_003f: stloc.s V_9 + IL_0041: ldloc.s V_9 + IL_0043: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task) + IL_0048: ldloc.0 + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: stloc.0 + IL_004c: leave.s IL_0054 + + } // end .try + finally + { + IL_004e: ldloc.0 + IL_004f: ldc.i4.s 100 + IL_0051: add + IL_0052: stloc.0 + IL_0053: endfinally + } // end handler + IL_0054: ldloc.0 + IL_0055: ldc.i4.0 + IL_0056: ble.s IL_005b + + IL_0058: ldloc.0 + IL_0059: br.s IL_005c + + IL_005b: ldc.i4.m1 + IL_005c: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2::NewChoice1Of2(!0) + IL_0061: stloc.s V_8 + IL_0063: leave.s IL_007a + + } // end .try + catch [mscorlib]System.Object + { + IL_0065: castclass [System.Runtime]System.Exception + IL_006a: stloc.s V_10 + IL_006c: ldloc.s V_10 + IL_006e: stloc.s V_6 + IL_0070: ldnull + IL_0071: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2::NewChoice2Of2(!1) + IL_0076: stloc.s V_8 + IL_0078: leave.s IL_007a + + } // end handler + IL_007a: ldloc.s V_8 + IL_007c: stloc.s V_7 + IL_007e: ldloc.s V_5 + IL_0080: box [System.Runtime]System.IDisposable + IL_0085: stloc.s V_11 + IL_0087: ldloc.s V_11 + IL_0089: isinst [System.Runtime]System.IAsyncDisposable + IL_008e: stloc.s V_12 + IL_0090: ldloc.s V_12 + IL_0092: brfalse.s IL_00a6 + + IL_0094: ldloc.s V_12 + IL_0096: stloc.s V_13 + IL_0098: ldloc.s V_13 + IL_009a: callvirt instance valuetype [System.Runtime]System.Threading.Tasks.ValueTask [System.Runtime]System.IAsyncDisposable::DisposeAsync() + IL_009f: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(valuetype [System.Runtime]System.Threading.Tasks.ValueTask) + IL_00a4: br.s IL_00c0 + + IL_00a6: ldloc.s V_11 + IL_00a8: isinst [System.Runtime]System.IDisposable + IL_00ad: stloc.s V_14 + IL_00af: ldloc.s V_14 + IL_00b1: brfalse.s IL_00c0 + + IL_00b3: ldloc.s V_14 + IL_00b5: stloc.s V_15 + IL_00b7: ldloc.s V_15 + IL_00b9: callvirt instance void [System.Runtime]System.IDisposable::Dispose() + IL_00be: br.s IL_00c0 + + IL_00c0: ldloc.s V_6 + IL_00c2: stloc.s V_10 + IL_00c4: ldloc.s V_10 + IL_00c6: brtrue.s IL_00ca + + IL_00c8: br.s IL_00cd + + IL_00ca: ldloc.s V_10 + IL_00cc: throw + + IL_00cd: ldloc.s V_7 + IL_00cf: isinst class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2/Choice2Of2 + IL_00d4: brfalse.s IL_00d8 + + IL_00d6: br.s IL_00e5 + + IL_00d8: ldloc.s V_7 + IL_00da: castclass class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2/Choice1Of2 + IL_00df: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2/Choice1Of2::get_Item() + IL_00e4: ret + + IL_00e5: ldc.i4.0 + IL_00e6: ret + } // end of method outer@13::Invoke +""" + +[] +let ``async impl flag is on the lifted async method, not the enclosing F# function`` () = + let asyncBit = 0x2000 + FsFromPath builderPath + |> withAdditionalSourceFile (FsSource composedLayoutProgram) + |> withLangVersionPreview + |> compile + |> shouldSucceed + |> verifyILContains [ composedOuterBody; composedAsyncClosureBody ] + |> withMetadataReader (fun md -> + let methods = + [ for th in md.TypeDefinitions do + let td = md.GetTypeDefinition th + let typeName = md.GetString td.Name + for mh in td.GetMethods() do + let m = md.GetMethodDefinition mh + yield typeName, md.GetString m.Name, ((int m.ImplAttributes) &&& asyncBit) <> 0 ] + + let isAsync typeName methodName = + methods |> List.exists (fun (t, m, a) -> t = typeName && m = methodName && a) + + // The user functions are plain IL methods — the async flag must NOT leak onto them just + // because the CE (or a call to an async helper) appears lexically inside `outer`. + Assert.False(isAsync "M" "outer", "outer must not carry the async impl flag") + Assert.False(isAsync "M" "helper", "helper must not carry the async impl flag") + + // The CE body is lifted into a compiler-generated closure (name `outer@`); that + // emitted method is the one that carries the async flag. + let liftedIsAsync = + methods |> List.exists (fun (t, _, a) -> a && t.StartsWith "outer@") + Assert.True(liftedIsAsync, "the lifted closure holding outer's async body must carry the async impl flag")) + +// DEMO (auduchinok's sequence-points baseline format): source spans interleaved with the IL that +// implements them, so a large async body is readable and each Await maps to its `do!`/`let!`. +let private composedDirectProgram = """ +module M +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +let helper x = x * 2 + +let outer (n: int) : Task = + let inner y = y + helper n + let baseline = inner 10 + StateMachineHelpers.__runtimeAsync ( + let mutable total = baseline + for i in 1 .. n do + let d = AsyncHelpers.Await(Task.FromResult i) + total <- total + d + AsyncHelpers.Await(Task.Delay 1) + if total > 0 then total else -1) +""" + +[] +let ``composed runtime-async body: source-mapped IL (sequence points baseline)`` () = + FSharp composedDirectProgram + |> withLangVersionPreview + |> withPortablePdb + |> withNoOptimize + |> compile + |> shouldSucceed + |> verifySequencePointsBaseline composedDirectProgram (Path.Combine(runtimeAsyncDir, "ComposedRuntimeAsync.bsl")) + |> ignore + + +// Each pattern is contract-forbidden but compiles with NO diagnostic today; docs/runtime-async.md +// records them as known, currently-undiagnosed restrictions. Not executed here (the observed runtime +// result is a hard process crash); the row comments record the observed symptom. C# rejects the +// analogues at compile time (await-in-finally/catch; CS4007 for ref-struct; CS1988 for byref). +[] +[ = StateMachineHelpers.__runtimeAsync (try 1 finally AsyncHelpers.Await(Task.Delay(1)))")>] // runtime: fail-fast 0xC0000409 / SIGSEGV +[ = StateMachineHelpers.__runtimeAsync (try failwith \"boom\" with _ -> AsyncHelpers.Await(Task.Delay(1)); 7)")>] // runtime: crash +[ = StateMachineHelpers.__runtimeAsync (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] // runtime: IndexOutOfRangeException (C14) +[) : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(Task.Delay(1)); x)")>] // byref read after suspension; C# gives CS1988 +let ``contract-forbidden suspension pattern compiles with no diagnostic`` (_label: string) (body: string) = + compileDirect body + |> shouldSucceed + +[] +// Positive counterpart to the ref-struct row above: the same code through the CE builder IS rejected, +// because the continuation lambda captures the ref-struct local (FS0406). The CE provides a safety +// net that the delegate-free intrinsic does not. +let ``ref struct across a suspension is rejected through the CE builder`` () = + FsFromPath builderPath + |> withAdditionalSourceFile (FsSource refStructAcrossAwaitCE) + |> withLangVersionPreview + |> compile + |> shouldFail + |> withErrorCode 406 + +#endif From 31889ba97e472a907c0bbb4e0505f2367ce068cb Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Thu, 13 Aug 2026 17:40:57 +0200 Subject: [PATCH 11/59] Make composed runtime-async exhibits self-prove the async impl flag The sequence-points baseline (and ildasm) cannot render MethodImplOptions.Async (0x2000), so the lifted __runtimeAsync body shows up as a plain outer@ closure. Factor the metadata flag check into assertAsyncFlagOnLiftedClosureOnly and chain it onto the sequence-points fact so the exact program that emits the .bsl also proves the async marker lands only on the lifted closure, never on the user's outer/helper methods. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 55dd72c8-46d3-4959-9677-c52d41779596 --- .../Language/RuntimeAsyncEdgeCaseTests.fs | 269 ++++-------------- 1 file changed, 52 insertions(+), 217 deletions(-) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index b30b366df34..a8d49302063 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -84,14 +84,10 @@ let ``runtime async edge cases execute through the CE builder`` () = |> shouldSucceed // ============================ emitted IL (codegen contract) ============================ -// -// Each fact below pins the *entire* method body in scope (not a single line): the normalized -// `.method { ... }` block captured from the PR's own fsc on the pinned net11 preview. This hands -// dotnet/runtime reviewers the exact lowering to check against docs/runtime-async.md. The blocks -// are deliberately brittle across SDK/codegen bumps — a codegen exhibit is supposed to change when -// the codegen changes. ILChecker.compareIL normalizes both sides identically ([System.Runtime] -> -// [runtime], collapses the multi-line `.method` signature, strips comments), so the verbatim -// ildasm text is what we assert. +// Each fact pins the whole method body captured from the PR's fsc, so dotnet/runtime reviewers get +// the exact lowering to check against docs/runtime-async.md. ILChecker normalizes both sides +// ([System.Runtime] -> [runtime], collapses the `.method` signature, strips comments); a codegen +// exhibit is meant to change when the codegen changes. // `Await(Task); 1` — direct call to the non-generic Await overload, then push 1 and ret. let private simpleAwaitBody = """ @@ -205,24 +201,11 @@ let ``runtime async currently emits a forbidden tail prefix (C1)`` () = |> verifyILContains [ tailPrefixBody ] |> shouldSucceed -// ============== async impl-flag placement — F# source layout is not authoritative ============== -// -// The async marking is a *method* impl flag (MethodImplAttributes 0x2000, MethodImplOptions.Async; -// il.fs WithAsync), written into the emitted PE method header. It is NOT rendered by the ildasm we -// use, so it can only be checked from metadata — hence withMetadataReader rather than verifyIL. -// -// This is the composed / non-trivial case the trivial single-method exhibits above do not cover: a -// larger user function (`outer`) that has a nested local function (`inner`), non-async code before -// and after, and a runtimeTask CE that itself combines control flow (`for`, `let!`, `use`, -// `try/finally`, `do!`, `if`). The property being pinned: the 0x2000 flag lands on the emitted IL -// method that actually holds the async body (a compiler-generated closure the CE body is lifted -// into), and NOT on the enclosing `outer` just because the CE is written lexically inside it. -// -// Empirically on the pinned net11 preview (implAttrs, async = 0x2000 bit): -// M::helper 0x0000 async=false -// M::outer 0x0000 async=false <- encloses the CE, but is NOT the async method -// outer@NN::Invoke 0x2008 async=true <- lifted async body carries the flag (+noinlining) -// RuntimeTaskBuilder::Run 0x2008 async=true (the intrinsic-bodied inline builder member) +// ===== composed CE case: async marking follows the emitted method, not F# source layout ===== +// A larger `outer` (nested `inner`, non-async code before/after, a runtimeTask CE combining +// for/let!/use/try-finally/do!/if). Empirically the 0x2000 (MethodImplOptions.Async) bit lands on +// the lifted `outer@::Invoke` (0x2008, +noinlining) and RuntimeTaskBuilder::Run, never on +// `M::outer`/`M::helper` — asserted via assertAsyncFlagOnLiftedClosureOnly (ildasm/.bsl can't show it). let private composedLayoutProgram = """ module M open System @@ -251,104 +234,14 @@ let outer (n: int) : Task = work // non-async code AFTER the async part """ -// Full emitted IL of the composed program, so dotnet/runtime reviewers can read the exact lowering. -// -// (1) `M::outer` -- the *enclosing* user function. It is a plain, non-async method: it runs the -// pre-async code (`baseline = inner 10`, i.e. `10 + helper n`) inline, constructs the closure that -// holds the async body, and tail-calls its `Invoke`. It returns `Task` but carries NO async -// impl flag -- proof that the async marking follows the emitted async method, not the F# function the -// CE is lexically written in. (It is even allowed `tail.` here precisely because it is not async.) -let private composedOuterBody = """ - .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - outer(int32 n) cil managed - { - // Code size 23 (0x17) - .maxstack 5 - .locals init (int32 V_0) - IL_0000: ldc.i4.s 10 - IL_0002: ldarg.0 - IL_0003: ldc.i4.2 - IL_0004: mul - IL_0005: add - IL_0006: stloc.0 - IL_0007: ldarg.0 - IL_0008: ldloc.0 - IL_0009: newobj instance void M/outer@13::.ctor(int32, - int32) - IL_000e: ldnull - IL_000f: tail. - IL_0011: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2>::Invoke(!0) - IL_0016: ret - } // end of method M::outer -""" +// Two CE-only IL shapes the direct-intrinsic .bsl program cannot show (it has no use/try-finally), +// pinned as targeted contiguous slices of outer@::Invoke rather than the whole lifted body. +// Captured from the PR's fsc; ILChecker normalizes [System.Runtime] -> [runtime]. -// (2) `outer@13::Invoke` -- the compiler-generated closure the CE body is lifted into: THIS is the -// runtime-async method (the one carrying MethodImplAttributes.Async, checked via metadata below). -// Its body is the full composed lowering the runtime must honour: -// * a `for` loop (blt.s / bne.un.s) around a suspension, -// * `AsyncHelpers::Await(Task)` -- the generic await intrinsic (the `let!`), -// * a try/finally where `do!` suspends via `AsyncHelpers::Await(Task)` INSIDE the try while the -// finally does only arithmetic (no await in a finally region -- that is forbidden), -// * the `use` disposal lowered as isinst IAsyncDisposable -> DisposeAsync(); Await(ValueTask), -// else isinst IDisposable -> Dispose(), emitted in straight-line code AFTER the protected region -// (the builder hoists the awaited DisposeAsync out of the finally, by design), and -// * the final `if total > 0 then ... else -1`. -let private composedAsyncClosureBody = """ - .method public strict virtual instance class [System.Runtime]System.Threading.Tasks.Task`1 - Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unit) cil managed noinlining - { - // Code size 231 (0xe7) - .maxstack 7 - .locals init (int32 V_0, - int32 V_1, - int32 V_2, - class [System.Runtime]System.Threading.Tasks.Task`1 V_3, - int32 V_4, - class [System.Runtime]System.IDisposable V_5, - class [System.Runtime]System.Exception V_6, - class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 V_7, - class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 V_8, - class [System.Runtime]System.Threading.Tasks.Task V_9, - class [System.Runtime]System.Exception V_10, - object V_11, - class [System.Runtime]System.IAsyncDisposable V_12, - class [System.Runtime]System.IAsyncDisposable V_13, - class [System.Runtime]System.IDisposable V_14, - class [System.Runtime]System.IDisposable V_15) - IL_0000: ldarg.0 - IL_0001: ldfld int32 M/outer@13::baseline - IL_0006: stloc.0 - IL_0007: ldc.i4.1 - IL_0008: stloc.2 - IL_0009: ldarg.0 - IL_000a: ldfld int32 M/outer@13::n - IL_000f: stloc.1 - IL_0010: ldloc.1 - IL_0011: ldloc.2 - IL_0012: blt.s IL_0032 - - IL_0014: ldloc.2 - IL_0015: call class [System.Runtime]System.Threading.Tasks.Task`1 [System.Runtime]System.Threading.Tasks.Task::FromResult(!!0) - IL_001a: stloc.3 - IL_001b: ldloc.3 - IL_001c: call !!0 [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task`1) - IL_0021: stloc.s V_4 - IL_0023: ldloc.0 - IL_0024: ldloc.s V_4 - IL_0026: add - IL_0027: stloc.0 - IL_0028: ldloc.2 - IL_0029: ldc.i4.1 - IL_002a: add - IL_002b: stloc.2 - IL_002c: ldloc.2 - IL_002d: ldloc.1 - IL_002e: ldc.i4.1 - IL_002f: add - IL_0030: bne.un.s IL_0014 - - IL_0032: newobj instance void M/'outer@18-1'::.ctor() - IL_0037: stloc.s V_5 +// (1) `do!` suspends INSIDE the try; the finally does only arithmetic. Await in a finally is +// forbidden (docs/runtime-async.md), so the suspension must sit in the protected region. The `use` +// wraps it in an outer try/catch; the exhibit keeps both frames so the nesting is visible. +let private ceAwaitInsideTry = """ .try { .try @@ -373,37 +266,11 @@ let private composedAsyncClosureBody = """ IL_0052: stloc.0 IL_0053: endfinally } // end handler - IL_0054: ldloc.0 - IL_0055: ldc.i4.0 - IL_0056: ble.s IL_005b - - IL_0058: ldloc.0 - IL_0059: br.s IL_005c - - IL_005b: ldc.i4.m1 - IL_005c: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2::NewChoice1Of2(!0) - IL_0061: stloc.s V_8 - IL_0063: leave.s IL_007a +""" - } // end .try - catch [mscorlib]System.Object - { - IL_0065: castclass [System.Runtime]System.Exception - IL_006a: stloc.s V_10 - IL_006c: ldloc.s V_10 - IL_006e: stloc.s V_6 - IL_0070: ldnull - IL_0071: call class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2 class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2::NewChoice2Of2(!1) - IL_0076: stloc.s V_8 - IL_0078: leave.s IL_007a - - } // end handler - IL_007a: ldloc.s V_8 - IL_007c: stloc.s V_7 - IL_007e: ldloc.s V_5 - IL_0080: box [System.Runtime]System.IDisposable - IL_0085: stloc.s V_11 - IL_0087: ldloc.s V_11 +// (2) `use` disposal emitted AFTER the protected region: the builder hoists the awaited DisposeAsync +// out of the finally — isinst IAsyncDisposable -> DisposeAsync() -> Await(ValueTask). +let private ceDisposalHoist = """ IL_0089: isinst [System.Runtime]System.IAsyncDisposable IL_008e: stloc.s V_12 IL_0090: ldloc.s V_12 @@ -414,80 +281,48 @@ let private composedAsyncClosureBody = """ IL_0098: ldloc.s V_13 IL_009a: callvirt instance valuetype [System.Runtime]System.Threading.Tasks.ValueTask [System.Runtime]System.IAsyncDisposable::DisposeAsync() IL_009f: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(valuetype [System.Runtime]System.Threading.Tasks.ValueTask) - IL_00a4: br.s IL_00c0 - - IL_00a6: ldloc.s V_11 - IL_00a8: isinst [System.Runtime]System.IDisposable - IL_00ad: stloc.s V_14 - IL_00af: ldloc.s V_14 - IL_00b1: brfalse.s IL_00c0 - - IL_00b3: ldloc.s V_14 - IL_00b5: stloc.s V_15 - IL_00b7: ldloc.s V_15 - IL_00b9: callvirt instance void [System.Runtime]System.IDisposable::Dispose() - IL_00be: br.s IL_00c0 - - IL_00c0: ldloc.s V_6 - IL_00c2: stloc.s V_10 - IL_00c4: ldloc.s V_10 - IL_00c6: brtrue.s IL_00ca - - IL_00c8: br.s IL_00cd - - IL_00ca: ldloc.s V_10 - IL_00cc: throw - - IL_00cd: ldloc.s V_7 - IL_00cf: isinst class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2/Choice2Of2 - IL_00d4: brfalse.s IL_00d8 - - IL_00d6: br.s IL_00e5 - - IL_00d8: ldloc.s V_7 - IL_00da: castclass class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2/Choice1Of2 - IL_00df: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpChoice`2/Choice1Of2::get_Item() - IL_00e4: ret - - IL_00e5: ldc.i4.0 - IL_00e6: ret - } // end of method outer@13::Invoke """ -[] -let ``async impl flag is on the lifted async method, not the enclosing F# function`` () = +// MethodImplOptions.Async (0x2000) is a *method header* flag, not an IL instruction — neither the +// ildasm we use nor the sequence-points decoder render it, so both the composed IL exhibit and the +// sequence-points baseline show the lifted async body as an ordinary `outer@` closure. This +// reads it from metadata and pins the placement: the flag lands only on that lifted `__runtimeAsync` +// body and never leaks onto the user's own `outer`/`helper` methods just because the async part is +// written lexically inside `outer`. Empirically the lifted `Invoke` is 0x2008 (async + noinlining). +let private assertAsyncFlagOnLiftedClosureOnly (md: MetadataReader) = let asyncBit = 0x2000 + let methods = + [ for th in md.TypeDefinitions do + let td = md.GetTypeDefinition th + let typeName = md.GetString td.Name + for mh in td.GetMethods() do + let m = md.GetMethodDefinition mh + yield typeName, md.GetString m.Name, ((int m.ImplAttributes) &&& asyncBit) <> 0 ] + + let isAsync typeName methodName = + methods |> List.exists (fun (t, m, a) -> t = typeName && m = methodName && a) + + Assert.False(isAsync "M" "outer", "outer must not carry the async impl flag") + Assert.False(isAsync "M" "helper", "helper must not carry the async impl flag") + Assert.True( + methods |> List.exists (fun (t, _, a) -> a && t.StartsWith "outer@"), + "the lifted closure holding outer's async body must carry the async impl flag") + +[] +let ``composed CE body: await inside try, hoisted disposal, async flag on the lifted method`` () = FsFromPath builderPath |> withAdditionalSourceFile (FsSource composedLayoutProgram) |> withLangVersionPreview |> compile |> shouldSucceed - |> verifyILContains [ composedOuterBody; composedAsyncClosureBody ] - |> withMetadataReader (fun md -> - let methods = - [ for th in md.TypeDefinitions do - let td = md.GetTypeDefinition th - let typeName = md.GetString td.Name - for mh in td.GetMethods() do - let m = md.GetMethodDefinition mh - yield typeName, md.GetString m.Name, ((int m.ImplAttributes) &&& asyncBit) <> 0 ] - - let isAsync typeName methodName = - methods |> List.exists (fun (t, m, a) -> t = typeName && m = methodName && a) - - // The user functions are plain IL methods — the async flag must NOT leak onto them just - // because the CE (or a call to an async helper) appears lexically inside `outer`. - Assert.False(isAsync "M" "outer", "outer must not carry the async impl flag") - Assert.False(isAsync "M" "helper", "helper must not carry the async impl flag") - - // The CE body is lifted into a compiler-generated closure (name `outer@`); that - // emitted method is the one that carries the async flag. - let liftedIsAsync = - methods |> List.exists (fun (t, _, a) -> a && t.StartsWith "outer@") - Assert.True(liftedIsAsync, "the lifted closure holding outer's async body must carry the async impl flag")) + |> verifyILContains [ ceAwaitInsideTry; ceDisposalHoist ] + |> withMetadataReader assertAsyncFlagOnLiftedClosureOnly // DEMO (auduchinok's sequence-points baseline format): source spans interleaved with the IL that // implements them, so a large async body is readable and each Await maps to its `do!`/`let!`. +// NOTE: like ildasm, this decoder cannot render the MethodImplOptions.Async flag, so in the .bsl the +// lifted `outer@::Invoke` looks like a plain closure. The flag that actually makes it a +// runtime-async method is asserted on the very same compilation via assertAsyncFlagOnLiftedClosureOnly. let private composedDirectProgram = """ module M open System.Threading.Tasks @@ -517,7 +352,7 @@ let ``composed runtime-async body: source-mapped IL (sequence points baseline)`` |> compile |> shouldSucceed |> verifySequencePointsBaseline composedDirectProgram (Path.Combine(runtimeAsyncDir, "ComposedRuntimeAsync.bsl")) - |> ignore + |> withMetadataReader assertAsyncFlagOnLiftedClosureOnly // Each pattern is contract-forbidden but compiles with NO diagnostic today; docs/runtime-async.md From 6f8cadc1c3cf79e72b2e3bf099819bcef3e8f8a8 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 21 Aug 2026 00:24:26 +0200 Subject: [PATCH 12/59] restrict to net10, rename to __runtimeAsyncReturn --- .../.FSharp.Compiler.Service/11.0.100.md | 2 +- docs/release-notes/.FSharp.Core/11.0.100.md | 2 +- docs/runtime-async.md | 25 ++++++----- .../Checking/Expressions/CheckExpressions.fs | 6 +-- src/Compiler/CodeGen/IlxGen.fs | 25 ++++++----- src/Compiler/Optimize/Optimizer.fs | 2 +- src/Compiler/TypedTree/TcGlobals.fs | 4 +- src/Compiler/TypedTree/TcGlobals.fsi | 2 +- src/FSharp.Core/resumable.fs | 6 ++- src/FSharp.Core/resumable.fsi | 4 +- .../RuntimeAsync/RuntimeAsyncBasic.fs | 12 ++--- .../RuntimeAsync/RuntimeTaskBuilder.fs | 2 +- .../RuntimeTasksAsyncDisposalException.fs | 4 +- .../Language/RuntimeAsyncTests.fs | 44 ++++++++++++------- 14 files changed, 78 insertions(+), 62 deletions(-) diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md index 99b5d427477..f161b90d64b 100644 --- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md +++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md @@ -150,7 +150,7 @@ * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289)) * Symbols: add ObsoleteDiagnosticInfo ([PR #19359](https://github.com/dotnet/fsharp/pull/19359)) * FCS: add FSharpCheckFileResults.HasErrors ([PR #19892](https://github.com/dotnet/fsharp/pull/19892)) -* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsync` intrinsic, including carrier validation and target-runtime capability checks. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) +* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsyncReturn` intrinsic, including carrier validation and target-runtime capability checks. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * Add `#version;;` directive to F# Interactive to display version and environment information. ([Issue #13307](https://github.com/dotnet/fsharp/issues/13307), [PR #19332](https://github.com/dotnet/fsharp/pull/19332)) * Add diagnostic FS3889 when a namespace and a type have the same fully-qualified name in the same assembly, replacing the misleading FS0247 "namespace and a module" error. ([Issue #17827](https://github.com/dotnet/fsharp/issues/17827), [PR #19802](https://github.com/dotnet/fsharp/pull/19802)) * Debug: rework for expressions stepping ([PR #19894](https://github.com/dotnet/fsharp/pull/19894)) diff --git a/docs/release-notes/.FSharp.Core/11.0.100.md b/docs/release-notes/.FSharp.Core/11.0.100.md index fca9f6d4c00..0a0458d4e5b 100644 --- a/docs/release-notes/.FSharp.Core/11.0.100.md +++ b/docs/release-notes/.FSharp.Core/11.0.100.md @@ -8,7 +8,7 @@ ### Added -* Add the compiler-recognized `StateMachineHelpers.__runtimeAsync` intrinsic for .NET runtime-async methods. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) +* Add the compiler-recognized `StateMachineHelpers.__runtimeAsyncReturn` intrinsic to the `net10.0` FSharp.Core target for .NET runtime-async methods. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * Add `Unchecked.withNull`, an interop escape hatch that re-types any `'T` to `'T | null` without the usual `not null`/`not struct` constraints, so unconstrained C# nullable-generic APIs (e.g. `T? M()`) can be implemented and consumed from F#. ([Issue #17734](https://github.com/dotnet/fsharp/issues/17734), [PR #20232](https://github.com/dotnet/fsharp/pull/20232)) * Added generic `print` and `printn` functions (`'T -> unit`) to `ExtraTopLevelOperators` for simple value printing to stdout. ([RFC FS-1125](https://github.com/fsharp/fslang-design/blob/main/RFCs/FS-1125-print-printn-functions.md), [PR #19265](https://github.com/dotnet/fsharp/pull/19265)) * Ship `FSharp.Core` with an additional `net10.0` target framework (next to `netstandard2.0` and `netstandard2.1`). The `net`-TFM assembly is public-surface-identical to the `netstandard2.1` one; the target version is a pinned, deliberately advanced knob. ([PR #20229](https://github.com/dotnet/fsharp/pull/20229)) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 90d22b803de..2c9fa46a009 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -65,11 +65,12 @@ Known runtime restrictions (currently **not** diagnosed by the F# compiler): ## F# surface The source-level marker is the compiler intrinsic -`Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers.__runtimeAsync`, +`Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers.__runtimeAsyncReturn`, +available from the `net10.0` FSharp.Core target, declared in `resumable.fsi` alongside the other compiler intrinsics: ```fsharp -val __runtimeAsync<'T> : 'T -> System.Threading.Tasks.Task<'T> +val __runtimeAsyncReturn<'T> : 'T -> System.Threading.Tasks.Task<'T> ``` Its FSharp.Core implementation throws; the compiler consumes every @@ -87,26 +88,26 @@ Typical forms: ```fsharp let add (x: int) (y: int) : Task = - __runtimeAsync ( + __runtimeAsyncReturn ( let first = AsyncHelpers.Await (getTask x) first + y) type C() = member _.Add(x: int, y: int) : Task = - __runtimeAsync ( + __runtimeAsyncReturn ( AsyncHelpers.Await (getTask x) + y) // Let-bound value (not a function): also supported. -let answer : Task = __runtimeAsync 42 +let answer : Task = __runtimeAsyncReturn 42 ``` -There is no implicit awaiting: the argument of `__runtimeAsync` is checked +There is no implicit awaiting: the argument of `__runtimeAsyncReturn` is checked as the logical `'T` result, and flattening requires an explicit `AsyncHelpers.Await`. ## Type checking -`__runtimeAsync` is an ordinary generic value in the typed tree; no new +`__runtimeAsyncReturn` is an ordinary generic value in the typed tree; no new expression node or `Val` flag is added. Type checking special-cases its application in two places in `CheckExpressions.fs`: @@ -121,7 +122,7 @@ application in two places in `CheckExpressions.fs`: the usual way. A non-`Task<'T>` declared return type therefore fails with the ordinary FS0001 type-mismatch error. -User code that defines its own `__runtimeAsync` is unaffected: the intrinsic +User code that defines its own `__runtimeAsyncReturn` is unaffected: the intrinsic is only recognised when the `ValRef` resolves (via `valRefEq`) to the FSharp.Core declaration. @@ -136,7 +137,7 @@ nothing else in the typed tree records that a method is runtime-async. ## Code generation `IlxGen.fs` recognises the marker in three placements -(`TryUnwrapRuntimeAsyncExpr`, which strips `DebugPoint` wrappers): +(`TryUnwrapRuntimeAsyncReturnExpr`, which strips `DebugPoint` wrappers): 1. **Method body** (`GenMethodForBinding`): the marker is unwrapped from the top of the method lambda body; the generated `ILMethodDef` gets @@ -149,14 +150,14 @@ nothing else in the typed tree records that a method is runtime-async. `Invoke` method's IL body (`ILMethodBody.IsRuntimeAsync`). `EraseClosures.convIlxClosureDef` copies that flag onto the emitted method, again with `NoInlining`. -3. **Any other expression position** (`GenRuntimeAsyncAsStartedTask`), e.g. +3. **Any other expression position** (`GenRuntimeAsyncReturnAsStartedTask`), e.g. a `let`-bound value initializer: the marker application is wrapped in a fresh `fun () -> ...` lambda that is immediately applied to `unit` and regenerated. The lambda flows through the closure path (2), producing a generated runtime-async helper method whose call starts the task. This relies on `GenApp` never beta-reducing a lambda application (it always emits a closure plus an indirect call); see the comment at - `GenRuntimeAsyncAsStartedTask`. + `GenRuntimeAsyncReturnAsStartedTask`. A marker that ends up wrapped in anything other than `DebugPoint` at the top of a method or closure body is not detected there, but still reaches the @@ -195,7 +196,7 @@ Tests live in `tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync*`: `RuntimeTaskBuilder.fs` is a quasi-synchronous builder aiming for feature parity with FSharp.Core's `task` builder: `Delay` is the identity on `unit -> 'T`, so all combinators are plain inline functions over delayed -code; only `Run` introduces `__runtimeAsync` and returns `Task<'T>`. +code; only `Run` introduces `__runtimeAsyncReturn` and returns `Task<'T>`. `Bind` lowers directly to `AsyncHelpers.Await` with SRTP fallbacks (`AwaitAwaiter`) for arbitrary task-likes, as do `ReturnFrom` and `MergeSources`. `MergeSources` awaits its sources sequentially, matching the diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 8c6ee467206..8fcdcb6539b 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -8709,7 +8709,7 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl match expr.Expr with | Expr.Val(vref, _, _) | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [], _) - when valRefEq g vref g.cgh__runtimeAsync_vref -> true + when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> true | _ -> false match isRuntimeAsync, UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with @@ -9028,10 +9028,10 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let intrinsic = match leftExpr with | ApplicableExpr(expr=Expr.Val (vref, flags, m)) - when valRefEq g vref g.cgh__runtimeAsync_vref -> + when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> Some(vref, flags, m) | ApplicableExpr(expr=Expr.App (Expr.Val (vref, flags, m), _, [ _ ], [], _)) - when valRefEq g vref g.cgh__runtimeAsync_vref -> + when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> Some(vref, flags, m) | _ -> None diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index 4b4c5409c9b..fe803467726 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3127,17 +3127,17 @@ let ComputeDebugPointForBinding g bind = | _, (Expr.Lambda _ | Expr.TyLambda _) -> false, None | DebugPointAtBinding.Yes m, _ -> false, Some m -let IsRuntimeAsyncVref (g: TcGlobals) (vref: ValRef) = - valRefEq g vref g.cgh__runtimeAsync_vref +let IsRuntimeAsyncReturnVref (g: TcGlobals) (vref: ValRef) = + valRefEq g vref g.cgh__runtimeAsyncReturn_vref -let rec TryUnwrapRuntimeAsyncExpr (g: TcGlobals) expr = +let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = match expr with | Expr.DebugPoint(_, innerExpr) -> - match TryUnwrapRuntimeAsyncExpr g innerExpr with + match TryUnwrapRuntimeAsyncReturnExpr g innerExpr with | true, body -> true, body | false, _ -> false, expr - | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncVref g vref -> true, body + | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body | _ -> false, expr //------------------------------------------------------------------------- @@ -3287,8 +3287,8 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = // application of local type functions with type parameters = measure types and body = local value - inline the body GenExpr cenv cgbuf eenv v sequel - | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ _ ], _) when IsRuntimeAsyncVref g vref -> - GenRuntimeAsyncAsStartedTask cenv cgbuf eenv expr sequel + | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ _ ], _) when IsRuntimeAsyncReturnVref g vref -> + GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel | Expr.App(f, fty, tyargs, curriedArgs, m) -> GenApp cenv cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel @@ -3391,14 +3391,14 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = | Expr.TyChoose(_, _, m) -> error (InternalError("Unexpected Expr.TyChoose", m)) -// A __runtimeAsync marker that is not at the top of a method or closure body is lowered +// A __runtimeAsyncReturn marker that is not at the top of a method or closure body is lowered // as a "started task": the marked expression becomes the body of a fresh closure whose // Invoke method is the runtime-async method, and the closure is invoked immediately. // This relies on GenApp never beta-reducing a lambda application - it always emits a // closure value followed by an indirect call (the "worst case" path), which routes the // lambda through the closure generation that consumes the marker. If that invariant ever // changes, the marker expression would reach GenExprAux again and recurse without bound. -and GenRuntimeAsyncAsStartedTask cenv cgbuf eenv expr sequel = +and GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel = let m = expr.Range let unitVal, _ = mkLocal m "unit" cenv.g.unit_ty let lambdaExpr = mkLambda m unitVal (expr, tyOfExpr cenv.g expr) @@ -7138,7 +7138,7 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr strip cloinfo.ilCloLambdas - let isRuntimeAsync, body = TryUnwrapRuntimeAsyncExpr g body + let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body let ilCloBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) @@ -7194,7 +7194,7 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e let ilCloTypeRef = cloinfo.cloSpec.TypeRef - let isRuntimeAsync, body = TryUnwrapRuntimeAsyncExpr g body + let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body let ilCloBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) @@ -9850,7 +9850,8 @@ and GenMethodForBinding | h :: t -> [ h ], t, true | _ -> [], methLambdaVars, false - let isRuntimeAsync, methLambdaBody = TryUnwrapRuntimeAsyncExpr g methLambdaBody + let isRuntimeAsync, methLambdaBody = + TryUnwrapRuntimeAsyncReturnExpr g methLambdaBody let nonUnitNonSelfMethodVars, body = BindUnitVars cenv.g (nonSelfMethodVars, paramInfos, methLambdaBody) diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index dfff6ac5b21..30fc0ed791e 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2555,7 +2555,7 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App (f, fty, tyargs, argsl, m) -> match expr with | Expr.App(Expr.Val(vref, flags, _), fty, [ _ ], [ body ], _) - when valRefEq g vref g.cgh__runtimeAsync_vref -> + when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> let bodyR, bodyInfo = OptimizeExpr cenv env body Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), { bodyInfo with diff --git a/src/Compiler/TypedTree/TcGlobals.fs b/src/Compiler/TypedTree/TcGlobals.fs index 9140b620a25..3cae4aeeaf0 100644 --- a/src/Compiler/TypedTree/TcGlobals.fs +++ b/src/Compiler/TypedTree/TcGlobals.fs @@ -885,7 +885,7 @@ type TcGlobals( let v_cgh__resumeAt_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__resumeAt" , None , None , [vara], ([[v_int_ty]; [varaTy]], varaTy)) let v_cgh__stateMachine_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__stateMachine" , None , None , [vara; varb], ([[varaTy]], varbTy)) // inaccurate type but it doesn't matter for linking let v_cgh__resumableEntry_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__resumableEntry" , None , None , [vara], ([[v_int_ty --> varaTy]; [v_unit_ty --> varaTy]], varaTy)) - let v_cgh__runtimeAsync_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsync" , None , None , [vara], ([[varaTy]], TType_app(v_task_tcr, [varaTy], v_knownWithoutNull))) // handled specially by the checker + let v_cgh__runtimeAsyncReturn_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsyncReturn" , None , None , [vara], ([[varaTy]], TType_app(v_task_tcr, [varaTy], v_knownWithoutNull))) // handled specially by the checker let v_seq_to_array_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "toArray" , None , Some "ToArray", [varb], ([[mkSeqTy varbTy]], mkArrayType 1 varbTy)) let v_seq_to_list_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "toList" , None , Some "ToList" , [varb], ([[mkSeqTy varbTy]], mkListTy varbTy)) let v_seq_map_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "map" , None , Some "Map" , [vara;varb], ([[varaTy --> varbTy]; [mkSeqTy varaTy]], mkSeqTy varbTy)) @@ -1775,7 +1775,7 @@ type TcGlobals( member val cgh__stateMachine_vref = ValRefForIntrinsic v_cgh__stateMachine_info - member val cgh__runtimeAsync_vref = ValRefForIntrinsic v_cgh__runtimeAsync_info + member val cgh__runtimeAsyncReturn_vref = ValRefForIntrinsic v_cgh__runtimeAsyncReturn_info member val cgh__useResumableCode_vref = ValRefForIntrinsic v_cgh__useResumableCode_info member val cgh__debugPoint_vref = ValRefForIntrinsic v_cgh__debugPoint_info member val cgh__resumeAt_vref = ValRefForIntrinsic v_cgh__resumeAt_info diff --git a/src/Compiler/TypedTree/TcGlobals.fsi b/src/Compiler/TypedTree/TcGlobals.fsi index 096bbf585b2..3bcb6247f6b 100644 --- a/src/Compiler/TypedTree/TcGlobals.fsi +++ b/src/Compiler/TypedTree/TcGlobals.fsi @@ -436,7 +436,7 @@ type internal TcGlobals = member cgh__stateMachine_vref: TypedTree.ValRef - member cgh__runtimeAsync_vref: TypedTree.ValRef + member cgh__runtimeAsyncReturn_vref: TypedTree.ValRef member cgh__useResumableCode_vref: TypedTree.ValRef diff --git a/src/FSharp.Core/resumable.fs b/src/FSharp.Core/resumable.fs index 2fc9a0d21ab..1315b79ee99 100644 --- a/src/FSharp.Core/resumable.fs +++ b/src/FSharp.Core/resumable.fs @@ -111,11 +111,13 @@ module StateMachineHelpers = failwith "__stateMachine should always be guarded by __useResumableCode and only used in valid state machine implementations" +#if NET10_0 [] - let __runtimeAsync<'T> (value: 'T) : Task<'T> = + let __runtimeAsyncReturn (value: 'T) : Task<'T> = ignore value - failwith "__runtimeAsync is a compiler intrinsic and should only be used in runtime-async method bodies" + failwith "__runtimeAsyncReturn is a compiler intrinsic and should only be used in runtime-async method bodies" +#endif module ResumableCode = open System.Runtime.ExceptionServices diff --git a/src/FSharp.Core/resumable.fsi b/src/FSharp.Core/resumable.fsi index 05ab2f8cfcf..ba3d18422e8 100644 --- a/src/FSharp.Core/resumable.fsi +++ b/src/FSharp.Core/resumable.fsi @@ -194,10 +194,12 @@ module StateMachineHelpers = afterCode: AfterCode<'Data, 'Result> -> 'Result +#if NET10_0 /// Marks an expression result for lowering as a .NET runtime-async method. /// This function is compiler-recognised and must not be called directly. [] - val __runtimeAsync<'T> : 'T -> System.Threading.Tasks.Task<'T> + val __runtimeAsyncReturn : 'T -> System.Threading.Tasks.Task<'T> +#endif /// Adding this attribute to the method adjusts the processing of some generic methods /// during overload resolution. diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs index 2df7b814a47..8974f367b0b 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs @@ -9,19 +9,19 @@ let private delayed value = Task.Delay(1).ContinueWith(fun (_: Task) -> value) let add (x: int) (y: int) : Task = - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( let first = AsyncHelpers.Await(delayed x) first + y) let lambdaAdd : int -> Task = fun value -> - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( let result = AsyncHelpers.Await(delayed value) result + 1) let makeAdder (offset: int) : int -> Task = fun value -> - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( let result = AsyncHelpers.Await(delayed value) result + offset) @@ -35,16 +35,16 @@ let inline awaitAndAdd (value: int) = apply (fun current -> current + 1) result let addWithInline (value: int) : Task = - StateMachineHelpers.__runtimeAsync (awaitAndAdd value) + StateMachineHelpers.__runtimeAsyncReturn (awaitAndAdd value) type Calculator() = member _.Add(x: int, y: int) : Task = - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( let first = AsyncHelpers.Await(delayed x) first + y) static member Double(value: int) : Task = - StateMachineHelpers.__runtimeAsync (value * 2) + StateMachineHelpers.__runtimeAsyncReturn (value * 2) let private resultOf (task: Task) = task.GetAwaiter().GetResult() diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs index a37691833f8..60427d5a5d4 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs @@ -21,7 +21,7 @@ let inline bindAwaiter type RuntimeTaskBuilder() = member inline _.Delay([] generator: unit -> 'T) : unit -> 'T = generator member inline _.Run([] code: unit -> 'T) : Task<'T> = - StateMachineHelpers.__runtimeAsync (code()) + StateMachineHelpers.__runtimeAsyncReturn (code()) member inline _.Zero() = () member inline _.Return(value: 'T) = value member inline _.ReturnFrom(task: Task<'T>) = AsyncHelpers.Await task diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs index 61feac5e73d..ab52169cca0 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs @@ -1,5 +1,5 @@ // Minimal repro: suspending with AsyncHelpers.Await inside the *handler* of an -// exception-handling region of a __runtimeAsync method. This is what `use` on an +// exception-handling region of a __runtimeAsyncReturn method. This is what `use` on an // IAsyncDisposable lowers to (the DisposeAsync await sits in the finally). // // Today this compiles cleanly but terminates the process at execution @@ -13,7 +13,7 @@ open System.Threading.Tasks open Microsoft.FSharp.Core.CompilerServices let run () : Task = - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( try 1 finally diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 6aec6ffaec2..3f833989530 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -12,21 +12,21 @@ open System.Runtime.CompilerServices open Microsoft.FSharp.Core.CompilerServices let add (x: int) (y: int) : Task = - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( AsyncHelpers.Await(Task.Delay(1)) x + y) let rawBody () : Task = - StateMachineHelpers.__runtimeAsync 1 + StateMachineHelpers.__runtimeAsyncReturn 1 type Calculator() = member _.Add(x: int, y: int) : Task = - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( AsyncHelpers.Await(Task.Delay(1)) x + y) member _.AddRaw(x: int) : Task = - StateMachineHelpers.__runtimeAsync (x + 1) + StateMachineHelpers.__runtimeAsyncReturn (x + 1) """ let private runtimeAsyncRawSource = """ @@ -41,7 +41,7 @@ type RuntimeTaskBuilder() = generator member inline _.Run([] code: unit -> 'T) : Task<'T> = - StateMachineHelpers.__runtimeAsync (code()) + StateMachineHelpers.__runtimeAsyncReturn (code()) member inline _.Zero() = () @@ -78,46 +78,53 @@ type Calculator() = """ +#if NETCOREAPP [] let ``runtime async requires preview language version`` () = FSharp """ +module RuntimeAsyncPreviewTest + open System.Threading.Tasks open Microsoft.FSharp.Core.CompilerServices let f : Task = - StateMachineHelpers.__runtimeAsync 1 + StateMachineHelpers.__runtimeAsyncReturn 1 """ - |> typecheck + |> withFSharpCoreShippedNet + |> compile |> shouldFail |> withErrorCode 3350 [] let ``runtime async rejects non Task result carriers`` () = FSharp """ +module RuntimeAsyncCarrierTest + open Microsoft.FSharp.Core.CompilerServices let f : string = - StateMachineHelpers.__runtimeAsync "result" + StateMachineHelpers.__runtimeAsyncReturn "result" """ |> withLangVersionPreview - |> typecheck + |> withFSharpCoreShippedNet + |> compile |> shouldFail |> withErrorCode 1 [] let ``runtime async intrinsic does not capture user-defined same-named values`` () = FSharp """ -let __runtimeAsync value = value -let result = __runtimeAsync 1 +let __runtimeAsyncReturn value = value +let result = __runtimeAsyncReturn 1 """ |> typecheck |> shouldSucceed -#if NETCOREAPP [] let ``runtime async compiles functions and members`` () = FSharp runtimeAsyncSource |> withLangVersionPreview + |> withFSharpCoreShippedNet |> compile |> shouldSucceed @@ -125,6 +132,7 @@ let ``runtime async compiles functions and members`` () = let ``runtime async combines awaited chunks without delegates`` () = FSharp runtimeAsyncRawSource |> withLangVersionPreview + |> withFSharpCoreShippedNet |> compile |> verifyILContains [ "Task::Delay(int32)" @@ -139,6 +147,7 @@ let ``runtime task builder fixture executes through runtime async`` () = SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasks.fs")) ) |> withLangVersionPreview + |> withFSharpCoreShippedNet |> compileExeAndRun |> shouldSucceed @@ -147,6 +156,7 @@ let ``runtime async direct intrinsic fixture executes`` () = Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncBasic.fs") |> FsFromPath |> withLangVersionPreview + |> withFSharpCoreShippedNet |> compileExeAndRun |> shouldSucceed @@ -158,21 +168,21 @@ let ``runtime async suspension in exception region compiles (runtime execution i Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasksAsyncDisposalException.fs") |> FsFromPath |> withLangVersionPreview - |> compileExeAndRun + |> withFSharpCoreShippedNet + |> compile |> shouldSucceed #else [] -let ``runtime async reports unsupported target runtime`` () = +let ``runtime async intrinsic is only available in the shipped net FSharp.Core`` () = FSharp """ open System.Threading.Tasks open Microsoft.FSharp.Core.CompilerServices let f : Task = - StateMachineHelpers.__runtimeAsync 1 + StateMachineHelpers.__runtimeAsyncReturn 1 """ - |> withLangVersionPreview |> typecheck |> shouldFail - |> withErrorCode 3351 + |> withErrorCode 39 #endif From d5bd674865319c39ef6839895858268cb63332bb Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 21 Aug 2026 07:52:04 +0200 Subject: [PATCH 13/59] ns surfacearea --- .../FSharp.Core.SurfaceArea.netstandard20.release.bsl | 9 ++++----- .../FSharp.Core.SurfaceArea.netstandard21.release.bsl | 11 +++++------ 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl index 0d95f654c06..13ab088a226 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl @@ -673,8 +673,8 @@ Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[] Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) @@ -985,7 +985,6 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() -Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsync[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) @@ -1103,11 +1102,11 @@ Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TR Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item @@ -2695,4 +2694,4 @@ Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString() Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name() Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType -Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType() \ No newline at end of file diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl index 9edb74121b2..37d6ae4920b 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl @@ -677,16 +677,16 @@ Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[] Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.ValueTask`1[T]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken() @@ -1003,7 +1003,6 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) -Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsync[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName @@ -1120,11 +1119,11 @@ Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TR Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item From 5154fa967702ac8edf0f1b26280a2a75a0058b4a Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 21 Aug 2026 09:01:33 +0200 Subject: [PATCH 14/59] adjust edge case tests to name change and net10 FSharp.Core --- .../RuntimeAsync/ComposedRuntimeAsync.bsl | 4 +-- .../Language/RuntimeAsyncEdgeCaseTests.fs | 33 +++++++++++-------- 2 files changed, 22 insertions(+), 15 deletions(-) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl index 9085a4e1425..f5c05aa112c 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/ComposedRuntimeAsync.bsl @@ -8,7 +8,7 @@ let helper x = x * 2 let outer (n: int) : Task = let inner y = y + helper n let baseline = inner 10 - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( let mutable total = baseline for i in 1 .. n do let d = AsyncHelpers.Await(Task.FromResult i) @@ -36,7 +36,7 @@ M::outer IL_000a: callvirt Invoke IL_000f: stloc.1 - (12,5-18,41) StateMachineHelpers.__runtimeAsync ( let mutable total = baseline for i in 1 .. n do let d = AsyncHelpers.Await(Task.FromResult i) total <- total + d AsyncHelpers.Await(Task.Delay 1) if total > 0 then total else -1) + (12,5-18,41) StateMachineHelpers.__runtimeAsyncReturn ( let mutable total = baseline for i in 1 .. n do let d = AsyncHelpers.Await(Task.FromResult i) total <- total + d AsyncHelpers.Await(Task.Delay 1) if total > 0 then total else -1) IL_0010: ldarg.0 IL_0011: ldloc.1 IL_0012: newobj outer@12::.ctor diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index a8d49302063..1938d931f22 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -8,7 +8,7 @@ module Language.RuntimeAsyncEdgeCaseTests // pointed at concrete IL. Every asserted substring was captured from the PR's own fsc on the // pinned net11 preview and normalized the way ILChecker does ([System.Runtime] -> [runtime]). // -// IL facts that assert the *absence* of a token use direct StateMachineHelpers.__runtimeAsync +// IL facts that assert the *absence* of a token use direct StateMachineHelpers.__runtimeAsyncReturn // sources (single async method, clean assembly), because ILChecker's NotPresent check is // assembly-scoped and the CE builder's own inline members legitimately contain `tail.`/`MoveNext`. // The CE `Run` lowers `do!`/`let!` to exactly this intrinsic form (see the execution facts). @@ -27,7 +27,7 @@ let private runtimeAsyncDir = Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync") let private builderPath = Path.Combine(runtimeAsyncDir, "RuntimeTaskBuilder.fs") // Builds a minimal direct-intrinsic compilation unit: the module header plus the opens every -// StateMachineHelpers.__runtimeAsync body needs, then the supplied one-liner body. Used for the +// StateMachineHelpers.__runtimeAsyncReturn body needs, then the supplied one-liner body. Used for the // shape / absence / undiagnosed-pattern assertions, which must run on a single-method assembly. let private directIntrinsicSource body = String.concat "\n" [ @@ -40,7 +40,10 @@ let private directIntrinsicSource body = ] let private compileDirect body = - FSharp(directIntrinsicSource body) |> withLangVersionPreview |> compile + FSharp(directIntrinsicSource body) + |> withFSharpCoreShippedNet + |> withLangVersionPreview + |> compile // ---- CE-builder sources (compiled against RuntimeTaskBuilder.fs, the hypothetical library) ------- @@ -80,6 +83,7 @@ let ``runtime async edge cases execute through the CE builder`` () = FsFromPath builderPath |> withAdditionalSourceFile (SourceFromPath (Path.Combine(runtimeAsyncDir, "RuntimeAsyncEdgeCases.fs"))) |> withLangVersionPreview + |> withFSharpCoreShippedNet |> compileExeAndRun |> shouldSucceed @@ -138,19 +142,19 @@ let private valueTaskAwaitBody = """ // call line) shows the surrounding shape a runtime reviewer needs (arg load, no spill, no builder). [] let ``ValueTask operand binds the non-generic Await (full body)`` () = - compileDirect "let f (vt: ValueTask) : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(vt); 1)" + compileDirect "let f (vt: ValueTask) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(vt); 1)" |> verifyILContains [ valueTaskAwaitBody ] |> shouldSucceed [] let ``Task<'T> operand binds the generic Await (full body)`` () = - compileDirect "let f (t: Task) : Task = StateMachineHelpers.__runtimeAsync (let x = AsyncHelpers.Await(t) in x + 1)" + compileDirect "let f (t: Task) : Task = StateMachineHelpers.__runtimeAsyncReturn (let x = AsyncHelpers.Await(t) in x + 1)" |> verifyILContains [ genericAwaitBody ] |> shouldSucceed [] let ``suspension lowers to the full Await body with no compiler state machine`` () = - compileDirect "let f () : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(Task.Delay(1)); 1)" + compileDirect "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); 1)" |> verifyILContains [ simpleAwaitBody ] |> verifyILNotPresent [ "AsyncTaskMethodBuilder" @@ -163,6 +167,7 @@ let ``suspension lowers to the full Await body with no compiler state machine`` let ``the CE builder lowers to Await with no state machine`` () = FsFromPath builderPath |> withAdditionalSourceFile (FsSource ceStateMachineSource) + |> withFSharpCoreShippedNet |> withLangVersionPreview |> compile |> verifyILContains [ "AsyncHelpers::Await(class [runtime]System.Threading.Tasks.Task`1)" ] @@ -197,7 +202,7 @@ let private tailPrefixBody = """ [] let ``runtime async currently emits a forbidden tail prefix (C1)`` () = - compileDirect "let f (g: int -> int) (x: int) : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(Task.Delay(1)); g x)" + compileDirect "let f (g: int -> int) (x: int) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); g x)" |> verifyILContains [ tailPrefixBody ] |> shouldSucceed @@ -286,7 +291,7 @@ let private ceDisposalHoist = """ // MethodImplOptions.Async (0x2000) is a *method header* flag, not an IL instruction — neither the // ildasm we use nor the sequence-points decoder render it, so both the composed IL exhibit and the // sequence-points baseline show the lifted async body as an ordinary `outer@` closure. This -// reads it from metadata and pins the placement: the flag lands only on that lifted `__runtimeAsync` +// reads it from metadata and pins the placement: the flag lands only on that lifted `__runtimeAsyncReturn` // body and never leaks onto the user's own `outer`/`helper` methods just because the async part is // written lexically inside `outer`. Empirically the lifted `Invoke` is 0x2008 (async + noinlining). let private assertAsyncFlagOnLiftedClosureOnly (md: MetadataReader) = @@ -313,6 +318,7 @@ let ``composed CE body: await inside try, hoisted disposal, async flag on the li FsFromPath builderPath |> withAdditionalSourceFile (FsSource composedLayoutProgram) |> withLangVersionPreview + |> withFSharpCoreShippedNet |> compile |> shouldSucceed |> verifyILContains [ ceAwaitInsideTry; ceDisposalHoist ] @@ -334,7 +340,7 @@ let helper x = x * 2 let outer (n: int) : Task = let inner y = y + helper n let baseline = inner 10 - StateMachineHelpers.__runtimeAsync ( + StateMachineHelpers.__runtimeAsyncReturn ( let mutable total = baseline for i in 1 .. n do let d = AsyncHelpers.Await(Task.FromResult i) @@ -347,6 +353,7 @@ let outer (n: int) : Task = let ``composed runtime-async body: source-mapped IL (sequence points baseline)`` () = FSharp composedDirectProgram |> withLangVersionPreview + |> withFSharpCoreShippedNet |> withPortablePdb |> withNoOptimize |> compile @@ -361,13 +368,13 @@ let ``composed runtime-async body: source-mapped IL (sequence points baseline)`` // analogues at compile time (await-in-finally/catch; CS4007 for ref-struct; CS1988 for byref). [] [ = StateMachineHelpers.__runtimeAsync (try 1 finally AsyncHelpers.Await(Task.Delay(1)))")>] // runtime: fail-fast 0xC0000409 / SIGSEGV + "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (try 1 finally AsyncHelpers.Await(Task.Delay(1)))")>] // runtime: fail-fast 0xC0000409 / SIGSEGV [ = StateMachineHelpers.__runtimeAsync (try failwith \"boom\" with _ -> AsyncHelpers.Await(Task.Delay(1)); 7)")>] // runtime: crash + "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (try failwith \"boom\" with _ -> AsyncHelpers.Await(Task.Delay(1)); 7)")>] // runtime: crash [ = StateMachineHelpers.__runtimeAsync (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] // runtime: IndexOutOfRangeException (C14) + "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] // runtime: IndexOutOfRangeException (C14) [) : Task = StateMachineHelpers.__runtimeAsync (AsyncHelpers.Await(Task.Delay(1)); x)")>] // byref read after suspension; C# gives CS1988 + "let f (x: byref) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); x)")>] // byref read after suspension; C# gives CS1988 let ``contract-forbidden suspension pattern compiles with no diagnostic`` (_label: string) (body: string) = compileDirect body |> shouldSucceed From b645d985303deab625308bcdb598096774a33110 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 21 Aug 2026 13:14:54 +0200 Subject: [PATCH 15/59] rewrite runtime async exception handling blocks during optimization --- docs/runtime-async.md | 20 +-- src/Compiler/Optimize/Optimizer.fs | 169 ++++++++++++++++++ .../RuntimeAsync/RuntimeTaskBuilder.fs | 36 +--- .../RuntimeTasksAsyncDisposalException.fs | 41 ++++- .../Language/RuntimeAsyncEdgeCaseTests.fs | 49 ++--- .../Language/RuntimeAsyncTests.fs | 7 +- 6 files changed, 250 insertions(+), 72 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 2c9fa46a009..709e79dd298 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -45,11 +45,10 @@ call int32 AsyncHelpers::Await(Task) Known runtime restrictions (currently **not** diagnosed by the F# compiler): * `tail.` and `localloc` are forbidden. -* suspension cannot occur inside exception-handling regions. Awaiting in a - `try` body now works on the current runtime; awaiting inside a `finally` - handler compiles and then terminates the process at execution - (`0xC0000409`). See `RuntimeTasksAsyncDisposalException.fs`, which is - compile-only for this reason. +* generated suspension points cannot occur inside exception-handling regions. + Awaiting in a protected `try` body now works on the current runtime. Direct + intrinsic bodies rewrite suspending `catch`, filter, and `finally` + expressions so the suspension runs outside the EH region. C# avoids this by rewriting EH-region awaits at lowering time (see the Roslyn design doc): `try B finally { await x }` becomes @@ -128,11 +127,12 @@ FSharp.Core declaration. ## Optimization -`Optimizer.fs` preserves the marker application as-is, optimizing only its -argument. The marked expression is forced to `HasEffect = true` and -`UnknownValue`, so the optimizer never inlines, duplicates, or discards it. -The marker therefore survives optimization as an ordinary `Expr.App` node; -nothing else in the typed tree records that a method is runtime-async. +`Optimizer.fs` preserves the marker application as-is, optimizing its +argument and rewriting any suspending exception handlers in that argument. +The marked expression is forced to `HasEffect = true` and `UnknownValue`, so +the optimizer never inlines, duplicates, or discards it. The marker therefore +survives optimization as an ordinary `Expr.App` node; nothing else in the +typed tree records that a method is runtime-async. ## Code generation diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index 30fc0ed791e..3b0a8752130 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2490,6 +2490,174 @@ let shouldForceInlineInDebug cenv env (vref: ValRef) : bool = HasFrameLocalBody cenv env vref +let private IsRuntimeAsyncSuspensionExpr expr = + match stripExpr expr with + | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) -> + ilMethodRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" + && ilMethodRef.Name + |> function + | "Await" + | "AwaitAwaiter" + | "UnsafeAwaitAwaiter" -> true + | _ -> false + | _ -> false + +let private ExprContainsRuntimeAsyncSuspension expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc || IsRuntimeAsyncSuspensionExpr expr then + true + else + noInterceptF acc expr } + + FoldExpr folder false expr + +let private RuntimeAsyncChoiceTy (g: TcGlobals) (ty: TType) = + TType_app(g.choice2_tcr, [ ty; g.exn_ty ], g.knownWithoutNull) + +let private RuntimeAsyncChoiceCase g m ty caseIndex expr = + mkUnionCaseExpr(mkChoiceCaseRef g m 2 caseIndex, [ ty; g.exn_ty ], [ expr ], m) + +let private RuntimeAsyncReraise m resultTy exnExpr = + mkThrow m resultTy exnExpr + +let private RuntimeAsyncFilterCondition m resultTy filter thenExpr elseExpr = + let matchBuilder = MatchBuilder(DebugPointAtBinding.NoneAtInvisible, m) + let matchCase = TCase(DecisionTreeTest.Const(Const.Int32 1), matchBuilder.AddResultTarget thenExpr) + let defaultCase = matchBuilder.AddResultTarget elseExpr + let decisionTree = TDSwitch(filter, [ matchCase ], Some defaultCase, m) + matchBuilder.Close(decisionTree, m, resultTy) + +let private IsRuntimeAsyncExceptionHandler expr = + match stripExpr expr with + | TryFinallyExpr(_, _, _, _, compensation, _) -> + ExprContainsRuntimeAsyncSuspension compensation + | TryWithExpr(_, _, _, _, _, filter, _, handler, _) -> + ExprContainsRuntimeAsyncSuspension filter + || ExprContainsRuntimeAsyncSuspension handler + | _ -> false + +let private ExprContainsRuntimeAsyncExceptionHandler expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc || IsRuntimeAsyncExceptionHandler expr then + true + else + noInterceptF acc expr } + + FoldExpr folder false expr + +let private RewriteRuntimeAsyncExceptionHandlers cenv expr = + let g = cenv.g + + let rewriteCapturedException m resultTy body buildResult = + let choiceTy = RuntimeAsyncChoiceTy g resultTy + let resultVal, _ = mkCompGenLocal m "__runtimeAsyncResult" choiceTy + let caughtVal, _ = mkCompGenLocal m "__runtimeAsyncCaughtException" g.exn_ty + let captured = exprForVal m resultVal + let bodyValue = + mkUnionCaseFieldGetUnprovenViaExprAddr( + captured, + mkChoiceCaseRef g m 2 0, + [ resultTy; g.exn_ty ], + 0, + m + ) + let exceptionValue = + mkUnionCaseFieldGetUnprovenViaExprAddr( + captured, + mkChoiceCaseRef g m 2 1, + [ resultTy; g.exn_ty ], + 0, + m + ) + let bodySucceeded = + mkUnionCaseTest g ( + captured, + mkChoiceCaseRef g m 2 0, + [ resultTy; g.exn_ty ], + m + ) + let result = buildResult bodySucceeded bodyValue exceptionValue + + mkCompGenLet + m + resultVal + (mkTryWith + g + (RuntimeAsyncChoiceCase g m resultTy 0 body, + caughtVal, + mkTrue g m, + caughtVal, + RuntimeAsyncChoiceCase g m resultTy 1 (exprForVal m caughtVal), + m, + choiceTy, + DebugPointAtTry.No, + DebugPointAtWith.No)) + result + + let postTransform expr = + match expr with + | TryFinallyExpr(_, _, resultTy, body, compensation, m) when + IsRuntimeAsyncExceptionHandler expr -> + Some( + rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionValue -> + let result = + mkCond + DebugPointAtBinding.NoneAtInvisible + m + resultTy + bodySucceeded + bodyValue + (RuntimeAsyncReraise m resultTy exceptionValue) + + mkCompGenSequential m compensation result) + ) + | TryWithExpr(_, _, resultTy, body, filterVal, filter, handlerVal, handler, m) when + IsRuntimeAsyncExceptionHandler expr -> + Some( + rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionExpr -> + let filter = + mkCompGenLet + m + filterVal + exceptionExpr + (mkCompGenLet + m + handlerVal + exceptionExpr + (RuntimeAsyncFilterCondition + m + resultTy + filter + handler + (RuntimeAsyncReraise m resultTy exceptionExpr))) + + mkCond + DebugPointAtBinding.NoneAtInvisible + m + resultTy + bodySucceeded + bodyValue + filter) + ) + | _ -> None + + if ExprContainsRuntimeAsyncExceptionHandler expr then + RewriteExpr + { PreIntercept = None + PostTransform = postTransform + PreInterceptBinding = None + RewriteQuotations = false + StackGuard = StackGuard("RuntimeAsyncExceptionRewrite") } + expr + else + expr + /// Optimize/analyze an expression let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = cenv.stackGuard.Guard <| fun () -> @@ -2557,6 +2725,7 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App(Expr.Val(vref, flags, _), fty, [ _ ], [ body ], _) when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> let bodyR, bodyInfo = OptimizeExpr cenv env body + let bodyR = RewriteRuntimeAsyncExceptionHandlers cenv bodyR Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), { bodyInfo with HasEffect = true diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs index 60427d5a5d4..5181bf1869d 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs @@ -51,35 +51,17 @@ type RuntimeTaskBuilder() = member inline _.Combine(first: unit, [] second: unit -> 'T) = second() member inline _.TryWith([] body: unit -> 'T, [] handler: exn -> 'T) = try body() with error -> handler error - member inline _.TryFinally([] body: unit -> 'T, compensation: unit -> unit) = + member inline _.TryFinally([] body: unit -> 'T, [] compensation: unit -> unit) = try body() finally compensation() - member inline _.Using(resource: 'Resource, [] body: 'Resource -> 'T) = - // Awaiting in a finally region is forbidden by the runtime-async contract. - // Hoist the DisposeAsync suspension out of the region: capture any exception - // from the body in a catch-all, run disposal (possibly suspending) outside - // the handler, then restore the pending exception. Mirrors the Roslyn - // runtime-async lowering for `await` in `finally`. - let mutable pendingException: exn = null + member inline _.Using(resource, [] body) = + try + body resource + finally + match box resource with + | :? IAsyncDisposable as disposable -> AsyncHelpers.Await(disposable.DisposeAsync()) + | :? IDisposable as disposable -> disposable.Dispose() + | _ -> () - let result = - try - Choice1Of2(body resource) - with error -> - pendingException <- error - Choice2Of2() - - match box resource with - | :? IAsyncDisposable as disposable -> AsyncHelpers.Await(disposable.DisposeAsync()) - | :? IDisposable as disposable -> disposable.Dispose() - | _ -> () - - match pendingException with - | null -> () - | error -> raise error - - match result with - | Choice1Of2 value -> value - | Choice2Of2() -> Unchecked.defaultof<'T> member inline _.While(guard: unit -> bool, [] body: unit -> unit) = while guard() do body() member inline _.For(sequence: seq<'T>, [] body: 'T -> unit) = diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs index ab52169cca0..b3ee6986e6c 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs @@ -1,11 +1,4 @@ -// Minimal repro: suspending with AsyncHelpers.Await inside the *handler* of an -// exception-handling region of a __runtimeAsyncReturn method. This is what `use` on an -// IAsyncDisposable lowers to (the DisposeAsync await sits in the finally). -// -// Today this compiles cleanly but terminates the process at execution -// (0xC0000409), so the component test compiles this file without running it. -// Awaiting in the try *body* with a plain finally works; awaiting inside the -// finally itself does not. +// Direct runtime-async calls must move suspension points out of exception handlers. module RuntimeAsyncAwaitInExceptionRegion open System.Runtime.CompilerServices @@ -20,6 +13,36 @@ let run () : Task = AsyncHelpers.Await(Task.Delay(1)) ) +let runCatch () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + try + failwith "boom" + with + | _ -> + AsyncHelpers.Await(Task.Delay(1)) + 2 + ) + +let runFilter () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + try + try + raise (System.InvalidOperationException()) + with + | :? System.InvalidOperationException when (AsyncHelpers.Await(Task.Delay(1)); false) -> + 2 + with + | :? System.InvalidOperationException -> 3 + ) + [] let main _ = - if (run ()).GetAwaiter().GetResult() = 1 then 0 else 1 + let first = run () + let second = runCatch () + let third = runFilter () + let results = + [| first.GetAwaiter().GetResult() + second.GetAwaiter().GetResult() + third.GetAwaiter().GetResult() |] + + if results = [| 1; 2; 3 |] then 0 else 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 1938d931f22..11b03779f72 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -253,8 +253,8 @@ let private ceAwaitInsideTry = """ { IL_0039: ldc.i4.1 IL_003a: call class [System.Runtime]System.Threading.Tasks.Task [System.Runtime]System.Threading.Tasks.Task::Delay(int32) - IL_003f: stloc.s V_9 - IL_0041: ldloc.s V_9 + IL_003f: stloc.s V_8 + IL_0041: ldloc.s V_8 IL_0043: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task) IL_0048: ldloc.0 IL_0049: ldc.i4.1 @@ -273,19 +273,19 @@ let private ceAwaitInsideTry = """ } // end handler """ -// (2) `use` disposal emitted AFTER the protected region: the builder hoists the awaited DisposeAsync -// out of the finally — isinst IAsyncDisposable -> DisposeAsync() -> Await(ValueTask). +// (2) `use` disposal emitted AFTER the protected region: the compiler rewrite hoists the awaited +// DisposeAsync out of the finally — isinst IAsyncDisposable -> DisposeAsync() -> Await(ValueTask). let private ceDisposalHoist = """ - IL_0089: isinst [System.Runtime]System.IAsyncDisposable - IL_008e: stloc.s V_12 - IL_0090: ldloc.s V_12 - IL_0092: brfalse.s IL_00a6 - - IL_0094: ldloc.s V_12 - IL_0096: stloc.s V_13 - IL_0098: ldloc.s V_13 - IL_009a: callvirt instance valuetype [System.Runtime]System.Threading.Tasks.ValueTask [System.Runtime]System.IAsyncDisposable::DisposeAsync() - IL_009f: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(valuetype [System.Runtime]System.Threading.Tasks.ValueTask) + IL_0086: isinst [System.Runtime]System.IAsyncDisposable + IL_008b: stloc.s V_11 + IL_008d: ldloc.s V_11 + IL_008f: brfalse.s IL_00a3 + + IL_0091: ldloc.s V_11 + IL_0093: stloc.s V_12 + IL_0095: ldloc.s V_12 + IL_0097: callvirt instance valuetype [System.Runtime]System.Threading.Tasks.ValueTask [System.Runtime]System.IAsyncDisposable::DisposeAsync() + IL_009c: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(valuetype [System.Runtime]System.Threading.Tasks.ValueTask) """ // MethodImplOptions.Async (0x2000) is a *method header* flag, not an IL instruction — neither the @@ -361,16 +361,23 @@ let ``composed runtime-async body: source-mapped IL (sequence points baseline)`` |> verifySequencePointsBaseline composedDirectProgram (Path.Combine(runtimeAsyncDir, "ComposedRuntimeAsync.bsl")) |> withMetadataReader assertAsyncFlagOnLiftedClosureOnly - -// Each pattern is contract-forbidden but compiles with NO diagnostic today; docs/runtime-async.md -// records them as known, currently-undiagnosed restrictions. Not executed here (the observed runtime -// result is a hard process crash); the row comments record the observed symptom. C# rejects the -// analogues at compile time (await-in-finally/catch; CS4007 for ref-struct; CS1988 for byref). [] [ = StateMachineHelpers.__runtimeAsyncReturn (try 1 finally AsyncHelpers.Await(Task.Delay(1)))")>] // runtime: fail-fast 0xC0000409 / SIGSEGV + "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (try 1 finally AsyncHelpers.Await(Task.Delay(1))) in f().Result |> ignore")>] [ = StateMachineHelpers.__runtimeAsyncReturn (try failwith \"boom\" with _ -> AsyncHelpers.Await(Task.Delay(1)); 7)")>] // runtime: crash + "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (try failwith \"boom\" with _ -> AsyncHelpers.Await(Task.Delay(1)); 7) in f().Result |> ignore")>] +let ``exception handling block suspensions compile and run correctly`` (_label: string) (body: string) = + FSharp(directIntrinsicSource body) + |> withFSharpCoreShippedNet + |> withLangVersionPreview + |> compileExeAndRun + |> shouldSucceed + + + +// These direct-intrinsic restrictions remain undiagnosed; exception handlers are rewritten before +// code generation and are covered by the execution test above. +[] [ = StateMachineHelpers.__runtimeAsyncReturn (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] // runtime: IndexOutOfRangeException (C14) [ shouldSucceed [] -// Minimal repro: awaiting inside an exception-handling region. Compilation -// succeeds, but executing the fixture currently terminates the process with -// 0xC0000409 (suspension in EH regions is forbidden by the runtime contract). -let ``runtime async suspension in exception region compiles (runtime execution is failing)`` () = +let ``runtime async suspension in exception region executes`` () = Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasksAsyncDisposalException.fs") |> FsFromPath |> withLangVersionPreview |> withFSharpCoreShippedNet - |> compile + |> compileExeAndRun |> shouldSucceed #else From d50c33c057be8f730ad3f390de5a5c945c9684ad Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 21 Aug 2026 19:10:04 +0200 Subject: [PATCH 16/59] fix surface area --- src/FSharp.Core/resumable.fs | 2 +- src/FSharp.Core/resumable.fsi | 2 +- .../FSharp.Core.SurfaceArea.netcore.debug.bsl | 2716 +++++++++++++++++ ...Sharp.Core.SurfaceArea.netcore.release.bsl | 2715 ++++++++++++++++ tests/FSharp.Core.UnitTests/SurfaceArea.fs | 2 +- 5 files changed, 5434 insertions(+), 3 deletions(-) create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl create mode 100644 tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl diff --git a/src/FSharp.Core/resumable.fs b/src/FSharp.Core/resumable.fs index 1315b79ee99..defdfd39964 100644 --- a/src/FSharp.Core/resumable.fs +++ b/src/FSharp.Core/resumable.fs @@ -111,7 +111,7 @@ module StateMachineHelpers = failwith "__stateMachine should always be guarded by __useResumableCode and only used in valid state machine implementations" -#if NET10_0 +#if NET [] let __runtimeAsyncReturn (value: 'T) : Task<'T> = ignore value diff --git a/src/FSharp.Core/resumable.fsi b/src/FSharp.Core/resumable.fsi index ba3d18422e8..439b1234639 100644 --- a/src/FSharp.Core/resumable.fsi +++ b/src/FSharp.Core/resumable.fsi @@ -194,7 +194,7 @@ module StateMachineHelpers = afterCode: AfterCode<'Data, 'Result> -> 'Result -#if NET10_0 +#if NET /// Marks an expression result for lowering as a .NET runtime-async method. /// This function is compiler-recognised and must not be called directly. [] diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl new file mode 100644 index 00000000000..7d32ca31c24 --- /dev/null +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl @@ -0,0 +1,2716 @@ +! AssemblyReference: System.Runtime.Numerics +! AssemblyReference: netstandard +Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,]) +Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,]) +Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T) +Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]) +Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]) +Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,]) +Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,]) +Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T) +Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,]) +Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]) +Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]]) +Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T1[],T2[]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Average[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Max[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Min[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Sum[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult ReduceBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortDescending[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Sort[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void SortInPlace[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][]) +Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32) +Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T RandomChoiceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], T[]) +Microsoft.FSharp.Collections.ArrayModule: T RandomChoiceWith[T](System.Random, T[]) +Microsoft.FSharp.Collections.ArrayModule: T RandomChoice[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState) +Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState) +Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[]) +Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState) +Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]]) +Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T) +Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]() +Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32) +Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomChoicesBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomChoicesWith[T](System.Random, Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomChoices[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomSampleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomSampleWith[T](System.Random, Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomSample[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomShuffleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomShuffleWith[T](System.Random, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomShuffle[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T) +Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T) +Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState) +Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32) +Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]]) +Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32) +Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T) +Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void RandomShuffleInPlaceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void RandomShuffleInPlaceWith[T](System.Random, T[]) +Microsoft.FSharp.Collections.ArrayModule: Void RandomShuffleInPlace[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T) +Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[]) +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]]) +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]() +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]() +Microsoft.FSharp.Collections.FSharpList: Microsoft.FSharp.Collections.FSharpList`1[T] Create[T](System.ReadOnlySpan`1[T]) +Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons +Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons() +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty() +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length() +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag() +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T] +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty() +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail() +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull() +Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString() +Microsoft.FSharp.Collections.FSharpList`1[T]: T Head +Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault +Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32] +Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head() +Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault() +Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32) +Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]]) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey] +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]]) +Microsoft.FSharp.Collections.FSharpSet: Microsoft.FSharp.Collections.FSharpSet`1[T] Create[T](System.ReadOnlySpan`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count +Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString() +Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement +Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement +Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement() +Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]() +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]() +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]() +Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]() +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomChoicesBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomChoicesWith[T](System.Random, Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomChoices[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomSampleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomSampleWith[T](System.Random, Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomSample[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomShuffleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomShuffleWith[T](System.Random, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomShuffle[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]]) +Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32) +Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T RandomChoiceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T RandomChoiceWith[T](System.Random, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T RandomChoice[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState) +Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState) +Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]() +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState) +Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]() +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomChoicesBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomChoicesWith[T](System.Random, Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomChoices[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomSampleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomSampleWith[T](System.Random, Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomSample[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomShuffleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomShuffleWith[T](System.Random, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomShuffle[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState) +Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T RandomChoiceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T RandomChoiceWith[T](System.Random, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T RandomChoice[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState) +Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState) +Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]() +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T1],Microsoft.FSharp.Collections.FSharpSet`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState) +Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested +Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested() +Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation() +Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T) +Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T) +Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised() +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty() +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn]) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.Await.Static$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], TTaskLike) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.Await.Static[TTaskLike,TAwaiter,T](TTaskLike) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.StartTaskImmediate.Static$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,TTaskLike]) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.StartTaskImmediate.Static[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,TTaskLike]) +Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32) +Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T]) +Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Await(System.Threading.Tasks.Task) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Await(System.Threading.Tasks.ValueTask) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] StartTaskImmediate(Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] StartTaskImmediate(Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread() +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool() +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken() +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken +Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken() +Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken() +Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero() +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply) +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish() +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor() +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[]) +Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish +Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish() +Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor() +Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T) +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish() +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor() +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs) +Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object) +Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] StartImmediate(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] StartImmediate(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Dispose() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void StartImmediate() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32) +Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate) +Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate) +Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T) +Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T]) +Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]() +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Using[TResource,TOverall,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask() +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task() +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty() +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T) +Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder +Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Empty +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] get_Empty() +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.ValueTask`1[TResult]], System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] OfTask[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] Result[T](T) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri) +Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor() +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value() +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor() +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path +Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path() +Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor() +Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value +Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value() +Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In +Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut +Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out +Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor() +Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor() +Microsoft.FSharp.Core.ClassAttribute: Void .ctor() +Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts +Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts() +Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[]) +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber() +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber() +Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags +Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags() +Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName +Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName() +Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions +Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions() +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags) +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32) +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32) +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[]) +Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags +Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags() +Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags) +Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__ +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue +Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName +Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName() +Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName +Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName() +Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError() +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden() +Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber +Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber() +Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message +Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message() +Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32) +Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean) +Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close() +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T) +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef) +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close() +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces() +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName() +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String) +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes() +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint() +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data() +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[]) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces() +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[]) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[]) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler) +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close() +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T) +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]() +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]() +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint +Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo +Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc() +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData() +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateTryWith[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Collections.Generic.IEnumerable`1[T]]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName() +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean]) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]]) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[]) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32) +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32) +Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__ +Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased +Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate +Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText +Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText() +Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor() +Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind() +Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord +Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name +Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord() +Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name() +Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor() +Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean) +Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value +Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value() +Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check +Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check() +Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor() +Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor() +Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor() +Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message +Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message() +Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder() +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query() +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query +Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) +Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2 +Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2 +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2 +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2 +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2] +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2] +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2] +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2) +Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3 +Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3 +Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3) +Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4 +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4 +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4 +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4) +Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5) +Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6) +Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor() +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X) +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major() +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor() +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release() +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32) +Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None +Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T] +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T) +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None() +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T) +Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString() +Microsoft.FSharp.Core.FSharpOption`1[T]: T Value +Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value() +Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T]) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T]) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: T Value +Microsoft.FSharp.Core.FSharpRef`1[T]: T contents +Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@ +Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value() +Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents() +Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T) +Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T) +Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T) +Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error +Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError] +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue() +Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]() +Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor() +Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone +Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T] +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value() +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult]) +Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor() +Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor() +Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString() +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]() +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit() +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit() +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte) +Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double) +Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T) +Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64) +Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr) +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators +Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte) +Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single) +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32) +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer() +Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal) +Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32) +Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32) +Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32) +Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]() +Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]() +Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]() +Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]() +Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16) +Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32) +Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64) +Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr) +Microsoft.FSharp.Core.LiteralAttribute: Void .ctor() +Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Exception, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object) +Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.MatchFailureException: Int32 Data1 +Microsoft.FSharp.Core.MatchFailureException: Int32 Data2 +Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode() +Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1() +Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2() +Microsoft.FSharp.Core.MatchFailureException: System.String Data0 +Microsoft.FSharp.Core.MatchFailureException: System.String Message +Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0() +Microsoft.FSharp.Core.MatchFailureException: System.String get_Message() +Microsoft.FSharp.Core.MatchFailureException: Void .ctor() +Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32) +Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor() +Microsoft.FSharp.Core.MeasureAttribute: Void .ctor() +Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor() +Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor() +Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor() +Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]() +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]() +Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32) +Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T) +Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T) +Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T) +Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T) +Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T) +Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T) +Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T) +Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T) +Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T) +Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T) +Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T) +Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T) +Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T) +Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T) +Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T) +Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T) +Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T) +Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T) +Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]() +Microsoft.FSharp.Core.Operators+Unchecked: T NonNullQuickPattern[T](T) +Microsoft.FSharp.Core.Operators+Unchecked: T NonNull[T](T) +Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object) +Microsoft.FSharp.Core.Operators+Unchecked: T WithNull[T](T) +Microsoft.FSharp.Core.Operators: Boolean IsNullV[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T) +Microsoft.FSharp.Core.Operators: Boolean Not(Boolean) +Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T) +Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.Operators: Byte ToByte[T](T) +Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T) +Microsoft.FSharp.Core.Operators: Char ToChar[T](T) +Microsoft.FSharp.Core.Operators: Double Infinity +Microsoft.FSharp.Core.Operators: Double NaN +Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T) +Microsoft.FSharp.Core.Operators: Double ToDouble[T](T) +Microsoft.FSharp.Core.Operators: Double get_Infinity() +Microsoft.FSharp.Core.Operators: Double get_NaN() +Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T) +Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T) +Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T) +Microsoft.FSharp.Core.Operators: Int32 Hash[T](T) +Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators: Int32 Sign[T](T) +Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]() +Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T) +Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T) +Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T) +Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T) +Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T) +Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T) +Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.Unit,T] NullMatchPattern[T](T) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.Unit,T] NullValueMatchPattern[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked +Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T) +Microsoft.FSharp.Core.Operators: Single InfinitySingle +Microsoft.FSharp.Core.Operators: Single NaNSingle +Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T) +Microsoft.FSharp.Core.Operators: Single ToSingle[T](T) +Microsoft.FSharp.Core.Operators: Single get_InfinitySingle() +Microsoft.FSharp.Core.Operators: Single get_NaNSingle() +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T) +Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T) +Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T) +Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String) +Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]() +Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]() +Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]() +Microsoft.FSharp.Core.Operators: System.Nullable`1[T] NullV[T]() +Microsoft.FSharp.Core.Operators: System.Nullable`1[T] WithNullV[T](T) +Microsoft.FSharp.Core.Operators: System.Object Box[T](T) +Microsoft.FSharp.Core.Operators: System.RuntimeMethodHandle MethodHandleOf[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.Operators: System.String NameOf[T](T) +Microsoft.FSharp.Core.Operators: System.String ToString[T](T) +Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String) +Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue]) +Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]() +Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]() +Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Abs[T](T) +Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Acos[T](T) +Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Asin[T](T) +Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Atan[T](T) +Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Ceiling[T](T) +Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Cos[T](T) +Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Cosh[T](T) +Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T) +Microsoft.FSharp.Core.Operators: T DefaultIfNullV[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: T DefaultIfNull[T](T, T) +Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T) +Microsoft.FSharp.Core.Operators: T Exit[T](Int32) +Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Exp[T](T) +Microsoft.FSharp.Core.Operators: T FailWith[T](System.String) +Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Floor[T](T) +Microsoft.FSharp.Core.Operators: T Identity[T](T) +Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String) +Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String) +Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Log10[T](T) +Microsoft.FSharp.Core.Operators: T Log[T](T) +Microsoft.FSharp.Core.Operators: T Max[T](T, T) +Microsoft.FSharp.Core.Operators: T Min[T](T, T) +Microsoft.FSharp.Core.Operators: T NonNullQuickPattern[T](T) +Microsoft.FSharp.Core.Operators: T NonNullQuickValuePattern[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: T NonNullV[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: T NonNull[T](T) +Microsoft.FSharp.Core.Operators: T NullArgCheck[T](System.String, T) +Microsoft.FSharp.Core.Operators: T NullArg[T](System.String) +Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32) +Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32) +Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception) +Microsoft.FSharp.Core.Operators: T Reraise[T]() +Microsoft.FSharp.Core.Operators: T Rethrow[T]() +Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Round[T](T) +Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Sin[T](T) +Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Sinh[T](T) +Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Tan[T](T) +Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Tanh[T](T) +Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Truncate[T](T) +Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object) +Microsoft.FSharp.Core.Operators: T WithNull[T](T) +Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T) +Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T) +Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T]) +Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T) +Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult) +Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32) +Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32) +Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T) +Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32) +Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32) +Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T) +Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T) +Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1) +Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1) +Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T) +Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T) +Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32) +Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2) +Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3) +Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T) +Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]) +Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]]) +Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult]) +Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T) +Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T) +Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T) +Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T) +Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T) +Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T) +Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32]) +Microsoft.FSharp.Core.Operators: Void Ignore[T](T) +Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32]) +Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult] +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult] +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult] +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult] +Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfValueOption[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState) +Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String) +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[]) +Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String) +Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor() +Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue() +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor() +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor() +Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor() +Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState) +Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.SealedAttribute: Boolean Value +Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value() +Microsoft.FSharp.Core.SealedAttribute: Void .ctor() +Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__ +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value +Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String) +Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String) +Microsoft.FSharp.Core.StringModule: Int32 Length(System.String) +Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String) +Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String]) +Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String) +Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String]) +Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String) +Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String) +Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String) +Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String) +Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String) +Microsoft.FSharp.Core.StructAttribute: Void .ctor() +Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor() +Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value +Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value() +Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.TailCallAttribute: Void .ctor() +Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object) +Microsoft.FSharp.Core.Unit: Int32 GetHashCode() +Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor() +Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfOption[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState) +Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor() +Microsoft.FSharp.Core.WarnOnWithoutNullArgumentAttribute: System.String WarningMessage +Microsoft.FSharp.Core.WarnOnWithoutNullArgumentAttribute: System.String get_WarningMessage() +Microsoft.FSharp.Core.WarnOnWithoutNullArgumentAttribute: Void .ctor(System.String) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T) +Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]() +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32) +Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: Void .ctor() +Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]]) +Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source +Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source() +Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8) +Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T) +Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]() +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object) +Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode() +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes() +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars() +Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString() +Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean) +Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type +Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type() +Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[]) +Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[]) +Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw +Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw() +Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object) +Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable +Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable() +Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode() +Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type) +Microsoft.FSharp.Quotations.FSharpVar: System.String Name +Microsoft.FSharp.Quotations.FSharpVar: System.String ToString() +Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name() +Microsoft.FSharp.Quotations.FSharpVar: System.Type Type +Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type() +Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo) +Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object) +Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32) +Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object) +Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode() +Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag +Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type) +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name +Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType() \ No newline at end of file diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl new file mode 100644 index 00000000000..ceaf3d54fae --- /dev/null +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl @@ -0,0 +1,2715 @@ +! AssemblyReference: System.Runtime.Numerics +! AssemblyReference: netstandard +Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: Int32 Length2[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: T Get[T](T[,], Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: TResult[,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]], T[,]) +Microsoft.FSharp.Collections.Array2DModule: TResult[,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,]) +Microsoft.FSharp.Collections.Array2DModule: T[,] Copy[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: T[,] CreateBased[T](Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array2DModule: T[,] Create[T](Int32, Int32, T) +Microsoft.FSharp.Collections.Array2DModule: T[,] InitializeBased[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]) +Microsoft.FSharp.Collections.Array2DModule: T[,] Initialize[T](Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]) +Microsoft.FSharp.Collections.Array2DModule: T[,] Rebase[T](T[,]) +Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreateBased[T](Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: T[,] ZeroCreate[T](Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: Void CopyTo[T](T[,], Int32, Int32, T[,], Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array2DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]], T[,]) +Microsoft.FSharp.Collections.Array2DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,]) +Microsoft.FSharp.Collections.Array2DModule: Void Set[T](T[,], Int32, Int32, T) +Microsoft.FSharp.Collections.Array3DModule: Int32 Length1[T](T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Int32 Length2[T](T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Int32 Length3[T](T[,,]) +Microsoft.FSharp.Collections.Array3DModule: T Get[T](T[,,], Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array3DModule: TResult[,,] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]]]], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: TResult[,,] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: T[,,] Create[T](Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array3DModule: T[,,] Initialize[T](Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]) +Microsoft.FSharp.Collections.Array3DModule: T[,,] ZeroCreate[T](Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array3DModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]]]], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[,,]) +Microsoft.FSharp.Collections.Array3DModule: Void Set[T](T[,,], Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length1[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length2[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length3[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: Int32 Length4[T](T[,,,]) +Microsoft.FSharp.Collections.Array4DModule: T Get[T](T[,,,], Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array4DModule: T[,,,] Create[T](Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.Array4DModule: T[,,,] Initialize[T](Int32, Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]]]]) +Microsoft.FSharp.Collections.Array4DModule: T[,,,] ZeroCreate[T](Int32, Int32, Int32, Int32) +Microsoft.FSharp.Collections.Array4DModule: Void Set[T](T[,,,], Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T1[],T2[]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Average[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Max[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Min[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T Sum[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult ReduceBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortDescending[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: T[] Sort[T](T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule+Parallel: Void SortInPlace[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean Contains[T](T, T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Boolean IsEmpty[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[], T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Int32 Length[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.ArrayModule+Parallel +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[System.Int32,T][] Indexed[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T,T][] Pairwise[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] AllPairs[T1,T2](T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1,T2][] Zip[T1,T2](T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T1[],T2[]] Unzip[T1,T2](System.Tuple`2[T1,T2][]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,System.Int32][] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TKey,T[]][] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], T[], TState) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[TResult[],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`2[T[],T[]] SplitAt[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1,T2,T3][] Zip3[T1,T2,T3](T1[], T2[], T3[]) +Microsoft.FSharp.Collections.ArrayModule: System.Tuple`3[T1[],T2[],T3[]] Unzip3[T1,T2,T3](System.Tuple`3[T1,T2,T3][]) +Microsoft.FSharp.Collections.ArrayModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Average[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T ExactlyOne[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Get[T](T[], Int32) +Microsoft.FSharp.Collections.ArrayModule: T Head[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T Item[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T Last[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Max[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Min[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T RandomChoiceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], T[]) +Microsoft.FSharp.Collections.ArrayModule: T RandomChoiceWith[T](System.Random, T[]) +Microsoft.FSharp.Collections.ArrayModule: T RandomChoice[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T Sum[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult[]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1[], T2[], T3[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], T[]) +Microsoft.FSharp.Collections.ArrayModule: TResult[] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T[]) +Microsoft.FSharp.Collections.ArrayModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], T1[], T2[], TState) +Microsoft.FSharp.Collections.ArrayModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState) +Microsoft.FSharp.Collections.ArrayModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[]) +Microsoft.FSharp.Collections.ArrayModule: TState[] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], T[], TState) +Microsoft.FSharp.Collections.ArrayModule: TState[] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Append[T](T[], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Concat[T](System.Collections.Generic.IEnumerable`1[T[]]) +Microsoft.FSharp.Collections.ArrayModule: T[] Copy[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Create[T](Int32, T) +Microsoft.FSharp.Collections.ArrayModule: T[] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Distinct[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Empty[T]() +Microsoft.FSharp.Collections.ArrayModule: T[] Except[T](System.Collections.Generic.IEnumerable`1[T], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] GetSubArray[T](T[], Int32, Int32) +Microsoft.FSharp.Collections.ArrayModule: T[] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.ArrayModule: T[] InsertAt[T](Int32, T, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ArrayModule: T[] OfSeq[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.ArrayModule: T[] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomChoicesBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomChoicesWith[T](System.Random, Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomChoices[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomSampleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomSampleWith[T](System.Random, Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomSample[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomShuffleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomShuffleWith[T](System.Random, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RandomShuffle[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RemoveAt[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] RemoveManyAt[T](Int32, Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Replicate[T](Int32, T) +Microsoft.FSharp.Collections.ArrayModule: T[] Reverse[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Singleton[T](T) +Microsoft.FSharp.Collections.ArrayModule: T[] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Skip[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortDescending[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Sort[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Tail[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Take[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Truncate[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState) +Microsoft.FSharp.Collections.ArrayModule: T[] UpdateAt[T](Int32, T, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], T[]) +Microsoft.FSharp.Collections.ArrayModule: T[] ZeroCreate[T](Int32) +Microsoft.FSharp.Collections.ArrayModule: T[][] ChunkBySize[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[][] SplitInto[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: T[][] Transpose[T](System.Collections.Generic.IEnumerable`1[T[]]) +Microsoft.FSharp.Collections.ArrayModule: T[][] Windowed[T](Int32, T[]) +Microsoft.FSharp.Collections.ArrayModule: Void CopyTo[T](T[], Int32, T[], Int32, Int32) +Microsoft.FSharp.Collections.ArrayModule: Void Fill[T](T[], Int32, Int32, T) +Microsoft.FSharp.Collections.ArrayModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], T1[], T2[]) +Microsoft.FSharp.Collections.ArrayModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void RandomShuffleInPlaceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void RandomShuffleInPlaceWith[T](System.Random, T[]) +Microsoft.FSharp.Collections.ArrayModule: Void RandomShuffleInPlace[T](T[]) +Microsoft.FSharp.Collections.ArrayModule: Void Set[T](T[], Int32, T) +Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void SortInPlaceWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], T[]) +Microsoft.FSharp.Collections.ArrayModule: Void SortInPlace[T](T[]) +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] FromFunction[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]]) +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] NonStructural[T]() +Microsoft.FSharp.Collections.ComparisonIdentity: System.Collections.Generic.IComparer`1[T] Structural[T]() +Microsoft.FSharp.Collections.FSharpList: Microsoft.FSharp.Collections.FSharpList`1[T] Create[T](System.ReadOnlySpan`1[T]) +Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Cons +Microsoft.FSharp.Collections.FSharpList`1+Tags[T]: Int32 Empty +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(Microsoft.FSharp.Collections.FSharpList`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsCons +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean IsEmpty +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsCons() +Microsoft.FSharp.Collections.FSharpList`1[T]: Boolean get_IsEmpty() +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 GetReverseIndex(Int32, Int32) +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Length +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 Tag +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Length() +Microsoft.FSharp.Collections.FSharpList`1[T]: Int32 get_Tag() +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1+Tags[T] +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Cons(T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Empty +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] GetSlice(Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Tail +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] TailOrNull +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Empty() +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_Tail() +Microsoft.FSharp.Collections.FSharpList`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] get_TailOrNull() +Microsoft.FSharp.Collections.FSharpList`1[T]: System.String ToString() +Microsoft.FSharp.Collections.FSharpList`1[T]: T Head +Microsoft.FSharp.Collections.FSharpList`1[T]: T HeadOrDefault +Microsoft.FSharp.Collections.FSharpList`1[T]: T Item [Int32] +Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Head() +Microsoft.FSharp.Collections.FSharpList`1[T]: T get_HeadOrDefault() +Microsoft.FSharp.Collections.FSharpList`1[T]: T get_Item(Int32) +Microsoft.FSharp.Collections.FSharpList`1[T]: Void .ctor(T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean ContainsKey(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean Equals(System.Object) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean IsEmpty +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean TryGetValue(TKey, TValue ByRef) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Boolean get_IsEmpty() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 Count +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 GetHashCode() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Int32 get_Count() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Add(TKey, TValue) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Change(TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[TValue],Microsoft.FSharp.Core.FSharpOption`1[TValue]]) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue] Remove(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Microsoft.FSharp.Core.FSharpOption`1[TValue] TryFind(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] Keys +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TKey] get_Keys() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] Values +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.Collections.Generic.ICollection`1[TValue] get_Values() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: System.String ToString() +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue Item [TKey] +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: TValue get_Item(TKey) +Microsoft.FSharp.Collections.FSharpMap`2[TKey,TValue]: Void .ctor(System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]]) +Microsoft.FSharp.Collections.FSharpSet: Microsoft.FSharp.Collections.FSharpSet`1[T] Create[T](System.ReadOnlySpan`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Contains(T) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsEmpty +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsProperSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSubsetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean IsSupersetOf(Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Boolean get_IsEmpty() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 Count +Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Int32 get_Count() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Add(T) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove(T) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Addition(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: Microsoft.FSharp.Collections.FSharpSet`1[T] op_Subtraction(Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.FSharpSet`1[T]: System.String ToString() +Microsoft.FSharp.Collections.FSharpSet`1[T]: T MaximumElement +Microsoft.FSharp.Collections.FSharpSet`1[T]: T MinimumElement +Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MaximumElement() +Microsoft.FSharp.Collections.FSharpSet`1[T]: T get_MinimumElement() +Microsoft.FSharp.Collections.FSharpSet`1[T]: Void .ctor(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] FromFunctions[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] LimitedStructural[T](Int32) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] NonStructural[T]() +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Reference[T]() +Microsoft.FSharp.Collections.HashIdentity: System.Collections.Generic.IEqualityComparer`1[T] Structural[T]() +Microsoft.FSharp.Collections.ListModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Int32 Length[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] ChunkBySize[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] SplitInto[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Transpose[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[T]] Windowed[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Int32,T]] Indexed[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T,T]] Pairwise[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]] Zip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,Microsoft.FSharp.Collections.FSharpList`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Collect[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Collections.FSharpList`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], Microsoft.FSharp.Collections.FSharpList`1[T3]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Concat[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpList`1[T]]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Distinct[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Empty[T]() +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfArray[T](T[]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomChoicesBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomChoicesWith[T](System.Random, Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomChoices[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomSampleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomSampleWith[T](System.Random, Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomSample[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomShuffleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomShuffleWith[T](System.Random, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RandomShuffle[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] RemoveManyAt[T](Int32, Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Replicate[T](Int32, T) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Reverse[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Singleton[T](T) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Skip[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortDescending[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Sort[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Tail[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Take[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Truncate[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Unfold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] UpdateAt[T](Int32, T, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Collections.FSharpList`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2]] Unzip[T1,T2](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[T1,T2]]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T], TState) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[T],Microsoft.FSharp.Collections.FSharpList`1[T]] SplitAt[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: System.Tuple`3[Microsoft.FSharp.Collections.FSharpList`1[T1],Microsoft.FSharp.Collections.FSharpList`1[T2],Microsoft.FSharp.Collections.FSharpList`1[T3]] Unzip3[T1,T2,T3](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`3[T1,T2,T3]]) +Microsoft.FSharp.Collections.ListModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Average[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T ExactlyOne[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Get[T](Microsoft.FSharp.Collections.FSharpList`1[T], Int32) +Microsoft.FSharp.Collections.ListModule: T Head[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Item[T](Int32, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Last[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Max[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Min[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T RandomChoiceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T RandomChoiceWith[T](System.Random, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T RandomChoice[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T Sum[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2], TState) +Microsoft.FSharp.Collections.ListModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpList`1[T], TState) +Microsoft.FSharp.Collections.ListModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], Microsoft.FSharp.Collections.FSharpList`1[T1], Microsoft.FSharp.Collections.FSharpList`1[T2]) +Microsoft.FSharp.Collections.ListModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.ListModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.MapModule: Boolean ContainsKey[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Boolean Exists[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Boolean ForAll[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Boolean IsEmpty[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Int32 Count[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]] ToList[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,TResult] Map[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Add[TKey,T](TKey, T, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Change[TKey,T](TKey, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[T],Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Empty[TKey,T]() +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Filter[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfArray[TKey,T](System.Tuple`2[TKey,T][]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfList[TKey,T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[TKey,T]]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] OfSeq[TKey,T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Collections.FSharpMap`2[TKey,T] Remove[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TKey] TryFindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[TKey] Keys[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.ICollection`1[T] Values[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,T]] ToSeq[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[TKey,T],Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]] Partition[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MaxKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T] MinKeyValue[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: System.Tuple`2[TKey,T][] ToArray[TKey,T](Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: T Find[TKey,T](TKey, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: TKey FindKey[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: TResult Pick[TKey,T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: TState FoldBack[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T], TState) +Microsoft.FSharp.Collections.MapModule: TState Fold[TKey,T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]]], TState, Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.MapModule: Void Iterate[TKey,T](Microsoft.FSharp.Core.FSharpFunc`2[TKey,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Collections.FSharpMap`2[TKey,T]) +Microsoft.FSharp.Collections.SeqModule: Boolean Contains[T](T, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Boolean Exists2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Boolean ForAll2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,System.Boolean]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Boolean IsEmpty[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 CompareWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 FindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 FindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Int32 Length[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndexBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] TryFindIndex[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] TryPick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryExactlyOne[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryFind[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryHead[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryItem[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Microsoft.FSharp.Core.FSharpOption`1[T] TryLast[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Collections.Generic.IEnumerable`1[T]] Transpose[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.Int32,T]] Indexed[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T,T]] Pairwise[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] AllPairs[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[T1,T2]] Zip[T1,T2](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Collections.Generic.IEnumerable`1[T]]] GroupBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,System.Int32]] CountBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[System.Tuple`3[T1,T2,T3]] Zip3[T1,T2,T3](System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Collect[T,TCollection,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], System.Collections.Generic.IEnumerable`1[T3]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] MapIndexed[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] ScanBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[TState] Scan[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] ChunkBySize[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] SplitInto[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T[]] Windowed[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Append[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cache[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Cast[T](System.Collections.IEnumerable) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Concat[TCollection,T](System.Collections.Generic.IEnumerable`1[TCollection]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Collections.Generic.IEnumerable`1[T]]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] DistinctBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Distinct[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Empty[T]() +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Except[T](System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InitializeInfinite[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Initialize[T](Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] InsertManyAt[T](Int32, System.Collections.Generic.IEnumerable`1[T], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfArray[T](T[]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Permute[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.Int32], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomChoicesBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomChoicesWith[T](System.Random, Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomChoices[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomSampleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomSampleWith[T](System.Random, Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomSample[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomShuffleBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomShuffleWith[T](System.Random, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RandomShuffle[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] ReadOnly[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveAt[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] RemoveManyAt[T](Int32, Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Replicate[T](Int32, T) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Reverse[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Singleton[T](T) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SkipWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Skip[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortByDescending[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortBy[T,TKey](Microsoft.FSharp.Core.FSharpFunc`2[T,TKey], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortDescending[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] SortWith[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Sort[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Tail[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] TakeWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Take[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Truncate[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Unfold[TState,T](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[T,TState]]], TState) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] UpdateAt[T](Int32, T, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Collections.Generic.IEnumerable`1[T] Where[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFoldBack[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,System.Tuple`2[TResult,TState]]], System.Collections.Generic.IEnumerable`1[T], TState) +Microsoft.FSharp.Collections.SeqModule: System.Tuple`2[System.Collections.Generic.IEnumerable`1[TResult],TState] MapFold[T,TState,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[TResult,TState]]], TState, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Average$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Average[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T ExactlyOne[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T FindBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Find[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Get[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Head[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Item[T](Int32, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Last[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T MaxBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Max[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T MinBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Min[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T RandomChoiceBy[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Double], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T RandomChoiceWith[T](System.Random, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T RandomChoice[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T ReduceBack[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Reduce[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Sum$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T Sum[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult AverageBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult AverageBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult Pick[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult SumBy$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[TResult,TResult]], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TResult SumBy[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: TState Fold2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TState]]], TState, System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: TState FoldBack2[T1,T2,TState](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2], TState) +Microsoft.FSharp.Collections.SeqModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], System.Collections.Generic.IEnumerable`1[T], TState) +Microsoft.FSharp.Collections.SeqModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: T[] ToArray[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Void Iterate2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed2[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]]], System.Collections.Generic.IEnumerable`1[T1], System.Collections.Generic.IEnumerable`1[T2]) +Microsoft.FSharp.Collections.SeqModule: Void IterateIndexed[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SeqModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean Contains[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsEmpty[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsProperSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsProperSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsSubset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Boolean IsSuperset[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Int32 Count[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Add[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Difference[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Empty[T]() +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] IntersectMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Intersect[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfArray[T](T[]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfList[T](Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] OfSeq[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Remove[T](T, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Singleton[T](T) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] UnionMany[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpSet`1[T]]) +Microsoft.FSharp.Collections.SetModule: Microsoft.FSharp.Collections.FSharpSet`1[T] Union[T](Microsoft.FSharp.Collections.FSharpSet`1[T], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Collections.Generic.IEnumerable`1[T] ToSeq[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T1],Microsoft.FSharp.Collections.FSharpSet`1[T2]] PartitionWith[T,T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpSet`1[T],Microsoft.FSharp.Collections.FSharpSet`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: T MaxElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: T MinElement[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Collections.FSharpSet`1[T], TState) +Microsoft.FSharp.Collections.SetModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: T[] ToArray[T](Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Collections.SetModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpSet`1[T]) +Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean IsCancellationRequested +Microsoft.FSharp.Control.AsyncActivation`1[T]: Boolean get_IsCancellationRequested() +Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnCancellation() +Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn OnSuccess(T) +Microsoft.FSharp.Control.AsyncActivation`1[T]: Microsoft.FSharp.Control.AsyncReturn Success(Microsoft.FSharp.Control.AsyncActivation`1[T], T) +Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised() +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty() +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn CallThenInvoke[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], TResult, Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Invoke[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Control.AsyncActivation`1[T]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryFinally[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn TryWith[T](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]]) +Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.FSharpAsync`1[T] MakeAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.AsyncActivation`1[T],Microsoft.FSharp.Control.AsyncReturn]) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.Await.Static$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], TTaskLike) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.Await.Static[TTaskLike,TAwaiter,T](TTaskLike) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.StartTaskImmediate.Static$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,TTaskLike]) +Microsoft.FSharp.Control.AsyncTaskLikeExtensions: Microsoft.FSharp.Control.FSharpAsync`1[T] Async.StartTaskImmediate.Static[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,TTaskLike]) +Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.BackgroundTaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncWrite(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncReadBytes(System.IO.Stream, Int32) +Microsoft.FSharp.Control.CommonExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Int32] AsyncRead(System.IO.Stream, Byte[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.CommonExtensions: System.IDisposable SubscribeToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.CommonExtensions: Void AddToObservable[T](System.IObservable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[System.Tuple`2[T,T]],System.Tuple`2[T,T]] Pairwise[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Choose[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Map[T,TResult,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult],TResult] Scan[TResult,T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Filter[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Merge[TDel1,T,TDel2](Microsoft.FSharp.Control.IEvent`2[TDel1,T], Microsoft.FSharp.Control.IEvent`2[TDel2,T]) +Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult1],TResult1],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[TResult2],TResult2]] Split[T,TResult1,TResult2,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: System.Tuple`2[Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T],Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T]] Partition[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.EventModule: Void Add[T,TDel](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.IEvent`2[TDel,T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Control.FSharpAsync`1[T]] StartChild[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpChoice`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] Choice[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Await(System.Threading.Tasks.Task) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Await(System.Threading.Tasks.ValueTask) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AwaitTask(System.Threading.Tasks.Task) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(Int32) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Sleep(System.TimeSpan) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] StartTaskImmediate(Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] StartTaskImmediate(Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToContext(System.Threading.SynchronizationContext) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToNewThread() +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SwitchToThreadPool() +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitIAsyncResult(System.IAsyncResult, Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Boolean] AwaitWaitHandle(System.Threading.WaitHandle, Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.IDisposable] OnCancel(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] CancellationToken +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.CancellationToken] get_CancellationToken() +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[System.Threading.Tasks.Task`1[T]] StartChildAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken +Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken() +Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken() +Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: Void StartWithContinuations[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] For[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] While(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Zero() +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Combine[T](Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] ReturnFrom[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] Return[T](T) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryFinally[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.FSharpAsyncBuilder: Microsoft.FSharp.Control.FSharpAsync`1[T] TryWith[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Control.FSharpAsync`1[T]]) +Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply]: Void Reply(TReply) +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] Publish +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate] get_Publish() +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void .ctor() +Microsoft.FSharp.Control.FSharpDelegateEvent`1[TDelegate]: Void Trigger(System.Object[]) +Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] Publish +Microsoft.FSharp.Control.FSharpEvent`1[T]: Microsoft.FSharp.Control.IEvent`2[Microsoft.FSharp.Control.FSharpHandler`1[T],T] get_Publish() +Microsoft.FSharp.Control.FSharpEvent`1[T]: Void .ctor() +Microsoft.FSharp.Control.FSharpEvent`1[T]: Void Trigger(T) +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] Publish +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] get_Publish() +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void .ctor() +Microsoft.FSharp.Control.FSharpEvent`2[TDelegate,TArgs]: Void Trigger(System.Object, TArgs) +Microsoft.FSharp.Control.FSharpHandler`1[T]: System.IAsyncResult BeginInvoke(System.Object, T, System.AsyncCallback, System.Object) +Microsoft.FSharp.Control.FSharpHandler`1[T]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Control.FSharpHandler`1[T]: Void EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Control.FSharpHandler`1[T]: Void Invoke(System.Object, T) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 CurrentQueueLength +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 DefaultTimeout +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_CurrentQueueLength() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Int32 get_DefaultTimeout() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TMsg]] TryReceive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[TReply]] PostAndTryAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] TryScan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TMsg] Receive(Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[TReply] PostAndAsyncReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpAsync`1[T] Scan[T](Microsoft.FSharp.Core.FSharpFunc`2[TMsg,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpHandler`1[System.Exception] Error +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] Start(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] StartImmediate(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg] StartImmediate(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Microsoft.FSharp.Core.FSharpOption`1[TReply] TryPostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: TReply PostAndReply[TReply](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpAsyncReplyChannel`1[TReply],TMsg], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg],Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Dispose() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Post(TMsg) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void Start() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void StartImmediate() +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void add_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void remove_Error(Microsoft.FSharp.Control.FSharpHandler`1[System.Exception]) +Microsoft.FSharp.Control.FSharpMailboxProcessor`1[TMsg]: Void set_DefaultTimeout(Int32) +Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void AddHandler(TDelegate) +Microsoft.FSharp.Control.IDelegateEvent`1[TDelegate]: Void RemoveHandler(TDelegate) +Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] CreateFromValue[T](T) +Microsoft.FSharp.Control.LazyExtensions: System.Lazy`1[T] Create[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Control.LazyExtensions: T Force[T](System.Lazy`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IDisposable Subscribe[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[System.Tuple`2[T,T]] Pairwise[T](System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Choose[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[TResult] Scan[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]], TResult, System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.IObservable`1[T] Merge[T](System.IObservable`1[T], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[TResult1],System.IObservable`1[TResult2]] Split[T,TResult1,TResult2](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpChoice`2[TResult1,TResult2]], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: System.Tuple`2[System.IObservable`1[T],System.IObservable`1[T]] Partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], System.IObservable`1[T]) +Microsoft.FSharp.Control.ObservableModule: Void Add[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], System.IObservable`1[T]) +Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] RunDynamic[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.TaskBuilder: System.Threading.Tasks.Task`1[T] Run[T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] For[T,TOverall](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] While[TOverall](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit] Zero[TOverall]() +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Combine[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Delay[TOverall,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryFinally[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TryWith[TOverall,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] Using[TResource,TOverall,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderBase: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] Return[T](T) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Boolean TaskBuilderBase.BindDynamic.Static[TOverall,TResult1,TResult2](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.HighPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPlusPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Boolean TaskBuilderBase.BindDynamic.Static[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall]] ByRef, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind$W[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TTaskLike,TResult1,TResult2,TAwaiter,TOverall](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike, Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T] TaskBuilderBase.Using[TResource,TOverall,T](Microsoft.FSharp.Control.TaskBuilderBase, TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],T]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom$W[TTaskLike,TAwaiter,T](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike,TAwaiter], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,T], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter,System.Boolean], Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[TTaskLike,TAwaiter,T](Microsoft.FSharp.Control.TaskBuilderBase, TTaskLike) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.LowPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike1,TTaskLike2,TResult1,TResult2,TAwaiter1,TAwaiter2](Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2] TaskBuilderBase.Bind[TResult1,TOverall,TResult2](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TResult1,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[TOverall],TResult2]]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[Microsoft.FSharp.Control.TaskStateMachineData`1[T],T] TaskBuilderBase.ReturnFrom[T](Microsoft.FSharp.Control.TaskBuilderBase, Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.BackgroundTaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] BackgroundTaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.BackgroundTaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike1,TAwaiter1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,TResult1], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter1,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources$W[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Core.FSharpFunc`2[TTaskLike2,TAwaiter2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,TResult2], Microsoft.FSharp.Core.FSharpFunc`2[TAwaiter2,System.Boolean], Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, Microsoft.FSharp.Control.FSharpAsync`1[TResult1], System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TResult1,TResult2](Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], Microsoft.FSharp.Control.FSharpAsync`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike1,TResult1,TResult2,TAwaiter1](Microsoft.FSharp.Control.TaskBuilder, TTaskLike1, System.Threading.Tasks.Task`1[TResult2]) +Microsoft.FSharp.Control.TaskBuilderExtensions.MediumPriority: System.Threading.Tasks.Task`1[System.ValueTuple`2[TResult1,TResult2]] TaskBuilder.MergeSources[TTaskLike2,TResult1,TResult2,TAwaiter2](Microsoft.FSharp.Control.TaskBuilder, System.Threading.Tasks.Task`1[TResult1], TTaskLike2) +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder backgroundTask +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.BackgroundTaskBuilder get_backgroundTask() +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder get_task() +Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder task +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty() +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T) +Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder +Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Empty +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.Unit] get_Empty() +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.ValueTask`1[TResult]], System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] OfTask[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[T] Result[T](T) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] AsyncDownloadFile(System.Net.WebClient, System.Uri, System.String) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Byte[]] AsyncDownloadData(System.Net.WebClient, System.Uri) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.Net.WebResponse] AsyncGetResponse(System.Net.WebRequest) +Microsoft.FSharp.Control.WebExtensions: Microsoft.FSharp.Control.FSharpAsync`1[System.String] AsyncDownloadString(System.Net.WebClient, System.Uri) +Microsoft.FSharp.Core.AbstractClassAttribute: Void .ctor() +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value() +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor() +Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path +Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path() +Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor() +Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean Value +Microsoft.FSharp.Core.AutoSerializableAttribute: Boolean get_Value() +Microsoft.FSharp.Core.AutoSerializableAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+In +Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+InOut +Microsoft.FSharp.Core.ByRefKinds: Microsoft.FSharp.Core.ByRefKinds+Out +Microsoft.FSharp.Core.CLIEventAttribute: Void .ctor() +Microsoft.FSharp.Core.CLIMutableAttribute: Void .ctor() +Microsoft.FSharp.Core.ClassAttribute: Void .ctor() +Microsoft.FSharp.Core.ComparisonConditionalOnAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] Counts +Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: System.Collections.Generic.IEnumerable`1[System.Int32] get_Counts() +Microsoft.FSharp.Core.CompilationArgumentCountsAttribute: Void .ctor(Int32[]) +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 SequenceNumber +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 VariantNumber +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_SequenceNumber() +Microsoft.FSharp.Core.CompilationMappingAttribute: Int32 get_VariantNumber() +Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags SourceConstructFlags +Microsoft.FSharp.Core.CompilationMappingAttribute: Microsoft.FSharp.Core.SourceConstructFlags get_SourceConstructFlags() +Microsoft.FSharp.Core.CompilationMappingAttribute: System.String ResourceName +Microsoft.FSharp.Core.CompilationMappingAttribute: System.String get_ResourceName() +Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] TypeDefinitions +Microsoft.FSharp.Core.CompilationMappingAttribute: System.Type[] get_TypeDefinitions() +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags) +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32) +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(Microsoft.FSharp.Core.SourceConstructFlags, Int32, Int32) +Microsoft.FSharp.Core.CompilationMappingAttribute: Void .ctor(System.String, System.Type[]) +Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags Flags +Microsoft.FSharp.Core.CompilationRepresentationAttribute: Microsoft.FSharp.Core.CompilationRepresentationFlags get_Flags() +Microsoft.FSharp.Core.CompilationRepresentationAttribute: Void .ctor(Microsoft.FSharp.Core.CompilationRepresentationFlags) +Microsoft.FSharp.Core.CompilationRepresentationFlags: Int32 value__ +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Event +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Instance +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags ModuleSuffix +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags None +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags Static +Microsoft.FSharp.Core.CompilationRepresentationFlags: Microsoft.FSharp.Core.CompilationRepresentationFlags UseNullAsTrueValue +Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String SourceName +Microsoft.FSharp.Core.CompilationSourceNameAttribute: System.String get_SourceName() +Microsoft.FSharp.Core.CompilationSourceNameAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CompiledNameAttribute: System.String CompiledName +Microsoft.FSharp.Core.CompiledNameAttribute: System.String get_CompiledName() +Microsoft.FSharp.Core.CompiledNameAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsError +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean IsHidden +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsError() +Microsoft.FSharp.Core.CompilerMessageAttribute: Boolean get_IsHidden() +Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 MessageNumber +Microsoft.FSharp.Core.CompilerMessageAttribute: Int32 get_MessageNumber() +Microsoft.FSharp.Core.CompilerMessageAttribute: System.String Message +Microsoft.FSharp.Core.CompilerMessageAttribute: System.String get_Message() +Microsoft.FSharp.Core.CompilerMessageAttribute: Void .ctor(System.String, Int32) +Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsError(Boolean) +Microsoft.FSharp.Core.CompilerMessageAttribute: Void set_IsHidden(Boolean) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: TResult Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: T[] Close() +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void Add(T) +Microsoft.FSharp.Core.CompilerServices.ArrayCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean CheckClose +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Boolean get_CheckClose() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Int32 GenerateNext(System.Collections.Generic.IEnumerable`1[T] ByRef) +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: System.Collections.Generic.IEnumerator`1[T] GetFreshEnumerator() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T LastGenerated +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: T get_LastGenerated() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1[T]: Void Close() +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNestedNamespaces() +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String NamespaceName +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.String get_NamespaceName() +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type ResolveTypeName(System.String) +Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace: System.Type[] GetTypes() +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 ResumptionPoint +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Int32 get_ResumptionPoint() +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData Data +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: TData get_Data() +Microsoft.FSharp.Core.CompilerServices.IResumableStateMachine`1[TData]: Void set_Data(TData) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.MethodBase ApplyStaticArgumentsForMethod(System.Reflection.MethodBase, System.String, System.Object[]) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider2: System.Reflection.ParameterInfo[] GetStaticParametersForMethod(System.Reflection.MethodBase) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Byte[] GetGeneratedAssemblyContents(System.Reflection.Assembly) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Core.CompilerServices.IProvidedNamespace[] GetNamespaces() +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Microsoft.FSharp.Quotations.FSharpExpr GetInvokerExpression(System.Reflection.MethodBase, Microsoft.FSharp.Quotations.FSharpExpr[]) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.EventHandler Invalidate +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Reflection.ParameterInfo[] GetStaticParameters(System.Type) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: System.Type ApplyStaticArguments(System.Type, System.String[], System.Object[]) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void add_Invalidate(System.EventHandler) +Microsoft.FSharp.Core.CompilerServices.ITypeProvider: Void remove_Invalidate(System.EventHandler) +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] AddManyAndClose(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Microsoft.FSharp.Collections.FSharpList`1[T] Close() +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void Add(T) +Microsoft.FSharp.Core.CompilerServices.ListCollector`1[T]: Void AddMany(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean CombineDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryFinallyAsyncDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean TryWithDynamic[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean WhileDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Boolean YieldDynamic[TData](Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] For[T,TData](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] While[TData](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Yield[TData]() +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit] Zero[TData]() +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Combine[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Delay[TData,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinallyAsync[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryFinally[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] TryWith[TData,T](Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode: Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T] Using[TResource,TData,T](TResource, Microsoft.FSharp.Core.FSharpFunc`2[TResource,Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]]) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.ResumableCode`2[TData,T]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Int32 ResumptionPoint +Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData] ResumptionDynamicInfo +Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData]: TData Data +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] ResumptionFunc +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData] get_ResumptionFunc() +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object ResumptionData +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: System.Object get_ResumptionData() +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void .ctor(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void MoveNext(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void SetStateMachine(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionData(System.Object) +Microsoft.FSharp.Core.CompilerServices.ResumptionDynamicInfo`1[TData]: Void set_ResumptionFunc(Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Boolean Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.ResumptionFunc`1[TData]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: Microsoft.FSharp.Control.IEvent`2[TDelegate,TArgs] CreateEvent[TDelegate,TArgs](Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[TDelegate,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.Object,Microsoft.FSharp.Core.FSharpFunc`2[TArgs,Microsoft.FSharp.Core.Unit]],TDelegate]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateFromFunctions[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[TResult] EnumerateUsing[T,TCollection,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TCollection]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateThenFinally[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateTryWith[T](System.Collections.Generic.IEnumerable`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Int32], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Collections.Generic.IEnumerable`1[T]]) +Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers: System.Collections.Generic.IEnumerable`1[T] EnumerateWhile[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: System.IAsyncResult BeginInvoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine, System.AsyncCallback, System.Object) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void .ctor(System.Object, IntPtr) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void EndInvoke(System.IAsyncResult) +Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName() +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsHostedExecution +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean IsInvalidationSupported +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean SystemRuntimeContainsType(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsHostedExecution() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Boolean get_IsInvalidationSupported() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String ResolutionFolder +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String RuntimeAssembly +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String TemporaryFolder +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_ResolutionFolder() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_RuntimeAssembly() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String get_TemporaryFolder() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] ReferencedAssemblies +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.String[] get_ReferencedAssemblies() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version SystemRuntimeAssemblyVersion +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: System.Version get_SystemRuntimeAssemblyVersion() +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean]) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,System.Boolean], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.String[]]) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsHostedExecution(Boolean) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_IsInvalidationSupported(Boolean) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ReferencedAssemblies(System.String[]) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_ResolutionFolder(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_RuntimeAssembly(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_SystemRuntimeAssemblyVersion(System.Version) +Microsoft.FSharp.Core.CompilerServices.TypeProviderConfig: Void set_TemporaryFolder(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Column +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 Line +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Column() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Int32 get_Line() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String FilePath +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: System.String get_FilePath() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Column(Int32) +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_FilePath(System.String) +Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute: Void set_Line(Int32) +Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute: Void .ctor() +Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Int32 value__ +Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes IsErased +Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes: Microsoft.FSharp.Core.CompilerServices.TypeProviderTypeAttributes SuppressRelocate +Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String CommentText +Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: System.String get_CommentText() +Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CustomComparisonAttribute: Void .ctor() +Microsoft.FSharp.Core.CustomEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean AllowIntoPattern +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeGroupJoin +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeJoin +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean IsLikeZip +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpace +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean MaintainsVariableSpaceUsingBind +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_AllowIntoPattern() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeGroupJoin() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeJoin() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_IsLikeZip() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpace() +Microsoft.FSharp.Core.CustomOperationAttribute: Boolean get_MaintainsVariableSpaceUsingBind() +Microsoft.FSharp.Core.CustomOperationAttribute: System.String JoinConditionWord +Microsoft.FSharp.Core.CustomOperationAttribute: System.String Name +Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_JoinConditionWord() +Microsoft.FSharp.Core.CustomOperationAttribute: System.String get_Name() +Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor() +Microsoft.FSharp.Core.CustomOperationAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_AllowIntoPattern(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeGroupJoin(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeJoin(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_IsLikeZip(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_JoinConditionWord(System.String) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpace(Boolean) +Microsoft.FSharp.Core.CustomOperationAttribute: Void set_MaintainsVariableSpaceUsingBind(Boolean) +Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean Value +Microsoft.FSharp.Core.DefaultAugmentationAttribute: Boolean get_Value() +Microsoft.FSharp.Core.DefaultAugmentationAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.DefaultValueAttribute: Boolean Check +Microsoft.FSharp.Core.DefaultValueAttribute: Boolean get_Check() +Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor() +Microsoft.FSharp.Core.DefaultValueAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.EntryPointAttribute: Void .ctor() +Microsoft.FSharp.Core.EqualityConditionalOnAttribute: Void .ctor() +Microsoft.FSharp.Core.ExperimentalAttribute: System.String Message +Microsoft.FSharp.Core.ExperimentalAttribute: System.String get_Message() +Microsoft.FSharp.Core.ExperimentalAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: Byte ToByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked: SByte ToSByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Byte ToByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Double ToDouble[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Collections.FSharpSet`1[T] CreateSet[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder DefaultAsyncBuilder +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Control.FSharpAsyncBuilder get_DefaultAsyncBuilder() +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Core.ExtraTopLevelOperators+Checked +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder get_query() +Microsoft.FSharp.Core.ExtraTopLevelOperators: Microsoft.FSharp.Linq.QueryBuilder query +Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: SByte ToSByte[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Single ToSingle[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IDictionary`2[TKey,TValue] CreateDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: System.Collections.Generic.IReadOnlyDictionary`2[TKey,TValue] CreateReadOnlyDictionary[TKey,TValue](System.Collections.Generic.IEnumerable`1[System.Tuple`2[TKey,TValue]]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T LazyPattern[T](System.Lazy`1[T]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) +Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice1Of2 +Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2]: Int32 Choice2Of2 +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice1Of2 +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean IsChoice2Of2 +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice1Of2() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Boolean get_IsChoice2Of2() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2] +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2] +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2+Tags[T1,T2] +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice1Of2(T1) +Microsoft.FSharp.Core.FSharpChoice`2[T1,T2]: Microsoft.FSharp.Core.FSharpChoice`2[T1,T2] NewChoice2Of2(T2) +Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice1Of3 +Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice2Of3 +Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3]: Int32 Choice3Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice1Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice2Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean IsChoice3Of3 +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice1Of3() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice2Of3() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Boolean get_IsChoice3Of3() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice1Of3[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice2Of3[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Choice3Of3[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3+Tags[T1,T2,T3] +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice1Of3(T1) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice2Of3(T2) +Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3]: Microsoft.FSharp.Core.FSharpChoice`3[T1,T2,T3] NewChoice3Of3(T3) +Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice1Of4 +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice2Of4 +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice3Of4 +Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4]: Int32 Choice4Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice1Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice2Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice3Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean IsChoice4Of4 +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice1Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice2Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice3Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Boolean get_IsChoice4Of4() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice1Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice2Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice3Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Choice4Of4[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4+Tags[T1,T2,T3,T4] +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice1Of4(T1) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice2Of4(T2) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice3Of4(T3) +Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4]: Microsoft.FSharp.Core.FSharpChoice`4[T1,T2,T3,T4] NewChoice4Of4(T4) +Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 Item +Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5]: T5 get_Item() +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice1Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice2Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice3Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice4Of5 +Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5]: Int32 Choice5Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice1Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice2Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice3Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice4Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean IsChoice5Of5 +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice1Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice2Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice3Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice4Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Boolean get_IsChoice5Of5() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice1Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice2Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice3Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice4Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Choice5Of5[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5+Tags[T1,T2,T3,T4,T5] +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice1Of5(T1) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice2Of5(T2) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice3Of5(T3) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice4Of5(T4) +Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5]: Microsoft.FSharp.Core.FSharpChoice`5[T1,T2,T3,T4,T5] NewChoice5Of5(T5) +Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6]: T5 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 Item +Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6]: T6 get_Item() +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice1Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice2Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice3Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice4Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice5Of6 +Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6]: Int32 Choice6Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice1Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice2Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice3Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice4Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice5Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean IsChoice6Of6 +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice1Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice2Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice3Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice4Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice5Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Boolean get_IsChoice6Of6() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice1Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice2Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice3Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice4Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice5Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Choice6Of6[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6+Tags[T1,T2,T3,T4,T5,T6] +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice1Of6(T1) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice2Of6(T2) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice3Of6(T3) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice4Of6(T4) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice5Of6(T5) +Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6]: Microsoft.FSharp.Core.FSharpChoice`6[T1,T2,T3,T4,T5,T6] NewChoice6Of6(T6) +Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 Item +Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item() +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice1Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice2Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice3Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice4Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice5Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice6Of7 +Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7]: Int32 Choice7Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice1Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice2Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice3Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice4Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice5Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice6Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean IsChoice7Of7 +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice1Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice2Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice3Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice4Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice5Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice6Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Boolean get_IsChoice7Of7() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 Tag +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice1Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice2Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice3Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice4Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice5Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice6Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Choice7Of7[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7+Tags[T1,T2,T3,T4,T5,T6,T7] +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice1Of7(T1) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice2Of7(T2) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice3Of7(T3) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice4Of7(T4) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice5Of7(T5) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice6Of7(T6) +Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7]: Microsoft.FSharp.Core.FSharpChoice`7[T1,T2,T3,T4,T5,T6,T7] NewChoice7Of7(T7) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromConverter(System.Converter`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] op_Implicit(System.Converter`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] ToConverter(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: System.Converter`2[T,TResult] op_Implicit(Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: TResult Invoke(T) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: V InvokeFast[V](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,V]], T, TResult) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Void .ctor() +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: W InvokeFast[V,W](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,W]]], T, TResult, V) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: X InvokeFast[V,W,X](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,X]]]], T, TResult, V, W) +Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]: Y InvokeFast[V,W,X,Y](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Core.FSharpFunc`2[V,Microsoft.FSharp.Core.FSharpFunc`2[W,Microsoft.FSharp.Core.FSharpFunc`2[X,Y]]]]], T, TResult, V, W, X) +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Major +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Minor +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 Release +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Major() +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Minor() +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Int32 get_Release() +Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute: Void .ctor(Int32, Int32, Int32) +Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 None +Microsoft.FSharp.Core.FSharpOption`1+Tags[T]: Int32 Some +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsNone +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean IsSome +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsNone(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Boolean get_IsSome(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpOption`1[T]: Int32 GetTag(Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1+Tags[T] +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] None +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] Some(T) +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] get_None() +Microsoft.FSharp.Core.FSharpOption`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] op_Implicit(T) +Microsoft.FSharp.Core.FSharpOption`1[T]: System.String ToString() +Microsoft.FSharp.Core.FSharpOption`1[T]: T Value +Microsoft.FSharp.Core.FSharpOption`1[T]: T get_Value() +Microsoft.FSharp.Core.FSharpOption`1[T]: Void .ctor(T) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T]) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpRef`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpRef`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpRef`1[T]) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpRef`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpRef`1[T]: T Value +Microsoft.FSharp.Core.FSharpRef`1[T]: T contents +Microsoft.FSharp.Core.FSharpRef`1[T]: T contents@ +Microsoft.FSharp.Core.FSharpRef`1[T]: T get_Value() +Microsoft.FSharp.Core.FSharpRef`1[T]: T get_contents() +Microsoft.FSharp.Core.FSharpRef`1[T]: Void .ctor(T) +Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_Value(T) +Microsoft.FSharp.Core.FSharpRef`1[T]: Void set_contents(T) +Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Error +Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError]: Int32 Ok +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(Microsoft.FSharp.Core.FSharpResult`2[T,TError], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsError +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean IsOk +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsError() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Boolean get_IsOk() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 Tag +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2+Tags[T,TError] +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewError(TError) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: Microsoft.FSharp.Core.FSharpResult`2[T,TError] NewOk(T) +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T ResultValue +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: T get_ResultValue() +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError ErrorValue +Microsoft.FSharp.Core.FSharpResult`2[T,TError]: TError get_ErrorValue() +Microsoft.FSharp.Core.FSharpTypeFunc: System.Object Specialize[T]() +Microsoft.FSharp.Core.FSharpTypeFunc: Void .ctor() +Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueNone +Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T]: Int32 ValueSome +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(Microsoft.FSharp.Core.FSharpValueOption`1[T], System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsNone +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsSome +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueNone +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean IsValueSome +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsNone() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsSome() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueNone() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Boolean get_IsValueSome() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 CompareTo(System.Object, System.Collections.IComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 Tag +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Int32 get_Tag() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1+Tags[T] +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] NewValueSome(T) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] None +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] Some(T) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] ValueNone +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_None() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] get_ValueNone() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: Microsoft.FSharp.Core.FSharpValueOption`1[T] op_Implicit(T) +Microsoft.FSharp.Core.FSharpValueOption`1[T]: System.String ToString() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Item +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T Value +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Item() +Microsoft.FSharp.Core.FSharpValueOption`1[T]: T get_Value() +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] FromAction(System.Action) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T] FromFunc[T](System.Func`1[T]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] FromAction[T](System.Action`1[T]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit] ToFSharpFunc[T](System.Action`1[T]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] FromFunc[T,TResult](System.Func`2[T,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T,TResult] ToFSharpFunc[T,TResult](System.Converter`2[T,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,Microsoft.FSharp.Core.Unit]]]]] FromAction[T1,T2,T3,T4,T5](System.Action`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FromFunc[T1,T2,T3,T4,T5,TResult](System.Func`6[T1,T2,T3,T4,T5,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]] FuncFromTupled[T1,T2,T3,T4,T5,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[T1,T2,T3,T4,T5],TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.Unit]]]] FromAction[T1,T2,T3,T4](System.Action`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FromFunc[T1,T2,T3,T4,TResult](System.Func`5[T1,T2,T3,T4,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]] FuncFromTupled[T1,T2,T3,T4,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[T1,T2,T3,T4],TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.Unit]]] FromAction[T1,T2,T3](System.Action`3[T1,T2,T3]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FromFunc[T1,T2,T3,TResult](System.Func`4[T1,T2,T3,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]] FuncFromTupled[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[T1,T2,T3],TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.Unit]] FromAction[T1,T2](System.Action`2[T1,T2]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FromFunc[T1,T2,TResult](System.Func`3[T1,T2,TResult]) +Microsoft.FSharp.Core.FuncConvert: Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]] FuncFromTupled[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[T1,T2],TResult]) +Microsoft.FSharp.Core.GeneralizableValueAttribute: Void .ctor() +Microsoft.FSharp.Core.InlineIfLambdaAttribute: Void .ctor() +Microsoft.FSharp.Core.InterfaceAttribute: Void .ctor() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String AddressOpNotFirstClassString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputArrayEmptyString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputMustBeNonNegativeString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String InputSequenceEmptyString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String NoNegateMinValueString +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_AddressOpNotFirstClassString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputArrayEmptyString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputMustBeNonNegativeString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_InputSequenceEmptyString() +Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings: System.String get_NoNegateMinValueString() +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean FastEqualsTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityERIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericEqualityWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterOrEqualIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericGreaterThanIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessOrEqualIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean GenericLessThanIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Boolean PhysicalEqualityIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple2[T1,T2](System.Collections.IComparer, System.Tuple`2[T1,T2], System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple3[T1,T2,T3](System.Collections.IComparer, System.Tuple`3[T1,T2,T3], System.Tuple`3[T1,T2,T3]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple4[T1,T2,T3,T4](System.Collections.IComparer, System.Tuple`4[T1,T2,T3,T4], System.Tuple`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastCompareTuple5[T1,T2,T3,T4,T5](System.Collections.IComparer, System.Tuple`5[T1,T2,T3,T4,T5], System.Tuple`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple2[T1,T2](System.Collections.IEqualityComparer, System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple3[T1,T2,T3](System.Collections.IEqualityComparer, System.Tuple`3[T1,T2,T3]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple4[T1,T2,T3,T4](System.Collections.IEqualityComparer, System.Tuple`4[T1,T2,T3,T4]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 FastHashTuple5[T1,T2,T3,T4,T5](System.Collections.IEqualityComparer, System.Tuple`5[T1,T2,T3,T4,T5]) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonIntrinsic[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericComparisonWithComparerIntrinsic[T](System.Collections.IComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashIntrinsic[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 GenericHashWithComparerIntrinsic[T](System.Collections.IEqualityComparer, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 LimitedGenericHashIntrinsic[T](Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+HashCompare: Int32 PhysicalHashIntrinsic[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestFast[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Boolean TypeTestGeneric[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Char GetString(System.String, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: System.Decimal MakeDecimal(Int32, Int32, Int32, Boolean, Byte) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CheckThis[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T CreateInstance[T]() +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray2D[T](T[,], Int32, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray3D[T](T[,,], Int32, Int32, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray4D[T](T[,,,], Int32, Int32, Int32, Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T GetArray[T](T[], Int32) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxFast[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: T UnboxGeneric[T](System.Object) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void Dispose[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailInit() +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void FailStaticInit() +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray2D[T](T[,], Int32, Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray3D[T](T[,,], Int32, Int32, Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray4D[T](T[,,,], Int32, Int32, Int32, Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions: Void SetArray[T](T[], Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean Or(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_Amp(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanAnd(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: Boolean op_BooleanOr(Boolean, Boolean) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: IntPtr op_IntegerAddressOf[T](T) +Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators: T& op_AddressOf[T](T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityER[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEqualityWithComparer[T](System.Collections.IEqualityComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericEquality[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterOrEqual[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericGreaterThan[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessOrEqual[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean GenericLessThan[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Boolean PhysicalEquality[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Byte ByteWithMeasure(Byte) +Microsoft.FSharp.Core.LanguagePrimitives: Double FloatWithMeasure(Double) +Microsoft.FSharp.Core.LanguagePrimitives: Int16 Int16WithMeasure(Int16) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparisonWithComparer[T](System.Collections.IComparer, T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericComparison[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHashWithComparer[T](System.Collections.IEqualityComparer, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericHash[T](T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 GenericLimitedHash[T](Int32, T) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 Int32WithMeasure(Int32) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 ParseInt32(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: Int32 PhysicalHash[T](T) +Microsoft.FSharp.Core.LanguagePrimitives: Int64 Int64WithMeasure(Int64) +Microsoft.FSharp.Core.LanguagePrimitives: Int64 ParseInt64(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: IntPtr IntPtrWithMeasure(IntPtr) +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+ErrorStrings +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+HashCompare +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicFunctions +Microsoft.FSharp.Core.LanguagePrimitives: Microsoft.FSharp.Core.LanguagePrimitives+IntrinsicOperators +Microsoft.FSharp.Core.LanguagePrimitives: SByte SByteWithMeasure(SByte) +Microsoft.FSharp.Core.LanguagePrimitives: Single Float32WithMeasure(Single) +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparerFromTable[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IComparer`1[T] FastGenericComparer[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparerFromTable[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastGenericEqualityComparer[T]() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.Generic.IEqualityComparer`1[T] FastLimitedGenericEqualityComparer[T](Int32) +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer GenericComparer +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IComparer get_GenericComparer() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityComparer +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer GenericEqualityERComparer +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityComparer() +Microsoft.FSharp.Core.LanguagePrimitives: System.Collections.IEqualityComparer get_GenericEqualityERComparer() +Microsoft.FSharp.Core.LanguagePrimitives: System.Decimal DecimalWithMeasure(System.Decimal) +Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32) +Microsoft.FSharp.Core.LanguagePrimitives: T DivideByIntDynamic[T](T, Int32) +Microsoft.FSharp.Core.LanguagePrimitives: T DivideByInt[T](T, Int32) +Microsoft.FSharp.Core.LanguagePrimitives: T EnumToValue[TEnum,T](TEnum) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericMaximum[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericMinimum[T](T, T) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericOneDynamic[T]() +Microsoft.FSharp.Core.LanguagePrimitives: T GenericOne[T]() +Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Core.LanguagePrimitives: T GenericZeroDynamic[T]() +Microsoft.FSharp.Core.LanguagePrimitives: T GenericZero[T]() +Microsoft.FSharp.Core.LanguagePrimitives: TEnum EnumOfValue[T,TEnum](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult AdditionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseAndDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult BitwiseOrDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedAdditionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedExplicitDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedMultiplyDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedSubtractionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult CheckedUnaryNegationDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult DivisionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult EqualityDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult ExclusiveOrDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult ExplicitDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult GreaterThanOrEqualDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult InequalityDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LeftShiftDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LessThanOrEqualDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult LogicalNotDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: TResult ModulusDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult MultiplyDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult RightShiftDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult SubtractionDynamic[T1,T2,TResult](T1, T2) +Microsoft.FSharp.Core.LanguagePrimitives: TResult UnaryNegationDynamic[T,TResult](T) +Microsoft.FSharp.Core.LanguagePrimitives: UInt16 UInt16WithMeasure(UInt16) +Microsoft.FSharp.Core.LanguagePrimitives: UInt32 ParseUInt32(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: UInt32 UInt32WithMeasure(UInt32) +Microsoft.FSharp.Core.LanguagePrimitives: UInt64 ParseUInt64(System.String) +Microsoft.FSharp.Core.LanguagePrimitives: UInt64 UInt64WithMeasure(UInt64) +Microsoft.FSharp.Core.LanguagePrimitives: UIntPtr UIntPtrWithMeasure(UIntPtr) +Microsoft.FSharp.Core.LiteralAttribute: Void .ctor() +Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Exception, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object) +Microsoft.FSharp.Core.MatchFailureException: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.MatchFailureException: Int32 Data1 +Microsoft.FSharp.Core.MatchFailureException: Int32 Data2 +Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode() +Microsoft.FSharp.Core.MatchFailureException: Int32 GetHashCode(System.Collections.IEqualityComparer) +Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data1() +Microsoft.FSharp.Core.MatchFailureException: Int32 get_Data2() +Microsoft.FSharp.Core.MatchFailureException: System.String Data0 +Microsoft.FSharp.Core.MatchFailureException: System.String Message +Microsoft.FSharp.Core.MatchFailureException: System.String get_Data0() +Microsoft.FSharp.Core.MatchFailureException: System.String get_Message() +Microsoft.FSharp.Core.MatchFailureException: Void .ctor() +Microsoft.FSharp.Core.MatchFailureException: Void .ctor(System.String, Int32, Int32) +Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute: Void .ctor() +Microsoft.FSharp.Core.MeasureAttribute: Void .ctor() +Microsoft.FSharp.Core.NoComparisonAttribute: Void .ctor() +Microsoft.FSharp.Core.NoCompilerInliningAttribute: Void .ctor() +Microsoft.FSharp.Core.NoDynamicInvocationAttribute: Void .ctor() +Microsoft.FSharp.Core.NoEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromInt64Dynamic(Int64) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: System.Object FromStringDynamic(System.String) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt32[T](Int32) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromInt64[T](Int64) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromOne[T]() +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromString[T](System.String) +Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI: T FromZero[T]() +Microsoft.FSharp.Core.NumericLiterals: Microsoft.FSharp.Core.NumericLiterals+NumericLiteralI +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 String.GetReverseIndex(System.String, Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,,]`1.GetReverseIndex[T](T[,,,], Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,,]`1.GetReverseIndex[T](T[,,], Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 [,]`1.GetReverseIndex[T](T[,], Int32, Int32) +Microsoft.FSharp.Core.Operators+ArrayExtensions: Int32 []`1.GetReverseIndex[T](T[], Int32, Int32) +Microsoft.FSharp.Core.Operators+Checked: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.Operators+Checked: Byte ToByte[T](T) +Microsoft.FSharp.Core.Operators+Checked: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T) +Microsoft.FSharp.Core.Operators+Checked: Char ToChar[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T) +Microsoft.FSharp.Core.Operators+Checked: Int16 ToInt16[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt32[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int32 ToInt[T](T) +Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T) +Microsoft.FSharp.Core.Operators+Checked: Int64 ToInt64[T](T) +Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T) +Microsoft.FSharp.Core.Operators+Checked: IntPtr ToIntPtr[T](T) +Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.Operators+Checked: SByte ToSByte[T](T) +Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators+Checked: T op_UnaryNegation[T](T) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Addition[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Multiply[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators+Checked: T3 op_Subtraction[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T) +Microsoft.FSharp.Core.Operators+Checked: UInt16 ToUInt16[T](T) +Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T) +Microsoft.FSharp.Core.Operators+Checked: UInt32 ToUInt32[T](T) +Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T) +Microsoft.FSharp.Core.Operators+Checked: UInt64 ToUInt64[T](T) +Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T) +Microsoft.FSharp.Core.Operators+Checked: UIntPtr ToUIntPtr[T](T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Equality[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThanOrEqual[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_GreaterThan[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_Inequality[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,System.Boolean]], T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThanOrEqual[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Boolean op_LessThan[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Compare[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: Int32 Hash[T](T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Max[T](T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]], T, T) +Microsoft.FSharp.Core.Operators+NonStructuralComparison: T Min[T](T, T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Byte PowByte(Byte, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Double PowDouble(Double, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int16 PowInt16(Int16, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 PowInt32(Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int32 SignDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Int64 PowInt64(Int64, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: IntPtr PowIntPtr(IntPtr, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: SByte PowSByte(SByte, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Single PowSingle(Single, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Byte] RangeByte(Byte, Byte, Byte) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Char] RangeChar(Char, Char) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Double] RangeDouble(Double, Double, Double) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int16] RangeInt16(Int16, Int16, Int16) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int32] RangeInt32(Int32, Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Int64] RangeInt64(Int64, Int64, Int64) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.IntPtr] RangeIntPtr(IntPtr, IntPtr, IntPtr) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.SByte] RangeSByte(SByte, SByte, SByte) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.Single] RangeSingle(Single, Single, Single) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt16] RangeUInt16(UInt16, UInt16, UInt16) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt32] RangeUInt32(UInt32, UInt32, UInt32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UInt64] RangeUInt64(UInt64, UInt64, UInt64) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[System.UIntPtr] RangeUIntPtr(UIntPtr, UIntPtr, UIntPtr) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Collections.Generic.IEnumerable`1[T] RangeStepGeneric[TStep,T](TStep, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.Decimal PowDecimal(System.Decimal, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: System.String GetStringSlice(System.String, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AbsDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AcosDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AsinDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T AtanDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CeilingDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CosDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T CoshDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T ExpDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T FloorDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T Log10Dynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T LogDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowDynamic[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T PowGeneric[T](T, Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T RoundDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T SinhDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TanhDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T TruncateDynamic[T](T) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 Atan2Dynamic[T1,T2](T1, T1) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T2 SqrtDynamic[T1,T2](T1) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,,] GetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,,] GetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[,] GetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: T[] GetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt16 PowUInt16(UInt16, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt32 PowUInt32(UInt32, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UInt64 PowUInt64(UInt64, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: UIntPtr PowUIntPtr(UIntPtr, Int32) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed1[T](T[,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2DFixed2[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice2D[T](T[,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble1[T](T[,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble2[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedDouble3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle1[T](T[,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle2[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3DFixedSingle3[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice3D[T](T[,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble1[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble3[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble5[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedDouble6[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle1[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle2[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle3[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedSingle4[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple1[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple2[T](T[,,,], Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple3[T](T[,,,], Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Int32, T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4DFixedTriple4[T](T[,,,], Int32, Int32, Int32, Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice4D[T](T[,,,], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[,,,]) +Microsoft.FSharp.Core.Operators+OperatorIntrinsics: Void SetArraySlice[T](T[], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], T[]) +Microsoft.FSharp.Core.Operators+Unchecked: Boolean Equals[T](T, T) +Microsoft.FSharp.Core.Operators+Unchecked: Int32 Compare[T](T, T) +Microsoft.FSharp.Core.Operators+Unchecked: Int32 Hash[T](T) +Microsoft.FSharp.Core.Operators+Unchecked: T DefaultOf[T]() +Microsoft.FSharp.Core.Operators+Unchecked: T NonNullQuickPattern[T](T) +Microsoft.FSharp.Core.Operators+Unchecked: T NonNull[T](T) +Microsoft.FSharp.Core.Operators+Unchecked: T Unbox[T](System.Object) +Microsoft.FSharp.Core.Operators+Unchecked: T WithNull[T](T) +Microsoft.FSharp.Core.Operators: Boolean IsNullV[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: Boolean IsNull[T](T) +Microsoft.FSharp.Core.Operators: Boolean Not(Boolean) +Microsoft.FSharp.Core.Operators: Boolean op_Equality[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_GreaterThanOrEqual[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_GreaterThan[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_Inequality[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_LessThanOrEqual[T](T, T) +Microsoft.FSharp.Core.Operators: Boolean op_LessThan[T](T, T) +Microsoft.FSharp.Core.Operators: Byte ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], T) +Microsoft.FSharp.Core.Operators: Byte ToByte[T](T) +Microsoft.FSharp.Core.Operators: Char ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], T) +Microsoft.FSharp.Core.Operators: Char ToChar[T](T) +Microsoft.FSharp.Core.Operators: Double Infinity +Microsoft.FSharp.Core.Operators: Double NaN +Microsoft.FSharp.Core.Operators: Double ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], T) +Microsoft.FSharp.Core.Operators: Double ToDouble[T](T) +Microsoft.FSharp.Core.Operators: Double get_Infinity() +Microsoft.FSharp.Core.Operators: Double get_NaN() +Microsoft.FSharp.Core.Operators: Int16 ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], T) +Microsoft.FSharp.Core.Operators: Int16 ToInt16[T](T) +Microsoft.FSharp.Core.Operators: Int32 Compare[T](T, T) +Microsoft.FSharp.Core.Operators: Int32 Hash[T](T) +Microsoft.FSharp.Core.Operators: Int32 Sign$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators: Int32 Sign[T](T) +Microsoft.FSharp.Core.Operators: Int32 SizeOf[T]() +Microsoft.FSharp.Core.Operators: Int32 ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators: Int32 ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], T) +Microsoft.FSharp.Core.Operators: Int32 ToInt32[T](T) +Microsoft.FSharp.Core.Operators: Int32 ToInt[T](T) +Microsoft.FSharp.Core.Operators: Int32 limitedHash[T](Int32, T) +Microsoft.FSharp.Core.Operators: Int64 ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], T) +Microsoft.FSharp.Core.Operators: Int64 ToInt64[T](T) +Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], T) +Microsoft.FSharp.Core.Operators: IntPtr ToIntPtr[T](T) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Collections.FSharpList`1[T] op_Append[T](Microsoft.FSharp.Collections.FSharpList`1[T], Microsoft.FSharp.Collections.FSharpList`1[T]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.Unit,T] NullMatchPattern[T](T) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpChoice`2[Microsoft.FSharp.Core.Unit,T] NullValueMatchPattern[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeLeft[T2,T3,T1](Microsoft.FSharp.Core.FSharpFunc`2[T2,T3], Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpFunc`2[T1,T3] op_ComposeRight[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,T2], Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[System.String] FailurePattern(System.Exception) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpOption`1[T] TryUnbox[T](System.Object) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.FSharpRef`1[T] Ref[T](T) +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+ArrayExtensions +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Checked +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+NonStructuralComparison +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+OperatorIntrinsics +Microsoft.FSharp.Core.Operators: Microsoft.FSharp.Core.Operators+Unchecked +Microsoft.FSharp.Core.Operators: SByte ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], T) +Microsoft.FSharp.Core.Operators: SByte ToSByte[T](T) +Microsoft.FSharp.Core.Operators: Single InfinitySingle +Microsoft.FSharp.Core.Operators: Single NaNSingle +Microsoft.FSharp.Core.Operators: Single ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], T) +Microsoft.FSharp.Core.Operators: Single ToSingle[T](T) +Microsoft.FSharp.Core.Operators: Single get_InfinitySingle() +Microsoft.FSharp.Core.Operators: Single get_NaNSingle() +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] CreateSequence[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep$W[T,TStep](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TStep], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TStep,T]], T, TStep, T) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_RangeStep[T,TStep](T, TStep, T) +Microsoft.FSharp.Core.Operators: System.Collections.Generic.IEnumerable`1[T] op_Range[T](T, T) +Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], T) +Microsoft.FSharp.Core.Operators: System.Decimal ToDecimal[T](T) +Microsoft.FSharp.Core.Operators: System.Exception Failure(System.String) +Microsoft.FSharp.Core.Operators: System.IO.TextReader ConsoleIn[T]() +Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleError[T]() +Microsoft.FSharp.Core.Operators: System.IO.TextWriter ConsoleOut[T]() +Microsoft.FSharp.Core.Operators: System.Nullable`1[T] NullV[T]() +Microsoft.FSharp.Core.Operators: System.Nullable`1[T] WithNullV[T](T) +Microsoft.FSharp.Core.Operators: System.Object Box[T](T) +Microsoft.FSharp.Core.Operators: System.String NameOf[T](T) +Microsoft.FSharp.Core.Operators: System.String ToString[T](T) +Microsoft.FSharp.Core.Operators: System.String op_Concatenate(System.String, System.String) +Microsoft.FSharp.Core.Operators: System.Tuple`2[TKey,TValue] KeyValuePattern[TKey,TValue](System.Collections.Generic.KeyValuePair`2[TKey,TValue]) +Microsoft.FSharp.Core.Operators: System.Type TypeDefOf[T]() +Microsoft.FSharp.Core.Operators: System.Type TypeOf[T]() +Microsoft.FSharp.Core.Operators: T Abs$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Abs[T](T) +Microsoft.FSharp.Core.Operators: T Acos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Acos[T](T) +Microsoft.FSharp.Core.Operators: T Asin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Asin[T](T) +Microsoft.FSharp.Core.Operators: T Atan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Atan[T](T) +Microsoft.FSharp.Core.Operators: T Ceiling$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Ceiling[T](T) +Microsoft.FSharp.Core.Operators: T Cos$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Cos[T](T) +Microsoft.FSharp.Core.Operators: T Cosh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Cosh[T](T) +Microsoft.FSharp.Core.Operators: T DefaultArg[T](Microsoft.FSharp.Core.FSharpOption`1[T], T) +Microsoft.FSharp.Core.Operators: T DefaultIfNullV[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: T DefaultIfNull[T](T, T) +Microsoft.FSharp.Core.Operators: T DefaultValueArg[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], T) +Microsoft.FSharp.Core.Operators: T Exit[T](Int32) +Microsoft.FSharp.Core.Operators: T Exp$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Exp[T](T) +Microsoft.FSharp.Core.Operators: T FailWith[T](System.String) +Microsoft.FSharp.Core.Operators: T Floor$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Floor[T](T) +Microsoft.FSharp.Core.Operators: T Identity[T](T) +Microsoft.FSharp.Core.Operators: T InvalidArg[T](System.String, System.String) +Microsoft.FSharp.Core.Operators: T InvalidOp[T](System.String) +Microsoft.FSharp.Core.Operators: T Lock[TLock,T](TLock, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) +Microsoft.FSharp.Core.Operators: T Log$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Log10$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Log10[T](T) +Microsoft.FSharp.Core.Operators: T Log[T](T) +Microsoft.FSharp.Core.Operators: T Max[T](T, T) +Microsoft.FSharp.Core.Operators: T Min[T](T, T) +Microsoft.FSharp.Core.Operators: T NonNullQuickPattern[T](T) +Microsoft.FSharp.Core.Operators: T NonNullQuickValuePattern[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: T NonNullV[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.Operators: T NonNull[T](T) +Microsoft.FSharp.Core.Operators: T NullArgCheck[T](System.String, T) +Microsoft.FSharp.Core.Operators: T NullArg[T](System.String) +Microsoft.FSharp.Core.Operators: T PowInteger$W[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, Int32) +Microsoft.FSharp.Core.Operators: T PowInteger[T](T, Int32) +Microsoft.FSharp.Core.Operators: T Raise[T](System.Exception) +Microsoft.FSharp.Core.Operators: T Reraise[T]() +Microsoft.FSharp.Core.Operators: T Rethrow[T]() +Microsoft.FSharp.Core.Operators: T Round$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Round[T](T) +Microsoft.FSharp.Core.Operators: T Sin$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Sin[T](T) +Microsoft.FSharp.Core.Operators: T Sinh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Sinh[T](T) +Microsoft.FSharp.Core.Operators: T Tan$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Tan[T](T) +Microsoft.FSharp.Core.Operators: T Tanh$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Tanh[T](T) +Microsoft.FSharp.Core.Operators: T Truncate$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T Truncate[T](T) +Microsoft.FSharp.Core.Operators: T Unbox[T](System.Object) +Microsoft.FSharp.Core.Operators: T WithNull[T](T) +Microsoft.FSharp.Core.Operators: T op_BitwiseAnd$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: T op_BitwiseAnd[T](T, T) +Microsoft.FSharp.Core.Operators: T op_BitwiseOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: T op_BitwiseOr[T](T, T) +Microsoft.FSharp.Core.Operators: T op_Dereference[T](Microsoft.FSharp.Core.FSharpRef`1[T]) +Microsoft.FSharp.Core.Operators: T op_ExclusiveOr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[T,T]], T, T) +Microsoft.FSharp.Core.Operators: T op_ExclusiveOr[T](T, T) +Microsoft.FSharp.Core.Operators: T op_Exponentiation$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TResult,T]], T, TResult) +Microsoft.FSharp.Core.Operators: T op_Exponentiation[T,TResult](T, TResult) +Microsoft.FSharp.Core.Operators: T op_LeftShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32) +Microsoft.FSharp.Core.Operators: T op_LeftShift[T](T, Int32) +Microsoft.FSharp.Core.Operators: T op_LogicalNot$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T op_LogicalNot[T](T) +Microsoft.FSharp.Core.Operators: T op_RightShift$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,T]], T, Int32) +Microsoft.FSharp.Core.Operators: T op_RightShift[T](T, Int32) +Microsoft.FSharp.Core.Operators: T op_UnaryNegation$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T op_UnaryNegation[T](T) +Microsoft.FSharp.Core.Operators: T op_UnaryPlus$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,T], T) +Microsoft.FSharp.Core.Operators: T op_UnaryPlus[T](T) +Microsoft.FSharp.Core.Operators: T1 Fst[T1,T2](System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.Operators: T2 Atan2$W[T1,T2](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T1,T2]], T1, T1) +Microsoft.FSharp.Core.Operators: T2 Atan2[T1,T2](T1, T1) +Microsoft.FSharp.Core.Operators: T2 Snd[T1,T2](System.Tuple`2[T1,T2]) +Microsoft.FSharp.Core.Operators: T3 op_Addition$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Addition[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Division$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Division[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Modulus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Modulus[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Multiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Multiply[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Subtraction$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, T2) +Microsoft.FSharp.Core.Operators: T3 op_Subtraction[T1,T2,T3](T1, T2) +Microsoft.FSharp.Core.Operators: TResult Sqrt$W[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T) +Microsoft.FSharp.Core.Operators: TResult Sqrt[T,TResult](T) +Microsoft.FSharp.Core.Operators: TResult ToEnum[TResult](Int32) +Microsoft.FSharp.Core.Operators: TResult Using[T,TResult](T, Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Core.Operators: TResult op_PipeLeft2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], T1, T2) +Microsoft.FSharp.Core.Operators: TResult op_PipeLeft3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], T1, T2, T3) +Microsoft.FSharp.Core.Operators: TResult op_PipeLeft[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], T) +Microsoft.FSharp.Core.Operators: TResult op_PipeRight2[T1,T2,TResult](T1, T2, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]) +Microsoft.FSharp.Core.Operators: TResult op_PipeRight3[T1,T2,T3,TResult](T1, T2, T3, Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]]) +Microsoft.FSharp.Core.Operators: TResult op_PipeRight[T1,TResult](T1, Microsoft.FSharp.Core.FSharpFunc`2[T1,TResult]) +Microsoft.FSharp.Core.Operators: UInt16 ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], T) +Microsoft.FSharp.Core.Operators: UInt16 ToUInt16[T](T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt32[T](T) +Microsoft.FSharp.Core.Operators: UInt32 ToUInt[T](T) +Microsoft.FSharp.Core.Operators: UInt64 ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], T) +Microsoft.FSharp.Core.Operators: UInt64 ToUInt64[T](T) +Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], T) +Microsoft.FSharp.Core.Operators: UIntPtr ToUIntPtr[T](T) +Microsoft.FSharp.Core.Operators: Void Decrement(Microsoft.FSharp.Core.FSharpRef`1[System.Int32]) +Microsoft.FSharp.Core.Operators: Void Ignore[T](T) +Microsoft.FSharp.Core.Operators: Void Increment(Microsoft.FSharp.Core.FSharpRef`1[System.Int32]) +Microsoft.FSharp.Core.Operators: Void op_ColonEquals[T](Microsoft.FSharp.Core.FSharpRef`1[T], T) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: FSharpFunc`3 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: TResult Invoke(T1, T2) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: FSharpFunc`4 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: TResult Invoke(T1, T2, T3) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: FSharpFunc`5 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,TResult]]] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: TResult Invoke(T1, T2, T3, T4) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: FSharpFunc`6 Adapt(Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]]]) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,Microsoft.FSharp.Core.FSharpFunc`2[T4,Microsoft.FSharp.Core.FSharpFunc`2[T5,TResult]]]] Invoke(T1) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: TResult Invoke(T1, T2, T3, T4, T5) +Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult]: Void .ctor() +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`3[T1,T2,TResult] +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`4[T1,T2,T3,TResult] +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`5[T1,T2,T3,T4,TResult] +Microsoft.FSharp.Core.OptimizedClosures: Microsoft.FSharp.Core.OptimizedClosures+FSharpFunc`6[T1,T2,T3,T4,T5,TResult] +Microsoft.FSharp.Core.OptionModule: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Int32 Count[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[TResult]], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpOption`1[T1], Microsoft.FSharp.Core.FSharpOption`1[T2], Microsoft.FSharp.Core.FSharpOption`1[T3]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpOption`1[T]]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfNullable[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfObj[T](T) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OfValueOption[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpOption`1[T]], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpOption`1[T], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T GetValue[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T ToObj[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpOption`1[T], TState) +Microsoft.FSharp.Core.OptionModule: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: T[] ToArray[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionModule: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.OptionalArgumentAttribute: Void .ctor() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] Captures +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Object[] get_Captures() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String ToString() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String Value +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.String get_Value() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] CaptureTypes +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: System.Type[] get_CaptureTypes() +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String) +Microsoft.FSharp.Core.PrintfFormat`4[TPrinter,TState,TResidue,TResult]: Void .ctor(System.String, System.Object[], System.Type[]) +Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String) +Microsoft.FSharp.Core.PrintfFormat`5[TPrinter,TState,TResidue,TResult,TTuple]: Void .ctor(System.String, System.Object[], System.Type[]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatLineToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatLine[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToError[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilderThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringBuilder[T](System.Text.StringBuilder, Microsoft.FSharp.Core.PrintfFormat`4[T,System.Text.StringBuilder,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThenFail[T,TResult](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[System.String,TResult], Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToStringThen[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriterThen[TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TResult], System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,TResult]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.PrintfModule: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ProjectionParameterAttribute: Void .ctor() +Microsoft.FSharp.Core.ReferenceEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean IncludeValue +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Boolean get_IncludeValue() +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor() +Microsoft.FSharp.Core.ReflectedDefinitionAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.RequireQualifiedAccessAttribute: Void .ctor() +Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute: Void .ctor() +Microsoft.FSharp.Core.ResultModule: Boolean Contains[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean Exists[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean ForAll[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean IsError[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Boolean IsOk[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Int32 Count[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[T,TResult] MapError[TError,TResult,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Bind[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpResult`2[TResult,TError]], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpResult`2[TResult,TError] Map[T,TResult,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Microsoft.FSharp.Core.FSharpValueOption`1[T] ToValueOption[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: T DefaultValue[T,TError](T, Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: T DefaultWith[TError,T](Microsoft.FSharp.Core.FSharpFunc`2[TError,T], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: TState FoldBack[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpResult`2[T,TError], TState) +Microsoft.FSharp.Core.ResultModule: TState Fold[T,TError,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: T[] ToArray[T,TError](Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.ResultModule: Void Iterate[T,TError](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpResult`2[T,TError]) +Microsoft.FSharp.Core.SealedAttribute: Boolean Value +Microsoft.FSharp.Core.SealedAttribute: Boolean get_Value() +Microsoft.FSharp.Core.SealedAttribute: Void .ctor() +Microsoft.FSharp.Core.SealedAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.SourceConstructFlags: Int32 value__ +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Closure +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Exception +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Field +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags KindMask +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Module +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags NonPublicRepresentation +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags None +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags ObjectType +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags RecordType +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags SumType +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags UnionCase +Microsoft.FSharp.Core.SourceConstructFlags: Microsoft.FSharp.Core.SourceConstructFlags Value +Microsoft.FSharp.Core.StringModule: Boolean Exists(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String) +Microsoft.FSharp.Core.StringModule: Boolean ForAll(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String) +Microsoft.FSharp.Core.StringModule: Int32 Length(System.String) +Microsoft.FSharp.Core.StringModule: System.String Collect(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.String], System.String) +Microsoft.FSharp.Core.StringModule: System.String Concat(System.String, System.Collections.Generic.IEnumerable`1[System.String]) +Microsoft.FSharp.Core.StringModule: System.String Filter(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Boolean], System.String) +Microsoft.FSharp.Core.StringModule: System.String Initialize(Int32, Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String]) +Microsoft.FSharp.Core.StringModule: System.String Map(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char], System.String) +Microsoft.FSharp.Core.StringModule: System.String MapIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,System.Char]], System.String) +Microsoft.FSharp.Core.StringModule: System.String Replicate(Int32, System.String) +Microsoft.FSharp.Core.StringModule: Void Iterate(Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit], System.String) +Microsoft.FSharp.Core.StringModule: Void IterateIndexed(Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Char,Microsoft.FSharp.Core.Unit]], System.String) +Microsoft.FSharp.Core.StructAttribute: Void .ctor() +Microsoft.FSharp.Core.StructuralComparisonAttribute: Void .ctor() +Microsoft.FSharp.Core.StructuralEqualityAttribute: Void .ctor() +Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String Value +Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: System.String get_Value() +Microsoft.FSharp.Core.StructuredFormatDisplayAttribute: Void .ctor(System.String) +Microsoft.FSharp.Core.TailCallAttribute: Void .ctor() +Microsoft.FSharp.Core.Unit: Boolean Equals(System.Object) +Microsoft.FSharp.Core.Unit: Int32 GetHashCode() +Microsoft.FSharp.Core.UnverifiableAttribute: Void .ctor() +Microsoft.FSharp.Core.ValueOption: Boolean Contains[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean Exists[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean ForAll[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean IsNone[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Boolean IsSome[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Int32 Count[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Collections.FSharpList`1[T] ToList[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpOption`1[T] ToOption[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpValueOption`1[TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map2[T1,T2,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,TResult]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map3[T1,T2,T3,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,Microsoft.FSharp.Core.FSharpFunc`2[T3,TResult]]], Microsoft.FSharp.Core.FSharpValueOption`1[T1], Microsoft.FSharp.Core.FSharpValueOption`1[T2], Microsoft.FSharp.Core.FSharpValueOption`1[T3]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Filter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] Flatten[T](Microsoft.FSharp.Core.FSharpValueOption`1[Microsoft.FSharp.Core.FSharpValueOption`1[T]]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfNullable[T](System.Nullable`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfObj[T](T) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OfOption[T](Microsoft.FSharp.Core.FSharpOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElseWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.FSharpValueOption`1[T]], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Microsoft.FSharp.Core.FSharpValueOption`1[T] OrElse[T](Microsoft.FSharp.Core.FSharpValueOption`1[T], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: System.Nullable`1[T] ToNullable[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T DefaultValue[T](T, Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T DefaultWith[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T GetValue[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T ToObj[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: TState FoldBack[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[TState,TState]], Microsoft.FSharp.Core.FSharpValueOption`1[T], TState) +Microsoft.FSharp.Core.ValueOption: TState Fold[T,TState](Microsoft.FSharp.Core.FSharpFunc`2[TState,Microsoft.FSharp.Core.FSharpFunc`2[T,TState]], TState, Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: T[] ToArray[T](Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.ValueOption: Void Iterate[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpValueOption`1[T]) +Microsoft.FSharp.Core.VolatileFieldAttribute: Void .ctor() +Microsoft.FSharp.Core.WarnOnWithoutNullArgumentAttribute: System.String WarningMessage +Microsoft.FSharp.Core.WarnOnWithoutNullArgumentAttribute: System.String get_WarningMessage() +Microsoft.FSharp.Core.WarnOnWithoutNullArgumentAttribute: Void .ctor(System.String) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToByte[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Byte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Byte] ToUInt8[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Char], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Char] ToChar[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Decimal], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Decimal] ToDecimal[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToDouble[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Double], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Double] ToFloat[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int16], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int16] ToInt16[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt32[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int32] ToInt[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Int64], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Int64] ToInt64[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.IntPtr], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.IntPtr] ToIntPtr[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToInt8[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.SByte], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.SByte] ToSByte[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToFloat32[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Single], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.Single] ToSingle[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt16], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt16] ToUInt16[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt32], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt32[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt32] ToUInt[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UInt64], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UInt64] ToUInt64[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr$W[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.UIntPtr], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[System.UIntPtr] ToUIntPtr[T](System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableModule: System.Nullable`1[TResult] ToEnum[TResult](System.Nullable`1[System.Int32]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_EqualsQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterEqualsQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_GreaterQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessEqualsQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessGreaterQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_LessQmark[T](T, System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkEquals[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterEquals[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkGreater[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEqualsQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessEquals[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreaterQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessGreater[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLessQmark[T](System.Nullable`1[T], System.Nullable`1[T]) +Microsoft.FSharp.Linq.NullableOperators: Boolean op_QmarkLess[T](System.Nullable`1[T], T) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_DivideQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MinusQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_MultiplyQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PercentQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_PlusQmark[T1,T2,T3](T1, System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivideQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkDivide[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMinus[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiplyQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkMultiply[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercentQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPercent[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark$W[T1,T2,T3](Microsoft.FSharp.Core.FSharpFunc`2[T1,Microsoft.FSharp.Core.FSharpFunc`2[T2,T3]], System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlusQmark[T1,T2,T3](System.Nullable`1[T1], System.Nullable`1[T2]) +Microsoft.FSharp.Linq.NullableOperators: System.Nullable`1[T3] op_QmarkPlus[T1,T2,T3](System.Nullable`1[T1], T2) +Microsoft.FSharp.Linq.QueryBuilder: Boolean All[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Boolean Contains[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], T) +Microsoft.FSharp.Linq.QueryBuilder: Boolean Exists[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Int32 Count[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,TValue],Q] GroupValBy[T,TKey,TValue,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[System.Linq.IGrouping`2[TKey,T],Q] GroupBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Distinct[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SkipWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Skip[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] SortBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Source[T,Q](System.Linq.IQueryable`1[T]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] TakeWhile[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Take[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullableDescending[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenByNullable[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TKey]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] ThenBy[T,Q,TKey](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TKey]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Where[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] YieldFrom[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Yield[T,Q](T) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,Q] Zero[T,Q]() +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable] Source[T](System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] For[T,Q,TResult,Q2](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Linq.QuerySource`2[TResult,Q2]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] GroupJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Join[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[TInner,TResult]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] LeftOuterJoin[TOuter,Q,TInner,TKey,TResult](Microsoft.FSharp.Linq.QuerySource`2[TOuter,Q], Microsoft.FSharp.Linq.QuerySource`2[TInner,Q], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TInner,TKey], Microsoft.FSharp.Core.FSharpFunc`2[TOuter,Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[TInner],TResult]]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Linq.QuerySource`2[TResult,Q] Select[T,Q,TResult](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TResult]) +Microsoft.FSharp.Linq.QueryBuilder: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Quote[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Linq.QueryBuilder: System.Linq.IQueryable`1[T] Run[T](Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Linq.IQueryable]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] AverageByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MaxByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] MinByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: System.Nullable`1[TValue] SumByNullable[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Nullable`1[TValue]]) +Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOneOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T ExactlyOne[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Find[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]) +Microsoft.FSharp.Linq.QueryBuilder: T HeadOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Head[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T LastOrDefault[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Last[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q]) +Microsoft.FSharp.Linq.QueryBuilder: T Nth[T,Q](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Int32) +Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,TValue]], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue AverageBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue MaxBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue MinBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy$W[T,Q,TValue](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,TValue], Microsoft.FSharp.Core.FSharpFunc`2[TValue,Microsoft.FSharp.Core.FSharpFunc`2[TValue,TValue]], Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: TValue SumBy[T,Q,TValue](Microsoft.FSharp.Linq.QuerySource`2[T,Q], Microsoft.FSharp.Core.FSharpFunc`2[T,TValue]) +Microsoft.FSharp.Linq.QueryBuilder: Void .ctor() +Microsoft.FSharp.Linq.QueryRunExtensions.HighPriority: System.Collections.Generic.IEnumerable`1[T] RunQueryAsEnumerable[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[Microsoft.FSharp.Linq.QuerySource`2[T,System.Collections.IEnumerable]]) +Microsoft.FSharp.Linq.QueryRunExtensions.LowPriority: T RunQueryAsValue[T](Microsoft.FSharp.Linq.QueryBuilder, Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] Source +Microsoft.FSharp.Linq.QuerySource`2[T,Q]: System.Collections.Generic.IEnumerable`1[T] get_Source() +Microsoft.FSharp.Linq.QuerySource`2[T,Q]: Void .ctor(System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`1[T1]: Void .ctor(T1) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`2[T1,T2]: Void .ctor(T1, T2) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`3[T1,T2,T3]: Void .ctor(T1, T2, T3) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`4[T1,T2,T3,T4]: Void .ctor(T1, T2, T3, T4) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`5[T1,T2,T3,T4,T5]: Void .ctor(T1, T2, T3, T4, T5) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 Item6 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: T6 get_Item6() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`6[T1,T2,T3,T4,T5,T6]: Void .ctor(T1, T2, T3, T4, T5, T6) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 Item6 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T6 get_Item6() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 Item7 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: T7 get_Item7() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`7[T1,T2,T3,T4,T5,T6,T7]: Void .ctor(T1, T2, T3, T4, T5, T6, T7) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Boolean Equals(System.Object) +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Int32 GetHashCode() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 Item1 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T1 get_Item1() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 Item2 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T2 get_Item2() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 Item3 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T3 get_Item3() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 Item4 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T4 get_Item4() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 Item5 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T5 get_Item5() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 Item6 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T6 get_Item6() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 Item7 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T7 get_Item7() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 Item8 +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: T8 get_Item8() +Microsoft.FSharp.Linq.RuntimeHelpers.AnonymousObject`8[T1,T2,T3,T4,T5,T6,T7,T8]: Void .ctor(T1, T2, T3, T4, T5, T6, T7, T8) +Microsoft.FSharp.Linq.RuntimeHelpers.Grouping`2[K,T]: Void .ctor(K, System.Collections.Generic.IEnumerable`1[T]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr SubstHelperRaw(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: Microsoft.FSharp.Quotations.FSharpExpr`1[T] SubstHelper[T](Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar[], System.Object[]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression QuotationToExpression(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] ImplicitExpressionConversionHelper[T](T) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Linq.Expressions.Expression`1[T] QuotationToLambdaExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: System.Object EvaluateQuotation(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T MemberInitializationHelper[T](T) +Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter: T NewAnonymousObjectHelper[T](T) +Microsoft.FSharp.NativeInterop.NativePtrModule: Boolean IsNullPointer[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr AddPointerInlined[T](IntPtr, Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr NullPointer[T]() +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfILSigPtrInlined[T](T*) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfNativeIntInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr OfVoidPtrInlined[T](Void*) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr StackAllocate[T](Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: IntPtr ToNativeIntInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: T GetPointerInlined[T](IntPtr, Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: T ReadPointerInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: T& ToByRefInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: T* ToILSigPtrInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void ClearPointerInlined[T](IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyBlockInlined[T](IntPtr, IntPtr, Int32) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void CopyPointerInlined[T](IntPtr, IntPtr) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void InitializeBlockInlined[T](IntPtr, Byte, UInt32) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void SetPointerInlined[T](IntPtr, Int32, T) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void WritePointerInlined[T](IntPtr, T) +Microsoft.FSharp.NativeInterop.NativePtrModule: Void* ToVoidPtrInlined[T](IntPtr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[System.Type],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] SpecificCallPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.Unit] UnitPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] MethodWithReflectedDefinitionPattern(System.Reflection.MethodBase) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertyGetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] PropertySetterWithReflectedDefinitionPattern(System.Reflection.PropertyInfo) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Boolean] BoolPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Byte] BytePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Char] CharPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Decimal] DecimalPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Double] DoublePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int16] Int16Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] Int32Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Int64] Int64Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.SByte] SBytePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Single] SinglePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.String] StringPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar]],Microsoft.FSharp.Quotations.FSharpExpr]] LambdasPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]]] ApplicationsPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AndAlsoPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] OrElsePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt16] UInt16Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt32] UInt32Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.DerivedPatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.UInt64] UInt64Pattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Core.FSharpChoice`3[Microsoft.FSharp.Quotations.FSharpVar,System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr],System.Tuple`2[System.Object,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] ShapePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.ExprShapeModule: Microsoft.FSharp.Quotations.FSharpExpr RebuildShapeCombination(System.Object, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Boolean Equals(System.Object) +Microsoft.FSharp.Quotations.FSharpExpr: Int32 GetHashCode() +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] CustomAttributes +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr] get_CustomAttributes() +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] TryGetReflectedDefinition(System.Reflection.MethodBase) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressOf(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr AddressSet(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Application(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Applications(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Call(System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr CallWithWitnesses(System.Reflection.MethodInfo, System.Reflection.MethodInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Coerce(Microsoft.FSharp.Quotations.FSharpExpr, System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr DefaultValue(System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize(System.Type, Microsoft.FSharp.Collections.FSharpList`1[System.Type], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr], Byte[]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Deserialize40(System.Type, System.Type[], System.Type[], Microsoft.FSharp.Quotations.FSharpExpr[], Byte[]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldGet(System.Reflection.FieldInfo) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr FieldSet(System.Reflection.FieldInfo, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ForIntegerRangeLoop(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr IfThenElse(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Lambda(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Let(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr LetRecursive(Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]], Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewArray(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewDelegate(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar], Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewObject(System.Reflection.ConstructorInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewRecord(System.Type, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewStructTuple(System.Reflection.Assembly, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewTuple(Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr NewUnionCase(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertyGet(System.Reflection.PropertyInfo, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(Microsoft.FSharp.Quotations.FSharpExpr, System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr PropertySet(System.Reflection.PropertyInfo, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Quote(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteRaw(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr QuoteTyped(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Sequential(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Substitute(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr]]) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryFinally(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TryWith(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TupleGet(Microsoft.FSharp.Quotations.FSharpExpr, Int32) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr TypeTest(Microsoft.FSharp.Quotations.FSharpExpr, System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr UnionCaseTest(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Reflection.UnionCaseInfo) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value(System.Object, System.Type) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName(System.Object, System.Type, System.String) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr ValueWithName[T](T, System.String) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Value[T](T) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr Var(Microsoft.FSharp.Quotations.FSharpVar) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr VarSet(Microsoft.FSharp.Quotations.FSharpVar, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WhileLoop(Microsoft.FSharp.Quotations.FSharpExpr, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr WithValue(System.Object, System.Type, Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] Cast[T](Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] GlobalVar[T](System.String) +Microsoft.FSharp.Quotations.FSharpExpr: Microsoft.FSharp.Quotations.FSharpExpr`1[T] WithValue[T](T, Microsoft.FSharp.Quotations.FSharpExpr`1[T]) +Microsoft.FSharp.Quotations.FSharpExpr: System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Quotations.FSharpVar] GetFreeVars() +Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString() +Microsoft.FSharp.Quotations.FSharpExpr: System.String ToString(Boolean) +Microsoft.FSharp.Quotations.FSharpExpr: System.Type Type +Microsoft.FSharp.Quotations.FSharpExpr: System.Type get_Type() +Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[]) +Microsoft.FSharp.Quotations.FSharpExpr: Void RegisterReflectedDefinitions(System.Reflection.Assembly, System.String, Byte[], System.Type[]) +Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr Raw +Microsoft.FSharp.Quotations.FSharpExpr`1[T]: Microsoft.FSharp.Quotations.FSharpExpr get_Raw() +Microsoft.FSharp.Quotations.FSharpVar: Boolean Equals(System.Object) +Microsoft.FSharp.Quotations.FSharpVar: Boolean IsMutable +Microsoft.FSharp.Quotations.FSharpVar: Boolean get_IsMutable() +Microsoft.FSharp.Quotations.FSharpVar: Int32 GetHashCode() +Microsoft.FSharp.Quotations.FSharpVar: Microsoft.FSharp.Quotations.FSharpVar Global(System.String, System.Type) +Microsoft.FSharp.Quotations.FSharpVar: System.String Name +Microsoft.FSharp.Quotations.FSharpVar: System.String ToString() +Microsoft.FSharp.Quotations.FSharpVar: System.String get_Name() +Microsoft.FSharp.Quotations.FSharpVar: System.Type Type +Microsoft.FSharp.Quotations.FSharpVar: System.Type get_Type() +Microsoft.FSharp.Quotations.FSharpVar: Void .ctor(System.String, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewStructTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]] NewTuplePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] AddressOfPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuotePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteRawPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr] QuoteTypedPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpVar] VarPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]],Microsoft.FSharp.Quotations.FSharpExpr]] LetRecursivePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo]] FieldGetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] AddressSetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ApplicationPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] SequentialPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] TryFinallyPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] WhileLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Reflection.UnionCaseInfo]] UnionCaseTestPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Int32]] TupleGetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] CoercePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpExpr,System.Type]] TypeTestPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] LambdaPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] VarSetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewUnionCasePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Object,System.Type]] ValuePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewObjectPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewArrayPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] NewRecordPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.FieldInfo,Microsoft.FSharp.Quotations.FSharpExpr]] FieldSetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] PropertyGetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] IfThenElsePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] LetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,Microsoft.FSharp.Quotations.FSharpExpr]] WithValuePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Object,System.Type,System.String]] ValueWithNamePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`3[System.Type,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpVar],Microsoft.FSharp.Quotations.FSharpExpr]] NewDelegatePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.PropertyInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Quotations.FSharpExpr]] PropertySetPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`4[Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpExpr]] ForIntegerRangeLoopPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Quotations.FSharpExpr],System.Reflection.MethodInfo,System.Reflection.MethodInfo,Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr],Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Quotations.FSharpExpr]]] CallWithWitnessesPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`5[Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr,Microsoft.FSharp.Quotations.FSharpVar,Microsoft.FSharp.Quotations.FSharpExpr]] TryWithPattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Quotations.PatternsModule: Microsoft.FSharp.Core.FSharpOption`1[System.Type] DefaultValuePattern(Microsoft.FSharp.Quotations.FSharpExpr) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsExceptionRepresentation.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsRecord.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Boolean FSharpType.IsUnion.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] FSharpValue.PreComputeUnionTagReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeRecordReader.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] FSharpValue.PreComputeUnionReader.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeRecordConstructor.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] FSharpValue.PreComputeUnionConstructor.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: Microsoft.FSharp.Reflection.UnionCaseInfo[] FSharpType.GetUnionCases.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeRecord.Static(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object FSharpValue.MakeUnion.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetExceptionFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Object[] FSharpValue.GetRecordFields.Static(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.ConstructorInfo FSharpValue.PreComputeRecordConstructorInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MemberInfo FSharpValue.PreComputeUnionTagMemberInfo.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.MethodInfo FSharpValue.PreComputeUnionConstructorInfo.Static(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetExceptionFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Reflection.PropertyInfo[] FSharpType.GetRecordFields.Static(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpReflectionExtensions: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] FSharpValue.GetUnionFields.Static(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean]) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsExceptionRepresentation(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsFunction(System.Type) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsModule(System.Type) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsRecord(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsTuple(System.Type) +Microsoft.FSharp.Reflection.FSharpType: Boolean IsUnion(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: Microsoft.FSharp.Reflection.UnionCaseInfo[] GetUnionCases(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetExceptionFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: System.Reflection.PropertyInfo[] GetRecordFields(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpType: System.Tuple`2[System.Type,System.Type] GetFunctionElements(System.Type) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeFunctionType(System.Type, System.Type) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Reflection.Assembly, System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeStructTupleType(System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Reflection.Assembly, System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type MakeTupleType(System.Type[]) +Microsoft.FSharp.Reflection.FSharpType: System.Type[] GetTupleElements(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Int32] PreComputeUnionTagReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeRecordReader(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeTupleReader(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object[]] PreComputeUnionReader(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object] PreComputeRecordFieldReader(System.Reflection.PropertyInfo) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeRecordConstructor(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeTupleConstructor(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: Microsoft.FSharp.Core.FSharpFunc`2[System.Object[],System.Object] PreComputeUnionConstructor(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object GetRecordField(System.Object, System.Reflection.PropertyInfo) +Microsoft.FSharp.Reflection.FSharpValue: System.Object GetTupleField(System.Object, Int32) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeFunction(System.Type, Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeRecord(System.Type, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeTuple(System.Object[], System.Type) +Microsoft.FSharp.Reflection.FSharpValue: System.Object MakeUnion(Microsoft.FSharp.Reflection.UnionCaseInfo, System.Object[], Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetExceptionFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetRecordFields(System.Object, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Object[] GetTupleFields(System.Object) +Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.ConstructorInfo PreComputeRecordConstructorInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MemberInfo PreComputeUnionTagMemberInfo(System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Reflection.MethodInfo PreComputeUnionConstructorInfo(Microsoft.FSharp.Reflection.UnionCaseInfo, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[Microsoft.FSharp.Reflection.UnionCaseInfo,System.Object[]] GetUnionFields(System.Object, System.Type, Microsoft.FSharp.Core.FSharpOption`1[System.Reflection.BindingFlags]) +Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.ConstructorInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Type]] PreComputeTupleConstructorInfo(System.Type) +Microsoft.FSharp.Reflection.FSharpValue: System.Tuple`2[System.Reflection.PropertyInfo,Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Type,System.Int32]]] PreComputeTuplePropertyInfo(System.Type, Int32) +Microsoft.FSharp.Reflection.UnionCaseInfo: Boolean Equals(System.Object) +Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 GetHashCode() +Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 Tag +Microsoft.FSharp.Reflection.UnionCaseInfo: Int32 get_Tag() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Collections.Generic.IList`1[System.Reflection.CustomAttributeData] GetCustomAttributesData() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Object[] GetCustomAttributes(System.Type) +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Reflection.PropertyInfo[] GetFields() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name +Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name() +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType() \ No newline at end of file diff --git a/tests/FSharp.Core.UnitTests/SurfaceArea.fs b/tests/FSharp.Core.UnitTests/SurfaceArea.fs index c52b1fba19f..5e5d0126fc6 100644 --- a/tests/FSharp.Core.UnitTests/SurfaceArea.fs +++ b/tests/FSharp.Core.UnitTests/SurfaceArea.fs @@ -24,7 +24,7 @@ type SurfaceAreaTest() = // We are testing the surface area of the FSharp.Core assembly. #if NETCOREAPP - "netstandard21" + "netcore" #else "netstandard20" #endif From 27944e7cd38bd8fc9092b791c87fa2eb406e644b Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 22 Aug 2026 10:26:39 +0200 Subject: [PATCH 17/59] surf --- .../FSharp.Core.SurfaceArea.netcore.debug.bsl | 11 +++++------ .../FSharp.Core.SurfaceArea.netcore.release.bsl | 5 ++--- .../FSharp.Core.SurfaceArea.netstandard20.release.bsl | 10 +++++----- .../FSharp.Core.SurfaceArea.netstandard21.release.bsl | 10 +++++----- tests/FSharp.Test.Utilities/SurfaceArea.fs | 2 +- 5 files changed, 18 insertions(+), 20 deletions(-) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl index 7d32ca31c24..9c43a6bc4d8 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl @@ -1,5 +1,3 @@ -! AssemblyReference: System.Runtime.Numerics -! AssemblyReference: netstandard Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,]) Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,]) Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,]) @@ -677,9 +675,9 @@ Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[] Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.ValueTask`1[T]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) @@ -852,6 +850,7 @@ Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value() Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor() Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.AllowOverloadOnReturnTypeAttribute: Void .ctor() Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path() Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor() @@ -1002,10 +1001,10 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) -Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName() Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor() @@ -1120,11 +1119,11 @@ Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TR Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl index ceaf3d54fae..59db3956794 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl @@ -1,5 +1,3 @@ -! AssemblyReference: System.Runtime.Numerics -! AssemblyReference: netstandard Microsoft.FSharp.Collections.Array2DModule: Int32 Base1[T](T[,]) Microsoft.FSharp.Collections.Array2DModule: Int32 Base2[T](T[,]) Microsoft.FSharp.Collections.Array2DModule: Int32 Length1[T](T[,]) @@ -852,6 +850,7 @@ Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean Value Microsoft.FSharp.Core.AllowNullLiteralAttribute: Boolean get_Value() Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor() Microsoft.FSharp.Core.AllowNullLiteralAttribute: Void .ctor(Boolean) +Microsoft.FSharp.Core.AllowOverloadOnReturnTypeAttribute: Void .ctor() Microsoft.FSharp.Core.AutoOpenAttribute: System.String Path Microsoft.FSharp.Core.AutoOpenAttribute: System.String get_Path() Microsoft.FSharp.Core.AutoOpenAttribute: Void .ctor() @@ -1002,10 +1001,10 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) -Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String AssemblyName Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: System.String get_AssemblyName() Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute: Void .ctor() diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl index 956b82a5b4f..cd66e9af3f9 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard20.release.bsl @@ -673,8 +673,8 @@ Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[] Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) @@ -687,8 +687,8 @@ Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_Def Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.Tasks.TaskCreationOptions], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: System.Threading.Tasks.Task`1[T] StartImmediateAsTask[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg,System.AsyncCallback,System.Object],System.IAsyncResult],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T],Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,Microsoft.FSharp.Core.Unit]] AsBeginEnd[TArg,T](Microsoft.FSharp.Core.FSharpFunc`2[TArg,Microsoft.FSharp.Control.FSharpAsync`1[T]]) -Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: T RunSynchronously[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Int32], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) +Microsoft.FSharp.Control.FSharpAsync: T RunSynchronouslyImmediate[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: Void CancelDefaultToken() Microsoft.FSharp.Control.FSharpAsync: Void Start(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) Microsoft.FSharp.Control.FSharpAsync: Void StartImmediate(Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpOption`1[System.Threading.CancellationToken]) @@ -1103,11 +1103,11 @@ Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TR Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item @@ -2695,4 +2695,4 @@ Microsoft.FSharp.Reflection.UnionCaseInfo: System.String Name Microsoft.FSharp.Reflection.UnionCaseInfo: System.String ToString() Microsoft.FSharp.Reflection.UnionCaseInfo: System.String get_Name() Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type DeclaringType -Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType() \ No newline at end of file +Microsoft.FSharp.Reflection.UnionCaseInfo: System.Type get_DeclaringType() diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl index 995205b0470..b04e73244a7 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netstandard21.release.bsl @@ -677,16 +677,16 @@ Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[] Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Parallel[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]], Microsoft.FSharp.Core.FSharpOption`1[System.Int32]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T[]] Sequential[T](System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitEvent[TDel,T](Microsoft.FSharp.Control.IEvent`2[TDel,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] Await[T](System.Threading.Tasks.ValueTask`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] AwaitTask[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]) +Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,TArg3,T](TArg1, TArg2, TArg3, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`5[TArg1,TArg2,TArg3,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,TArg2,T](TArg1, TArg2, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`4[TArg1,TArg2,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[TArg1,T](TArg1, Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[TArg1,System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromBeginEnd[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`2[System.AsyncCallback,System.Object],System.IAsyncResult], Microsoft.FSharp.Core.FSharpFunc`2[System.IAsyncResult,T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] FromContinuations[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Tuple`3[Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]],Microsoft.FSharp.Core.Unit]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]) -Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] StartTaskImmediate[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.ValueTask`1[T]]) Microsoft.FSharp.Control.FSharpAsync: Microsoft.FSharp.Control.FSharpAsync`1[T] TryCancelled[T](Microsoft.FSharp.Control.FSharpAsync`1[T], Microsoft.FSharp.Core.FSharpFunc`2[System.OperationCanceledException,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken DefaultCancellationToken Microsoft.FSharp.Control.FSharpAsync: System.Threading.CancellationToken get_DefaultCancellationToken() @@ -1120,11 +1120,11 @@ Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToStringThenFail[T,TR Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToString[T](Microsoft.FSharp.Core.PrintfFormat`4[T,Microsoft.FSharp.Core.Unit,System.String,System.String]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormatToTextWriter[T](System.IO.TextWriter, Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T PrintFormat[T](Microsoft.FSharp.Core.PrintfFormat`4[T,System.IO.TextWriter,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) +Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceExpression[T](Microsoft.FSharp.Quotations.FSharpExpr`1[T]) Microsoft.FSharp.Core.ExtraTopLevelOperators: T SpliceUntypedExpression[T](Microsoft.FSharp.Quotations.FSharpExpr) Microsoft.FSharp.Core.ExtraTopLevelOperators: T[,] CreateArray2D[a,T](System.Collections.Generic.IEnumerable`1[a]) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValueLine[T](T) -Microsoft.FSharp.Core.ExtraTopLevelOperators: Void PrintValue[T](T) Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 Item Microsoft.FSharp.Core.FSharpChoice`2+Choice1Of2[T1,T2]: T1 get_Item() Microsoft.FSharp.Core.FSharpChoice`2+Choice2Of2[T1,T2]: T2 Item diff --git a/tests/FSharp.Test.Utilities/SurfaceArea.fs b/tests/FSharp.Test.Utilities/SurfaceArea.fs index 8b6e6c90748..96c6ddfdc6b 100644 --- a/tests/FSharp.Test.Utilities/SurfaceArea.fs +++ b/tests/FSharp.Test.Utilities/SurfaceArea.fs @@ -81,4 +81,4 @@ module FSharp.Test.SurfaceArea verifyWith true (fun _ -> true) assembly baselinePath let verifyIgnoringAssemblyReferences assembly baselinePath : unit = - verifyWith false (fun line -> not (line.StartsWith("! AssemblyReference:", StringComparison.Ordinal))) assembly baselinePath + verifyWith true (fun line -> not (line.StartsWith("! AssemblyReference:", StringComparison.Ordinal))) assembly baselinePath From 1d6f3b8096fb16910b3d40e5cfff75b40df5b05a Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 22 Aug 2026 18:18:32 +0200 Subject: [PATCH 18/59] do not emit .tail in runtime async methods --- src/Compiler/CodeGen/IlxGen.fs | 25 +++++++++++++++++-- .../Language/RuntimeAsyncEdgeCaseTests.fs | 17 ++++++------- 2 files changed, 30 insertions(+), 12 deletions(-) diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index aaf59ffed49..5416c215f16 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -1261,6 +1261,9 @@ and IlxGenEnv = /// Are we under the scope of a try, catch or finally? If so we can't tailcall. SEH = structured exception handling withinSEH: bool + /// We are generating a runtime-async method/closure body, which forbids tail prefixes. + inRuntimeAsyncMethod: bool + /// Suppresses filter block emission inside finally/fault handlers (workaround for dotnet/runtime#112406). insideFinallyOrFaultHandler: bool @@ -4695,6 +4698,7 @@ and GenApp (cenv: cenv) cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel = isDllImport, isSelfInit, makesNoCriticalTailcalls, + eenv.inRuntimeAsyncMethod, cgbuf, sequel ) @@ -4825,6 +4829,7 @@ and CanTailcall isDllImport, isSelfInit, makesNoCriticalTailcalls, + inRuntimeAsyncMethod, cgbuf: CodeGenBuffer, sequel ) = @@ -4832,6 +4837,7 @@ and CanTailcall // Can't tailcall with a struct object arg since it involves a byref // Can't tailcall with a .NET 2.0 generic constrained call since it involves a byref // Can't tailcall when there are pinned locals since the stack frame must remain alive + // Runtime-async methods forbid .tail according to the CLI spec. let hasPinnedLocals = cgbuf.HasPinnedLocals() let hasStackAllocatedLocals = cgbuf.HasStackAllocatedLocals() @@ -4839,6 +4845,7 @@ and CanTailcall not hasStructObjArg && Option.isNone ccallInfo && not withinSEH + && not inRuntimeAsyncMethod && not hasByrefArg && not isDllImport && not isSelfInit @@ -5043,7 +5050,7 @@ and GenIndirectCall cenv cgbuf eenv (funcTy, tyargs, curriedArgs, m) sequel = check ilxClosureApps let isTailCall = - CanTailcall(false, None, eenv.withinSEH, hasByrefArg, false, false, false, false, cgbuf, sequel) + CanTailcall(false, None, eenv.withinSEH, hasByrefArg, false, false, false, false, eenv.inRuntimeAsyncMethod, cgbuf, sequel) CountCallFuncInstructions() @@ -5784,6 +5791,7 @@ and GenILCall isDllImport, false, makesNoCriticalTailcalls, + eenv.inRuntimeAsyncMethod, cgbuf, sequel ) @@ -7159,6 +7167,11 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body + let eenvinner = + { eenvinner with + inRuntimeAsyncMethod = isRuntimeAsync + } + let ilCloBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) @@ -7215,6 +7228,11 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body + let eenvinner = + { eenvinner with + inRuntimeAsyncMethod = isRuntimeAsync + } + let ilCloBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) @@ -9935,7 +9953,9 @@ and GenMethodForBinding else eenvForMeth - eenvForMeth + { eenvForMeth with + inRuntimeAsyncMethod = isRuntimeAsync + } let tailCallInfo = [ @@ -13083,6 +13103,7 @@ let GetEmptyIlxGenEnv (g: TcGlobals) ccu = innerVals = [] sigToImplRemapInfo = [] (* "module remap info" *) withinSEH = false + inRuntimeAsyncMethod = false insideFinallyOrFaultHandler = false isInLoop = false initLocals = true diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 11b03779f72..dfec9b3dcf4 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -176,32 +176,29 @@ let ``the CE builder lowers to Await with no state machine`` () = "IAsyncStateMachine" ] -// CONTRACT VIOLATION (finding C1): the tail-position function-value call is emitted with a `tail.` -// prefix (IL_000d) inside a runtime-async body. The runtime-async contract forbids `tail.`, and -// ilverify reports `TailRetType` on this exact method. Pinning the whole body makes the offending -// prefix unambiguous; once IlxGen.CanTailcall learns about runtime-async the `IL_000d: tail.` line -// must disappear and this expected body must be updated. +// Runtime-async methods must not emit `.tail`. This body is the contract pin: a function-value call +// in the runtime-async return position is normal (non-tail) so the runtime-async spec's TailRetType +// requirement remains satisfied. let private tailPrefixBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 f(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2 g, int32 x) cil managed noinlining { .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) - // Code size 21 (0x15) + // Code size 20 (0x14) .maxstack 8 IL_0000: ldc.i4.1 IL_0001: call class [System.Runtime]System.Threading.Tasks.Task [System.Runtime]System.Threading.Tasks.Task::Delay(int32) IL_0006: call void [System.Runtime]System.Runtime.CompilerServices.AsyncHelpers::Await(class [System.Runtime]System.Threading.Tasks.Task) IL_000b: ldarg.0 IL_000c: ldarg.1 - IL_000d: tail. - IL_000f: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2::Invoke(!0) - IL_0014: ret + IL_000d: callvirt instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2::Invoke(!0) + IL_0012: ret } // end of method M::f """ [] -let ``runtime async currently emits a forbidden tail prefix (C1)`` () = +let ``runtime async avoids a forbidden tail prefix (C1)`` () = compileDirect "let f (g: int -> int) (x: int) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); g x)" |> verifyILContains [ tailPrefixBody ] |> shouldSucceed From 773866444fe4e89219eabee43e95f8ff4951ccea Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 22 Aug 2026 19:46:13 +0200 Subject: [PATCH 19/59] error on AsyncHelpers use outside of async method --- docs/runtime-async.md | 4 ++++ src/Compiler/CodeGen/IlxGen.fs | 24 +++++++++++++++++++ src/Compiler/FSComp.txt | 1 + src/Compiler/xlf/FSComp.txt.cs.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.de.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.es.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.fr.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.it.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.ja.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.ko.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.pl.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.pt-BR.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.ru.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.tr.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.zh-Hans.xlf | 5 ++++ src/Compiler/xlf/FSComp.txt.zh-Hant.xlf | 5 ++++ .../Language/RuntimeAsyncTests.fs | 19 +++++++++++++++ 17 files changed, 113 insertions(+) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 709e79dd298..fa80c6d5142 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -61,6 +61,10 @@ Known runtime restrictions (currently **not** diagnosed by the F# compiler): executes). * Byref, byref-like, and pinned locals cannot be preserved across suspension. +Calls to `AsyncHelpers` suspension methods emitted outside a runtime-async +method are rejected during code generation. Explicitly `inline` method bodies +are treated as templates and checked at their eventual use site. + ## F# surface The source-level marker is the compiler intrinsic diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index 5416c215f16..cf1e2700810 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -1264,6 +1264,9 @@ and IlxGenEnv = /// We are generating a runtime-async method/closure body, which forbids tail prefixes. inRuntimeAsyncMethod: bool + /// Inline method bodies are templates whose suspension calls are checked at their eventual use site. + inInlineMethod: bool + /// Suppresses filter block emission inside finally/fault handlers (workaround for dotnet/runtime#112406). insideFinallyOrFaultHandler: bool @@ -3155,6 +3158,18 @@ let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body | _ -> false, expr +let private IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = + let (TILObjectReprData(coreLibScope, _, _)) = g.system_Object_tcref.ILTyconInfo + + ilMethRef.DeclaringTypeRef.Scope = coreLibScope + && ilMethRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" + && ilMethRef.Name + |> function + | "Await" + | "AwaitAwaiter" + | "UnsafeAwaitAwaiter" -> true + | _ -> false + //------------------------------------------------------------------------- // Generate expressions //------------------------------------------------------------------------- @@ -5781,6 +5796,13 @@ and GenILCall let makesNoCriticalTailcalls = (newobj || not virt) // Don't tailcall for 'newobj', or 'call' to IL code let hasStructObjArg = valu && ilMethRef.CallingConv.IsInstance + if + not eenv.inRuntimeAsyncMethod + && not eenv.inInlineMethod + && IsRuntimeAsyncSuspensionMethod cenv.g ilMethRef + then + errorR (Error(FSComp.SR.ilRuntimeAsyncSuspensionOutsideRuntimeAsync (RichText.mkText ilMethRef.Name), m)) + let tail = CanTailcall( hasStructObjArg, @@ -9955,6 +9977,7 @@ and GenMethodForBinding { eenvForMeth with inRuntimeAsyncMethod = isRuntimeAsync + inInlineMethod = v.InlineInfo = ValInline.Always } let tailCallInfo = @@ -13104,6 +13127,7 @@ let GetEmptyIlxGenEnv (g: TcGlobals) ccu = sigToImplRemapInfo = [] (* "module remap info" *) withinSEH = false inRuntimeAsyncMethod = false + inInlineMethod = false insideFinallyOrFaultHandler = false isInLoop = false initLocals = true diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt index 318612bfe6a..19ba33406c6 100644 --- a/src/Compiler/FSComp.txt +++ b/src/Compiler/FSComp.txt @@ -1553,6 +1553,7 @@ csTypeHasNullAsExtraValue,"The type '%s' supports 'null' but a non-null type is 3351,chkFeatureNotRuntimeSupported,"Feature '%s' is not supported by target runtime." 3352,typrelInterfaceMemberNoMostSpecificImplementation,"Interface member '%s' does not have a most specific implementation." 3353,fsiInvalidDirective,"Invalid directive '#%s %s'" +3354,ilRuntimeAsyncSuspensionOutsideRuntimeAsync,"Runtime async suspension method '%s' may only be called from a runtime async method." useSdkRefs,"Use reference assemblies for .NET framework references when available (Enabled by default)." optsCheckNulls,"Enable nullness declarations and checks (%s by default)" fSharpBannerVersion,"%s for F# %s" diff --git a/src/Compiler/xlf/FSComp.txt.cs.xlf b/src/Compiler/xlf/FSComp.txt.cs.xlf index ec8ea8c2d39..b701c464e05 100644 --- a/src/Compiler/xlf/FSComp.txt.cs.xlf +++ b/src/Compiler/xlf/FSComp.txt.cs.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Neznámý bod ladění {0}. Dostupné body ladění jsou {1}. diff --git a/src/Compiler/xlf/FSComp.txt.de.xlf b/src/Compiler/xlf/FSComp.txt.de.xlf index bbd650053a3..eb2329004c0 100644 --- a/src/Compiler/xlf/FSComp.txt.de.xlf +++ b/src/Compiler/xlf/FSComp.txt.de.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Unbekannter Debugpunkt „{0}“. Die verfügbaren Debugpunkte sind „{1}“. diff --git a/src/Compiler/xlf/FSComp.txt.es.xlf b/src/Compiler/xlf/FSComp.txt.es.xlf index 1f3e9c1f616..f1ef8e07169 100644 --- a/src/Compiler/xlf/FSComp.txt.es.xlf +++ b/src/Compiler/xlf/FSComp.txt.es.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Punto de depuración desconocido \"{0}\". Los puntos de depuración disponibles son \"{1}\". diff --git a/src/Compiler/xlf/FSComp.txt.fr.xlf b/src/Compiler/xlf/FSComp.txt.fr.xlf index 63472c3de44..76b7c801ec6 100644 --- a/src/Compiler/xlf/FSComp.txt.fr.xlf +++ b/src/Compiler/xlf/FSComp.txt.fr.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Point de débogage inconnu « {0} ». Les points de débogage disponibles sont «{1}». diff --git a/src/Compiler/xlf/FSComp.txt.it.xlf b/src/Compiler/xlf/FSComp.txt.it.xlf index dc6a5fe0f04..daacb98d9d3 100644 --- a/src/Compiler/xlf/FSComp.txt.it.xlf +++ b/src/Compiler/xlf/FSComp.txt.it.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Punto di debug '{0}' sconosciuto. I punti di debug disponibili sono '{1}'. diff --git a/src/Compiler/xlf/FSComp.txt.ja.xlf b/src/Compiler/xlf/FSComp.txt.ja.xlf index 81c80bb3b46..e768faf9866 100644 --- a/src/Compiler/xlf/FSComp.txt.ja.xlf +++ b/src/Compiler/xlf/FSComp.txt.ja.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. 不明なデバッグ ポイントの `{0}`。使用可能なデバッグ ポイントは `{1}` です。 diff --git a/src/Compiler/xlf/FSComp.txt.ko.xlf b/src/Compiler/xlf/FSComp.txt.ko.xlf index 9343affd3df..cf5b04d0c35 100644 --- a/src/Compiler/xlf/FSComp.txt.ko.xlf +++ b/src/Compiler/xlf/FSComp.txt.ko.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. 알 수 없는 디버그 지점 '{0}'. 사용 가능한 디버그 지점은 '{1}'입니다. diff --git a/src/Compiler/xlf/FSComp.txt.pl.xlf b/src/Compiler/xlf/FSComp.txt.pl.xlf index 44544be13f5..ce099cd688e 100644 --- a/src/Compiler/xlf/FSComp.txt.pl.xlf +++ b/src/Compiler/xlf/FSComp.txt.pl.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Nieznany punkt debugowania „{0}”. Dostępnymi punktami debugowania są „{1}”. diff --git a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf index 79c69171638..1c6428eebb8 100644 --- a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf +++ b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Ponto de depuração desconhecido '{0}'. Os pontos de depuração disponíveis são '{1}'. diff --git a/src/Compiler/xlf/FSComp.txt.ru.xlf b/src/Compiler/xlf/FSComp.txt.ru.xlf index e5b6ac6100c..8ade9aff4c6 100644 --- a/src/Compiler/xlf/FSComp.txt.ru.xlf +++ b/src/Compiler/xlf/FSComp.txt.ru.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Неизвестная точка отладки \"{0}\". Доступные точки отладки: \"{1}\". diff --git a/src/Compiler/xlf/FSComp.txt.tr.xlf b/src/Compiler/xlf/FSComp.txt.tr.xlf index 66b738a214c..e45cbeaeda2 100644 --- a/src/Compiler/xlf/FSComp.txt.tr.xlf +++ b/src/Compiler/xlf/FSComp.txt.tr.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. Bilinmeyen hata ayıklama noktası '{0}'. Kullanılabilir hata ayıklama noktaları '{1}'. diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf index c5ac56305ae..67acd2bb6eb 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. 调试点“{0}”未知。可用的调试点为“{1}”。 diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf index 2a3b306d5df..5f2ec5107d7 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + Runtime async suspension method '{0}' may only be called from a runtime async method. + Runtime async suspension method '{0}' may only be called from a runtime async method. + + Unknown debug point '{0}'. The available debug points are '{1}'. 未知的偵錯點 '{0}'。可用的偵錯點為 '{1}'。 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 6919e59c532..1ce3bbd4c28 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -95,6 +95,25 @@ let f : Task = |> shouldFail |> withErrorCode 3350 +[] +let ``runtime async suspension outside runtime async is rejected`` () = + FSharp """ +module RuntimeAsyncSuspensionContextTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices + +let f () = + AsyncHelpers.Await(Task.Delay(1)) + AsyncHelpers.AwaitAwaiter(Task.Delay(1).GetAwaiter()) + AsyncHelpers.UnsafeAwaitAwaiter(Task.Delay(1).GetAwaiter()) +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compile + |> shouldFail + |> withErrorCodes [ 3354; 3354; 3354 ] + [] let ``runtime async rejects non Task result carriers`` () = FSharp """ From 6f2338d790ec037c77bfeb53415d748f93523bd6 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Sat, 22 Aug 2026 21:05:43 +0200 Subject: [PATCH 20/59] add non-preservable-value diagnostics --- .../.FSharp.Compiler.Service/11.0.100.md | 2 +- docs/runtime-async.md | 7 +-- .../Checking/Expressions/CheckExpressions.fs | 3 ++ src/Compiler/CodeGen/IlxGen.fs | 48 +++++++++++++++++++ src/Compiler/FSComp.txt | 1 + src/Compiler/xlf/FSComp.txt.cs.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.de.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.es.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.fr.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.it.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.ja.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.ko.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.pl.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.pt-BR.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.ru.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.tr.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.zh-Hans.xlf | 5 ++ src/Compiler/xlf/FSComp.txt.zh-Hant.xlf | 5 ++ .../Language/RuntimeAsyncEdgeCaseTests.fs | 27 ++++++----- 19 files changed, 137 insertions(+), 16 deletions(-) diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md index 0020b70a86c..8d971b7b224 100644 --- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md +++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md @@ -151,7 +151,7 @@ * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289)) * Symbols: add ObsoleteDiagnosticInfo ([PR #19359](https://github.com/dotnet/fsharp/pull/19359)) * FCS: add FSharpCheckFileResults.HasErrors ([PR #19892](https://github.com/dotnet/fsharp/pull/19892)) -* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsyncReturn` intrinsic, including carrier validation and target-runtime capability checks. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) +* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsyncReturn` intrinsic, including carrier validation, target-runtime capability checks, diagnostics for suspension calls outside runtime-async methods, and diagnostics for byref, byref-like, or pinned values used after suspension. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * Add `#version;;` directive to F# Interactive to display version and environment information. ([Issue #13307](https://github.com/dotnet/fsharp/issues/13307), [PR #19332](https://github.com/dotnet/fsharp/pull/19332)) * Add diagnostic FS3889 when a namespace and a type have the same fully-qualified name in the same assembly, replacing the misleading FS0247 "namespace and a module" error. ([Issue #17827](https://github.com/dotnet/fsharp/issues/17827), [PR #19802](https://github.com/dotnet/fsharp/pull/19802)) * Debug: rework for expressions stepping ([PR #19894](https://github.com/dotnet/fsharp/pull/19894)) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index fa80c6d5142..878146d6b54 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -59,7 +59,8 @@ Known runtime restrictions (currently **not** diagnosed by the F# compiler): `try`, then restores a pending exception. This makes `use` on an `IAsyncDisposable` work under runtime async (`testUsingAsyncDisposableSync` executes). -* Byref, byref-like, and pinned locals cannot be preserved across suspension. +Byref, byref-like, and pinned locals that are used after a suspension are +rejected with diagnostic FS3357. Calls to `AsyncHelpers` suspension methods emitted outside a runtime-async method are rejected during code generation. Explicitly `inline` method bodies @@ -231,8 +232,8 @@ element-type propagation through `Bind` without an annotation, and unannotated ## Not yet implemented -* Diagnostics for suspension in exception-handling regions, byref/byref-like - or pinned locals across suspension, `tail.`, and `localloc`. +* Diagnostics for suspension in exception-handling regions, `tail.`, and + `localloc`. * Non-generic `Task` and `ValueTask`/`ValueTask<'T>` return shapes. * Any FSharp.Core builder (the test builder is test-only). * Compile-time enforcement that the marker was actually consumed before diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 89e8a1f795f..bee429befd8 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -12325,6 +12325,9 @@ and TcLetBinding (cenv: cenv) isUse env containerInfo declKind tpenv (synBinds, tmp, checkedPat + if isFixed then + patternInputTmp.SetIsFixed() + // Add the bind "let patternInputTmp = rhsExpr" to the bodyExpr we get from mkPatBind let mkRhsBind (bodyExpr, bodyExprTy) = let letExpr = mkLet debugPoint m patternInputTmp rhsExpr bodyExpr diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index cf1e2700810..79ca7a27bab 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -1264,6 +1264,9 @@ and IlxGenEnv = /// We are generating a runtime-async method/closure body, which forbids tail prefixes. inRuntimeAsyncMethod: bool + /// Method parameters whose storage cannot be preserved across a runtime-async suspension. + runtimeAsyncMethodVars: ValRef list + /// Inline method bodies are templates whose suspension calls are checked at their eventual use site. inInlineMethod: bool @@ -2659,6 +2662,9 @@ let FeeFee (cenv: cenv) = let FeeFeeInstr (cenv: cenv) doc = I_seqpoint(ILDebugPoint.Create(document = doc, line = FeeFee cenv, column = 0, endLine = FeeFee cenv, endColumn = 0)) +let IsRuntimeAsyncNonPreservableVal (g: TcGlobals) (v: Val) = + v.IsFixed || isByrefTy g v.Type || isByrefLikeTy g v.Range v.Type + /// Buffers for IL code generation type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs: int) = @@ -2666,6 +2672,9 @@ type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs let locals = ResizeArray<(string * (Mark * Mark)) list * ILType * bool * bool>(10) let codebuf = ResizeArray(200) let exnSpecs = ResizeArray(10) + let runtimeAsyncTrackedLocals = HashSet() + let runtimeAsyncSuspendedLocals = HashSet() + let runtimeAsyncReportedLocals = HashSet() // Keep track of the current stack so we can spill stuff when we hit a "try" when some stuff // is on the stack. @@ -2908,6 +2917,25 @@ type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs member _.HasPinnedLocals() = locals |> Seq.exists (fun (_, _, isFixed, _) -> isFixed) + member _.TrackRuntimeAsyncLocal(vref: ValRef) = + runtimeAsyncTrackedLocals.Add(vref.Deref.Stamp) |> ignore + + member _.MarkRuntimeAsyncSuspension(locals: ValRef list) = + for vref in locals do + runtimeAsyncSuspendedLocals.Add(vref.Deref.Stamp) |> ignore + + for stamp in runtimeAsyncTrackedLocals do + runtimeAsyncSuspendedLocals.Add stamp |> ignore + + member _.CheckRuntimeAsyncLocalUse(vref: ValRef) = + let stamp = vref.Deref.Stamp + + if + runtimeAsyncSuspendedLocals.Contains stamp + && runtimeAsyncReportedLocals.Add stamp + then + errorR (Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension (RichText.mkText vref.Deref.LogicalName), vref.Deref.Range)) + member _.HasStackAllocatedLocals() = hasStackAllocatedLocals member _.Close() = @@ -5803,6 +5831,11 @@ and GenILCall then errorR (Error(FSComp.SR.ilRuntimeAsyncSuspensionOutsideRuntimeAsync (RichText.mkText ilMethRef.Name), m)) + if IsRuntimeAsyncSuspensionMethod cenv.g ilMethRef then + eenv.runtimeAsyncMethodVars @ eenv.letBoundVars + |> List.filter (fun vref -> IsRuntimeAsyncNonPreservableVal cenv.g vref.Deref) + |> cgbuf.MarkRuntimeAsyncSuspension + let tail = CanTailcall( hasStructObjArg, @@ -5946,6 +5979,7 @@ and GenGetAddrOfRefCellField cenv cgbuf eenv (e, ty, m) sequel = GenSequel cenv eenv.cloc cgbuf sequel and GenGetValAddr cenv cgbuf eenv (v: ValRef, m) sequel = + cgbuf.CheckRuntimeAsyncLocalUse v let vspec = v.Deref let ilTy = GenTypeOfVal cenv eenv vspec let storage = StorageForValRef m v eenv @@ -9977,6 +10011,11 @@ and GenMethodForBinding { eenvForMeth with inRuntimeAsyncMethod = isRuntimeAsync + runtimeAsyncMethodVars = + if isRuntimeAsync then + methLambdaVars |> List.map mkLocalValRef + else + [] inInlineMethod = v.InlineInfo = ValInline.Always } @@ -10430,6 +10469,7 @@ and GenBindings cenv cgbuf eenv binds stateVarFlagsOpt = //------------------------------------------------------------------------- and GenSetVal cenv cgbuf eenv (vref, e, m) sequel = + cgbuf.CheckRuntimeAsyncLocalUse vref let storage = StorageForValRef m vref eenv GetStoreValCtxt cgbuf eenv vref.Deref GenExpr cenv cgbuf eenv e Continue @@ -10437,6 +10477,7 @@ and GenSetVal cenv cgbuf eenv (vref, e, m) sequel = GenUnitThenSequel cenv eenv m eenv.cloc cgbuf sequel and GenGetValRefAndSequel cenv cgbuf eenv m (v: ValRef) storeSequel = + cgbuf.CheckRuntimeAsyncLocalUse v let ty = v.Type GenGetStorageAndSequel cenv cgbuf eenv m (ty, GenType cenv m eenv.tyenv ty) (StorageForValRef m v eenv) storeSequel @@ -10595,12 +10636,15 @@ and GenGetFreeVarForClosure cenv cgbuf eenv m (fv: Val) = CG.EmitInstr cgbuf (pop 1) (Push [ ilUnderlyingTy ]) (mkNormalLdobj ilUnderlyingTy) and GenGetLocalVal cenv cgbuf eenv m (vspec: Val) storeSequel = + cgbuf.CheckRuntimeAsyncLocalUse(mkLocalValRef vspec) GenGetStorageAndSequel cenv cgbuf eenv m (vspec.Type, GenTypeOfVal cenv eenv vspec) (StorageForVal m vspec eenv) storeSequel and GenGetLocalVRef cenv cgbuf eenv m (vref: ValRef) storeSequel = + cgbuf.CheckRuntimeAsyncLocalUse vref GenGetStorageAndSequel cenv cgbuf eenv m (vref.Type, GenTypeOfVal cenv eenv vref.Deref) (StorageForValRef m vref eenv) storeSequel and GenStoreVal cgbuf eenv m (vspec: Val) = + cgbuf.CheckRuntimeAsyncLocalUse(mkLocalValRef vspec) GenSetStorage vspec.Range cgbuf (StorageForVal m vspec eenv) and CanRealloc isFixed eenv ty i (_, ty2, isFixed2, canBeReallocd) = @@ -10632,6 +10676,9 @@ and AllocLocal cenv cgbuf eenv compgen (v, ty, isFixed) (scopeMarks: Mark * Mark and AllocLocalVal cenv cgbuf v eenv repr scopeMarks = let g = cenv.g + if eenv.inRuntimeAsyncMethod && IsRuntimeAsyncNonPreservableVal g v then + cgbuf.TrackRuntimeAsyncLocal(mkLocalValRef v) + let repr, eenv = let ty = v.Type @@ -13127,6 +13174,7 @@ let GetEmptyIlxGenEnv (g: TcGlobals) ccu = sigToImplRemapInfo = [] (* "module remap info" *) withinSEH = false inRuntimeAsyncMethod = false + runtimeAsyncMethodVars = [] inInlineMethod = false insideFinallyOrFaultHandler = false isInLoop = false diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt index 19ba33406c6..0f29633e274 100644 --- a/src/Compiler/FSComp.txt +++ b/src/Compiler/FSComp.txt @@ -1554,6 +1554,7 @@ csTypeHasNullAsExtraValue,"The type '%s' supports 'null' but a non-null type is 3352,typrelInterfaceMemberNoMostSpecificImplementation,"Interface member '%s' does not have a most specific implementation." 3353,fsiInvalidDirective,"Invalid directive '#%s %s'" 3354,ilRuntimeAsyncSuspensionOutsideRuntimeAsync,"Runtime async suspension method '%s' may only be called from a runtime async method." +3357,ilRuntimeAsyncLocalUsedAfterSuspension,"A byref, byref-like, or pinned local '%s' cannot be used after a runtime async suspension." useSdkRefs,"Use reference assemblies for .NET framework references when available (Enabled by default)." optsCheckNulls,"Enable nullness declarations and checks (%s by default)" fSharpBannerVersion,"%s for F# %s" diff --git a/src/Compiler/xlf/FSComp.txt.cs.xlf b/src/Compiler/xlf/FSComp.txt.cs.xlf index b701c464e05..5d94e7cb688 100644 --- a/src/Compiler/xlf/FSComp.txt.cs.xlf +++ b/src/Compiler/xlf/FSComp.txt.cs.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.de.xlf b/src/Compiler/xlf/FSComp.txt.de.xlf index eb2329004c0..5b495b7b63f 100644 --- a/src/Compiler/xlf/FSComp.txt.de.xlf +++ b/src/Compiler/xlf/FSComp.txt.de.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.es.xlf b/src/Compiler/xlf/FSComp.txt.es.xlf index f1ef8e07169..04a4185633c 100644 --- a/src/Compiler/xlf/FSComp.txt.es.xlf +++ b/src/Compiler/xlf/FSComp.txt.es.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.fr.xlf b/src/Compiler/xlf/FSComp.txt.fr.xlf index 76b7c801ec6..03ac39ecc25 100644 --- a/src/Compiler/xlf/FSComp.txt.fr.xlf +++ b/src/Compiler/xlf/FSComp.txt.fr.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.it.xlf b/src/Compiler/xlf/FSComp.txt.it.xlf index daacb98d9d3..6c5262d7981 100644 --- a/src/Compiler/xlf/FSComp.txt.it.xlf +++ b/src/Compiler/xlf/FSComp.txt.it.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.ja.xlf b/src/Compiler/xlf/FSComp.txt.ja.xlf index e768faf9866..3034c65c87a 100644 --- a/src/Compiler/xlf/FSComp.txt.ja.xlf +++ b/src/Compiler/xlf/FSComp.txt.ja.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.ko.xlf b/src/Compiler/xlf/FSComp.txt.ko.xlf index cf5b04d0c35..f55b61b6ed4 100644 --- a/src/Compiler/xlf/FSComp.txt.ko.xlf +++ b/src/Compiler/xlf/FSComp.txt.ko.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.pl.xlf b/src/Compiler/xlf/FSComp.txt.pl.xlf index ce099cd688e..fd4a78d3d43 100644 --- a/src/Compiler/xlf/FSComp.txt.pl.xlf +++ b/src/Compiler/xlf/FSComp.txt.pl.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf index 1c6428eebb8..eccf4e90a38 100644 --- a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf +++ b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.ru.xlf b/src/Compiler/xlf/FSComp.txt.ru.xlf index 8ade9aff4c6..d86f26399e3 100644 --- a/src/Compiler/xlf/FSComp.txt.ru.xlf +++ b/src/Compiler/xlf/FSComp.txt.ru.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.tr.xlf b/src/Compiler/xlf/FSComp.txt.tr.xlf index e45cbeaeda2..e7f7930f02c 100644 --- a/src/Compiler/xlf/FSComp.txt.tr.xlf +++ b/src/Compiler/xlf/FSComp.txt.tr.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf index 67acd2bb6eb..04e6fa46fed 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf index 5f2ec5107d7..e915396cc77 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf @@ -817,6 +817,11 @@ The type '{0}' is not a valid custom attribute argument type. Custom attribute arrays must have elements of primitive types, enums, string, System.Type, or System.Object. + + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index dfec9b3dcf4..3d286cf6aad 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -14,9 +14,7 @@ module Language.RuntimeAsyncEdgeCaseTests // The CE `Run` lowers `do!`/`let!` to exactly this intrinsic form (see the execution facts). // // The "undiagnosed forbidden pattern" facts below pin restrictions that docs/runtime-async.md -// records as known and currently NOT diagnosed by the F# compiler (tail./localloc forbidden; -// suspension forbidden inside EH regions; byref/byref-like locals not preservable across a -// suspension). They compile clean today; the comments record the observed runtime outcome. +// records as known and currently NOT diagnosed by the F# compiler (tail./localloc forbidden). open Xunit open FSharp.Test.Compiler @@ -372,21 +370,26 @@ let ``exception handling block suspensions compile and run correctly`` (_label: -// These direct-intrinsic restrictions remain undiagnosed; exception handlers are rewritten before -// code generation and are covered by the execution test above. [] -[ = StateMachineHelpers.__runtimeAsyncReturn (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] // runtime: IndexOutOfRangeException (C14) +[) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] [) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); x)")>] // byref read after suspension; C# gives CS1988 -let ``contract-forbidden suspension pattern compiles with no diagnostic`` (_label: string) (body: string) = + "let f (x: byref) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); x)")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p 0)")>] +let ``non-preservable values after suspension are rejected`` (_label: string) (body: string) = compileDirect body + |> shouldFail + |> withErrorCode 3357 + +[] +let ``non-preservable value not used after suspension is allowed`` () = + compileDirect + "let f (x: byref) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); 1)" |> shouldSucceed [] -// Positive counterpart to the ref-struct row above: the same code through the CE builder IS rejected, -// because the continuation lambda captures the ref-struct local (FS0406). The CE provides a safety -// net that the delegate-free intrinsic does not. +// The CE builder rejects a ref-struct local captured by its continuation lambda (FS0406). let ``ref struct across a suspension is rejected through the CE builder`` () = FsFromPath builderPath |> withAdditionalSourceFile (FsSource refStructAcrossAwaitCE) From 25e87ba1d8bce7325f1d3983f36bce2787976a8b Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Sun, 23 Aug 2026 00:47:32 +0200 Subject: [PATCH 21/59] make it work in debug --- .../.FSharp.Compiler.Service/11.0.100.md | 2 +- docs/runtime-async.md | 6 + src/Compiler/CodeGen/IlxGen.fs | 2 +- src/Compiler/Optimize/Optimizer.fs | 247 ++++++++++++++---- .../Language/RuntimeAsyncEdgeCaseTests.fs | 7 +- .../Language/RuntimeAsyncTests.fs | 31 ++- 6 files changed, 246 insertions(+), 49 deletions(-) diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md index 8d971b7b224..4b7fa883c5d 100644 --- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md +++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md @@ -151,7 +151,7 @@ * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289)) * Symbols: add ObsoleteDiagnosticInfo ([PR #19359](https://github.com/dotnet/fsharp/pull/19359)) * FCS: add FSharpCheckFileResults.HasErrors ([PR #19892](https://github.com/dotnet/fsharp/pull/19892)) -* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsyncReturn` intrinsic, including carrier validation, target-runtime capability checks, diagnostics for suspension calls outside runtime-async methods, and diagnostics for byref, byref-like, or pinned values used after suspension. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) +* Add preview compiler support for runtime-async `Task<'T>` methods through the `__runtimeAsyncReturn` intrinsic, including carrier validation, target-runtime capability checks, diagnostics for suspension calls outside runtime-async methods, diagnostics for byref, byref-like, or pinned values used after suspension, and recursive specialization of inline suspension fragments when optimization is disabled. ([PR #20235](https://github.com/dotnet/fsharp/pull/20235)) * Add `#version;;` directive to F# Interactive to display version and environment information. ([Issue #13307](https://github.com/dotnet/fsharp/issues/13307), [PR #19332](https://github.com/dotnet/fsharp/pull/19332)) * Add diagnostic FS3889 when a namespace and a type have the same fully-qualified name in the same assembly, replacing the misleading FS0247 "namespace and a module" error. ([Issue #17827](https://github.com/dotnet/fsharp/issues/17827), [PR #19802](https://github.com/dotnet/fsharp/pull/19802)) * Debug: rework for expressions stepping ([PR #19894](https://github.com/dotnet/fsharp/pull/19894)) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 878146d6b54..8aec4f929ba 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -139,6 +139,12 @@ the optimizer never inlines, duplicates, or discards it. The marker therefore survives optimization as an ordinary `Expr.App` node; nothing else in the typed tree records that a method is runtime-async. +Inline values whose bodies contain the marker or an `AsyncHelpers` suspension +are recursively specialized at their call sites, including when optimization +is disabled. The optimizer follows nested inline calls and does not create a +generated helper method for the specialized suspension fragment, keeping every +suspension in the eventual runtime-async method. + ## Code generation `IlxGen.fs` recognises the marker in three placements diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index 79ca7a27bab..e0803badb5d 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3100,7 +3100,7 @@ let CodeGenThen (cenv: cenv) mgbuf (entryPointInfo, methodName, eenv, alreadyUse else mkILLocal ty None - if isFixed then { loc with IsPinned = true } else loc) + if isFixed && IsILTypeByref ty then { loc with IsPinned = true } else loc) (ilLocals, maxStack, lab2pc, code, exnSpecs, localDebugSpecs, hasDebugPoints) diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index 2dce697ea35..eed011f7bc4 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -499,6 +499,10 @@ type IncrementalOptimizationEnv = /// definition-site replay finds no match; this call site does, letting the correct extension be honored /// instead of degrading to the throwing dynamic stub. None outside the debug-specialization path. debugInlineCallSite: range option + + /// Indicates that the expression being optimized is the body of a runtime-async marker. + runtimeAsyncContext: bool + } static member Empty = @@ -513,7 +517,8 @@ type IncrementalOptimizationEnv = methEnv = { pipelineCount = 0 } referencedCcus = [] earlierImplFileSignatures = [] - debugInlineCallSite = None } + debugInlineCallSite = None + runtimeAsyncContext = false } override x.ToString() = "" @@ -2538,6 +2543,63 @@ let private ExprContainsRuntimeAsyncSuspension expr = FoldExpr folder false expr +let rec private HasRuntimeAsyncFragmentBody cenv env visiting (vref: ValRef) = + if List.exists ((=) vref.Stamp) visiting then + false + else + match TryGetInfoForVal cenv env vref |> Option.map (fun info -> stripValue info.ValExprInfo) with + | Some(CurriedLambdaValue (_, _, _, body, _)) -> + ExprContainsRuntimeAsyncFragment cenv env (vref.Stamp :: visiting) body + | _ -> + false + +and private ExprContainsRuntimeAsyncFragment cenv env visiting expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc then + true + else + match stripExpr expr with + | Expr.App(Expr.Val(vref, _, _), _, _, _, _) + when valRefEq cenv.g vref cenv.g.cgh__runtimeAsyncReturn_vref -> + true + | _ when IsRuntimeAsyncSuspensionExpr expr -> + true + | Expr.Val(vref, _, _) when vref.ShouldInline || vref.IsLocalRef -> + HasRuntimeAsyncFragmentBody cenv env visiting vref + | _ -> + noInterceptF acc expr } + + FoldExpr folder false expr + +let private ShouldForceRuntimeAsyncInline cenv env (vref: ValRef) (finfo: Summary) = + if env.runtimeAsyncContext && vref.InlineIfLambda && not vref.ShouldInline then + true + elif not (vref.ShouldInline || vref.IsLocalRef) then + false + else + match stripValue finfo.Info with + | CurriedLambdaValue (_, _, _, body, _) -> + ExprContainsRuntimeAsyncFragment cenv env [ vref.Stamp ] body + | _ -> + HasRuntimeAsyncFragmentBody cenv env [] vref + +let private ShouldForceRuntimeAsyncApplication cenv env vref finfo args = + ShouldForceRuntimeAsyncInline cenv env vref finfo + || ((vref.ShouldInline || vref.InlineIfLambda) + && List.exists (ExprContainsRuntimeAsyncFragment cenv env []) args) + || (env.runtimeAsyncContext + && vref.ShouldInline + && List.exists + (fun arg -> + match stripExpr arg with + | Expr.Lambda _ + | Expr.TyLambda _ -> true + | _ -> false) + args) + let private RuntimeAsyncChoiceTy (g: TcGlobals) (ty: TType) = TType_app(g.choice2_tcr, [ ty; g.exn_ty ], g.knownWithoutNull) @@ -2748,7 +2810,7 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = match expr with | Expr.App(Expr.Val(vref, flags, _), fty, [ _ ], [ body ], _) when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> - let bodyR, bodyInfo = OptimizeExpr cenv env body + let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } body let bodyR = RewriteRuntimeAsyncExceptionHandlers cenv bodyR Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), { bodyInfo with @@ -2978,6 +3040,47 @@ and OptimizeExprOp cenv env (op, tyargs, args, m) = // Reductions OptimizeExprOpReductions cenv env (op, tyargs, args, m) +and InlineRuntimeAsyncLambdaArgument cenv env expr = + let g = cenv.g + let inlineBinding (boundVal: Val) boundExpr body = + let rwenv = + { PreIntercept = + Some(fun _ expr -> + match stripExpr expr with + | Expr.Val(vref, _, _) when valEq boundVal vref.Deref -> + Some(copyExpr g CloneAll boundExpr) + | _ -> + None) + PreInterceptBinding = None + PostTransform = fun _ -> None + RewriteQuotations = false + StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") } + + RewriteExpr rwenv body + + let rwenv = + { PreIntercept = + Some(fun cont expr -> + match stripExpr expr with + | Expr.Let(TBind(boundVal, boundExpr, _), body, _, _) + when boundVal.InlineIfLambda + || ((match stripExpr boundExpr with + | Expr.Lambda _ + | Expr.TyLambda _ -> + true + | _ -> + false) + && ExprContainsRuntimeAsyncFragment cenv env [] boundExpr) -> + Some(cont (inlineBinding boundVal boundExpr body)) + | _ -> + None) + PreInterceptBinding = None + PostTransform = fun _ -> None + RewriteQuotations = false + StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") } + + RewriteExpr rwenv expr + and OptimizeExprOpReductions cenv env (op, tyargs, args, m) = let argsR, arginfos = OptimizeExprsThenConsiderSplits cenv env args OptimizeExprOpReductionsAfter cenv env (op, tyargs, argsR, arginfos, m) @@ -3424,7 +3527,6 @@ and OptimizeTraitCall cenv env (traitInfo, args, m) = match ConstraintSolver.CodegenWitnessExprForTraitConstraint cenv.TcVal g cenv.amap m traitInfoForResolution args with | OkResult (_, Some expr) -> OptimizeExpr cenv env expr - // Resolution fails when optimizing generic code, ignore the failure | _ -> match resolveWithRecordedSolution () with @@ -3835,7 +3937,12 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg let g = cenv.g match cenv.settings.alwaysInline, stripExpr valExpr with - | false, Expr.Val(vref, _, _) when vref.ShouldInline && not (shouldForceInlineInDebug cenv env vref) -> + | alwaysInline, Expr.Val(vref, _, _) + when ShouldForceRuntimeAsyncApplication cenv env vref finfo args + || (not alwaysInline + && vref.ShouldInline + && not (shouldForceInlineInDebug cenv env vref)) -> + let mustInlineRuntimeAsync = ShouldForceRuntimeAsyncApplication cenv env vref finfo args let hasNoTraits = let tps, _ = tryDestForallTy g vref.Type GetTraitConstraintInfosOfTypars g tps |> List.isEmpty @@ -3854,10 +3961,17 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg // so route those through the specialization path which inlines the body. let isHiddenBySignature = cenv.signatureHidingInfo.HiddenVals.Contains vref.Deref let canCallDirectly = + not mustInlineRuntimeAsync && (cenv.optimizing || (vref.Accessibility.IsPublic && not isHiddenBySignature)) && (hasNoTraits || (allTyargsAreBareTypars && vref.ValReprInfo.IsSome)) - let argsR = args |> List.map (OptimizeExpr cenv env >> fst) + let argEnv = + if mustInlineRuntimeAsync then + { env with runtimeAsyncContext = true } + else + env + + let argsR = args |> List.map (OptimizeExpr cenv argEnv >> fst) let info = { TotalSize = 1; FunctionSize = 1; HasEffect = true; MightMakeCriticalTailcall = false; Info = UnknownValue } if canCallDirectly then @@ -3865,8 +3979,16 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg else let origFinfo = GetInfoForVal cenv env m vref - match stripValue origFinfo.ValExprInfo with - | CurriedLambdaValue(origLambdaId, _, _, origLambda, origLambdaTy) -> + let lambdaInfo = + match stripValue finfo.Info with + | CurriedLambdaValue _ as info -> Some info + | _ -> + match stripValue origFinfo.ValExprInfo with + | CurriedLambdaValue _ as info -> Some info + | _ -> None + + match lambdaInfo with + | Some(CurriedLambdaValue(origLambdaId, _, _, origLambda, origLambdaTy)) -> let f2R = CopyExprForInlining cenv true origLambda m let specLambda = MakeApplicationAndBetaReduce g (f2R, origLambdaTy, [tyargs], [], m) let specLambdaTy = tyOfExpr g specLambda @@ -3893,7 +4015,10 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | None -> true if not canSpecialize then - None else + if mustInlineRuntimeAsync then + errorR(Error(FSComp.SR.optFailedToInlineValue(RichText.mkText vref.LogicalName), m)) + None + else let specLambdaR = if allTyargsAreConcrete then @@ -3901,13 +4026,19 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | Some (_, body) -> copyExpr g CloneAll body | None -> - let existingTypes = defaultArg (Map.tryFind origLambdaId env.dontInline) [] - let env = { env with dontInline = Map.add origLambdaId (specLambdaTy :: existingTypes) env.dontInline; debugInlineCallSite = Some m } + let existingTypes = defaultArg (Map.tryFind origLambdaId argEnv.dontInline) [] + let env = { argEnv with dontInline = Map.add origLambdaId (specLambdaTy :: existingTypes) argEnv.dontInline; debugInlineCallSite = Some m } let specLambdaR, _ = OptimizeExpr cenv env specLambda cenv.specializedInlineVals.Add(origLambdaId, (specLambdaTy, specLambdaR)) specLambdaR else - let specLambdaR, _ = OptimizeExpr cenv { env with dontInline = Map.add origLambdaId [] env.dontInline; debugInlineCallSite = Some m } specLambda + let specLambdaR, _ = + OptimizeExpr + cenv + { argEnv with + dontInline = Map.add origLambdaId [] argEnv.dontInline + debugInlineCallSite = Some m } + specLambda specLambdaR // Abstract the specialized lambda over its free typars so IlxGen emits a static @@ -3938,7 +4069,19 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg || capturedVals |> List.exists (fun v -> v.IsMutable) if not (List.isEmpty capturedVals) && cannotLiftCapturedVals then - Some(MakeApplicationAndBetaReduce g (specLambdaR, specLambdaTy, [], argsR, m), info) else + let reduced = MakeApplicationAndBetaReduce g (specLambdaR, specLambdaTy, [], argsR, m) + let reduced = + match reduced with + | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) + | _ -> reduced + let reduced = InlineRuntimeAsyncLambdaArgument cenv env reduced + let reduced = + if ExprContainsRuntimeAsyncSuspension reduced then + fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) + else + reduced + Some(reduced, info) + else let debugValName = $"<{vref.LogicalName}>__debug" @@ -3961,39 +4104,55 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg check specLambdaTy if freeTyparsNeedWitnesses && specArgsHaveByref then - None else - - // Static method path (no witnesses needed): abstract over free typars so IlxGen emits - // a method with flattened arguments rather than a closure that wraps args in Tuple<>. - // Closure path (witnesses needed, no byref): keep the body as-is; witnesses from the - // enclosing scope flow through the closure, so no typar abstraction is needed. - let debugValTy, debugValBody, valReprInfo, typeInstForCall, capturedArgs = - if not freeTyparsNeedWitnesses then - let liftedBody, liftedTy = mkMultiLambdasCore g m capturedArgGroups (specLambdaR, specLambdaTy) - let ty = mkForallTyIfNeeded freeTypars liftedTy - let body = mkTypeLambda m freeTypars (liftedBody, liftedTy) - let argInfos, retInfo = - match vref.ValReprInfo with - | Some(ValReprInfo(_, argInfos, retInfo)) -> argInfos, retInfo - | None -> - let (ValReprInfo(_, a, r)) = - InferValReprInfoOfExpr g AllowTypeDirectedDetupling.No specLambdaTy [] [] specLambdaR - a, r - let capturedArgInfos = - capturedArgGroups - |> List.map (List.map (fun (v: Val) -> { ValReprInfo.unnamedTopArg1 with Name = Some v.Id })) - let reprInfo = ValReprInfo(ValReprInfo.InferTyparInfo freeTypars, capturedArgInfos @ argInfos, retInfo) - ty, body, Some reprInfo, [List.map mkTyparTy freeTypars], List.map (mkRefTupledVars g m) capturedArgGroups + if mustInlineRuntimeAsync then + errorR(Error(FSComp.SR.optFailedToInlineValue(RichText.mkText vref.LogicalName), m)) + None + else + if mustInlineRuntimeAsync then + let reduced = MakeApplicationAndBetaReduce g (specLambdaR, specLambdaTy, [], argsR, m) + let reduced = + match reduced with + | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) + | _ -> reduced + let reduced = InlineRuntimeAsyncLambdaArgument cenv env reduced + let reduced = + if ExprContainsRuntimeAsyncSuspension reduced then + fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) + else + reduced + Some(reduced, info) else - specLambdaTy, specLambdaR, None, [], [] - - let debugVal = - Construct.NewVal(debugValName, m, None, debugValTy, Immutable, true, valReprInfo, taccessPublic, ValNotInRecScope, None, - NormalVal, [], ValInline.InlinedDefinition, XmlDoc.Empty, true, false, false, false, false, false, None, - ParentNone) - - let callExpr = mkApps g ((exprForVal m debugVal, debugValTy), typeInstForCall, capturedArgs @ argsR, m) - Some(mkCompGenLet m debugVal debugValBody callExpr, info) + // Static method path (no witnesses needed): abstract over free typars so IlxGen emits + // a method with flattened arguments rather than a closure that wraps args in Tuple<>. + // Closure path (witnesses needed, no byref): keep the body as-is; witnesses from the + // enclosing scope flow through the closure, so no typar abstraction is needed. + let debugValTy, debugValBody, valReprInfo, typeInstForCall, capturedArgs = + if not freeTyparsNeedWitnesses then + let liftedBody, liftedTy = mkMultiLambdasCore g m capturedArgGroups (specLambdaR, specLambdaTy) + let ty = mkForallTyIfNeeded freeTypars liftedTy + let body = mkTypeLambda m freeTypars (liftedBody, liftedTy) + let argInfos, retInfo = + match vref.ValReprInfo with + | Some(ValReprInfo(_, argInfos, retInfo)) -> argInfos, retInfo + | None -> + let (ValReprInfo(_, a, r)) = + InferValReprInfoOfExpr g AllowTypeDirectedDetupling.No specLambdaTy [] [] specLambdaR + a, r + let capturedArgInfos = + capturedArgGroups + |> List.map (List.map (fun (v: Val) -> { ValReprInfo.unnamedTopArg1 with Name = Some v.Id })) + let reprInfo = ValReprInfo(ValReprInfo.InferTyparInfo freeTypars, capturedArgInfos @ argInfos, retInfo) + ty, body, Some reprInfo, [List.map mkTyparTy freeTypars], List.map (mkRefTupledVars g m) capturedArgGroups + else + specLambdaTy, specLambdaR, None, [], [] + + let debugVal = + Construct.NewVal(debugValName, m, None, debugValTy, Immutable, true, valReprInfo, taccessPublic, ValNotInRecScope, None, + NormalVal, [], ValInline.InlinedDefinition, XmlDoc.Empty, true, false, false, false, false, false, None, + ParentNone) + + let callExpr = mkApps g ((exprForVal m debugVal, debugValTy), typeInstForCall, capturedArgs @ argsR, m) + Some(mkCompGenLet m debugVal debugValBody callExpr, info) | _ -> None | _ -> diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 3d286cf6aad..4a14f2359d4 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -76,12 +76,15 @@ let f () : Task = // ============================ execution (runtime behavior) ============================ -[] -let ``runtime async edge cases execute through the CE builder`` () = +[] +[] +[] +let ``runtime async edge cases execute through the CE builder`` (optimize: bool) = FsFromPath builderPath |> withAdditionalSourceFile (SourceFromPath (Path.Combine(runtimeAsyncDir, "RuntimeAsyncEdgeCases.fs"))) |> withLangVersionPreview |> withFSharpCoreShippedNet + |> withOptimization optimize |> compileExeAndRun |> shouldSucceed diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 1ce3bbd4c28..a167fa9ecf1 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -78,6 +78,23 @@ type Calculator() = """ +let private runtimeAsyncNestedInlineSource = """ +module RuntimeAsyncNestedInlineTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +type InlineAwait = + static member inline Await1(task: Task) = AsyncHelpers.Await task + static member inline Await2(task: Task) = InlineAwait.Await1 task + static member inline AddOne(value: int) = value + 1 + static member inline Await3(task: Task) = InlineAwait.AddOne (InlineAwait.Await2 task) + +let f (task: Task) : Task = + StateMachineHelpers.__runtimeAsyncReturn (InlineAwait.Await3 task) +""" + #if NETCOREAPP [] let ``runtime async requires preview language version`` () = @@ -160,13 +177,25 @@ let ``runtime async combines awaited chunks without delegates`` () = |> shouldSucceed [] -let ``runtime task builder fixture executes through runtime async`` () = +let ``runtime async specializes nested inline suspensions without optimization`` () = + FSharp runtimeAsyncNestedInlineSource + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> withNoOptimize + |> compile + |> verifyILContains [ "AsyncHelpers::Await(class [runtime]System.Threading.Tasks.Task`1)" ] + +[] +[] +[] +let ``runtime task builder fixture executes through runtime async`` (optimize: bool) = FsFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTaskBuilder.fs")) |> withAdditionalSourceFile ( SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasks.fs")) ) |> withLangVersionPreview |> withFSharpCoreShippedNet + |> withOptimization optimize |> compileExeAndRun |> shouldSucceed From 34060f9bfa5b9b0fcc7733037a538f53117e1a48 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sun, 23 Aug 2026 19:57:07 +0200 Subject: [PATCH 22/59] fix regressed --- src/Compiler/Checking/Expressions/CheckExpressions.fs | 3 --- src/Compiler/CodeGen/IlxGen.fs | 2 +- .../Language/RuntimeAsyncEdgeCaseTests.fs | 7 ++++--- 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index bee429befd8..89e8a1f795f 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -12325,9 +12325,6 @@ and TcLetBinding (cenv: cenv) isUse env containerInfo declKind tpenv (synBinds, tmp, checkedPat - if isFixed then - patternInputTmp.SetIsFixed() - // Add the bind "let patternInputTmp = rhsExpr" to the bodyExpr we get from mkPatBind let mkRhsBind (bodyExpr, bodyExprTy) = let letExpr = mkLet debugPoint m patternInputTmp rhsExpr bodyExpr diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index e0803badb5d..79ca7a27bab 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3100,7 +3100,7 @@ let CodeGenThen (cenv: cenv) mgbuf (entryPointInfo, methodName, eenv, alreadyUse else mkILLocal ty None - if isFixed && IsILTypeByref ty then { loc with IsPinned = true } else loc) + if isFixed then { loc with IsPinned = true } else loc) (ilLocals, maxStack, lab2pc, code, exnSpecs, localDebugSpecs, hasDebugPoints) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 4a14f2359d4..9ec657a5271 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -374,12 +374,13 @@ let ``exception handling block suspensions compile and run correctly`` (_label: [] -[) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] [) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); x)")>] [ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p 0)")>] + "let f (arr: int[]) : Task = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p 0)", + Skip = "TODO: Enable this test once the pinned local across suspension diagnostic is fixed")>] let ``non-preservable values after suspension are rejected`` (_label: string) (body: string) = compileDirect body |> shouldFail From a88067dfc1f9c323eeaaed2db3b9a55063d93d36 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Mon, 24 Aug 2026 12:08:34 +0200 Subject: [PATCH 23/59] fix diag codes --- docs/runtime-async.md | 2 +- src/Compiler/FSComp.txt | 4 ++-- .../Language/RuntimeAsyncEdgeCaseTests.fs | 2 +- .../Language/RuntimeAsyncTests.fs | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 8aec4f929ba..440e4c1056f 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -60,7 +60,7 @@ Known runtime restrictions (currently **not** diagnosed by the F# compiler): `IAsyncDisposable` work under runtime async (`testUsingAsyncDisposableSync` executes). Byref, byref-like, and pinned locals that are used after a suspension are -rejected with diagnostic FS3357. +rejected with diagnostic FS3917. Calls to `AsyncHelpers` suspension methods emitted outside a runtime-async method are rejected during code generation. Explicitly `inline` method bodies diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt index 0f29633e274..57dfad16af6 100644 --- a/src/Compiler/FSComp.txt +++ b/src/Compiler/FSComp.txt @@ -1553,8 +1553,6 @@ csTypeHasNullAsExtraValue,"The type '%s' supports 'null' but a non-null type is 3351,chkFeatureNotRuntimeSupported,"Feature '%s' is not supported by target runtime." 3352,typrelInterfaceMemberNoMostSpecificImplementation,"Interface member '%s' does not have a most specific implementation." 3353,fsiInvalidDirective,"Invalid directive '#%s %s'" -3354,ilRuntimeAsyncSuspensionOutsideRuntimeAsync,"Runtime async suspension method '%s' may only be called from a runtime async method." -3357,ilRuntimeAsyncLocalUsedAfterSuspension,"A byref, byref-like, or pinned local '%s' cannot be used after a runtime async suspension." useSdkRefs,"Use reference assemblies for .NET framework references when available (Enabled by default)." optsCheckNulls,"Enable nullness declarations and checks (%s by default)" fSharpBannerVersion,"%s for F# %s" @@ -1857,3 +1855,5 @@ featureRecordSpreads,"record type and expression spreads" 3913,tcExtendedLayoutCannotBeUsedOnUnions,"The 'ExtendedLayoutAttribute' cannot be applied to discriminated unions" 3914,tcExtendedLayoutStructMustHaveInstanceField,"A struct with the 'ExtendedLayoutAttribute' must have at least one instance field" 3915,tcTupleTypeExtensionTooManyElements,"Tuple type extensions are supported only for tuples of up to 7 elements, but this tuple type has %d elements. Extensions of larger tuples are not supported." +3916,ilRuntimeAsyncSuspensionOutsideRuntimeAsync,"Runtime async suspension method '%s' may only be called from a runtime async method." +3917,ilRuntimeAsyncLocalUsedAfterSuspension,"A byref, byref-like, or pinned local '%s' cannot be used after a runtime async suspension." \ No newline at end of file diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 9ec657a5271..163a43d7a98 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -384,7 +384,7 @@ let ``exception handling block suspensions compile and run correctly`` (_label: let ``non-preservable values after suspension are rejected`` (_label: string) (body: string) = compileDirect body |> shouldFail - |> withErrorCode 3357 + |> withErrorCode 3917 [] let ``non-preservable value not used after suspension is allowed`` () = diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index a167fa9ecf1..ae5adbf1bd4 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -129,7 +129,7 @@ let f () = |> withFSharpCoreShippedNet |> compile |> shouldFail - |> withErrorCodes [ 3354; 3354; 3354 ] + |> withErrorCodes [ 3916; 3916; 3916 ] [] let ``runtime async rejects non Task result carriers`` () = From f0eb291a0031cf1bb4becd586e65a1733adff6cf Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Mon, 24 Aug 2026 21:24:37 +0200 Subject: [PATCH 24/59] refactor and fix non preservables analysis --- .../Checking/Expressions/CheckExpressions.fs | 7 +- src/Compiler/CodeGen/IlxGen.fs | 48 --- src/Compiler/FSharp.Compiler.Service.fsproj | 1 + src/Compiler/Optimize/Optimizer.fs | 31 +- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 299 ++++++++++++++++++ src/Compiler/TypedTree/TypedTree.fs | 11 +- src/Compiler/TypedTree/TypedTree.fsi | 9 + .../Language/RuntimeAsyncEdgeCaseTests.fs | 46 ++- 8 files changed, 376 insertions(+), 76 deletions(-) create mode 100644 src/Compiler/Optimize/RuntimeAsyncAnalysis.fs diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 89e8a1f795f..98549173641 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -12272,7 +12272,12 @@ and TcLetBinding (cenv: cenv) isUse env containerInfo declKind tpenv (synBinds, let valSchemes = NameMap.map (UseCombinedValReprInfo g declKind rhsExpr) prelimValSchemes2 let values = MakeAndPublishVals cenv env (altActualParent, false, declKind, ValNotInRecScope, valSchemes, attrs, xmlDoc, literalValue) let checkedPat = tcPatPhase2 (TcPatPhase2Input (values, true)) - let prelimRecValues = NameMap.map fst values + let prelimRecValues = + let prelimRecValues = NameMap.map fst values + if isFixed then + NameMap.map (fun (v: Val) -> v.SetIsPinning(); v) prelimRecValues + else + prelimRecValues // Now bind the r.h.s. to the l.h.s. let rhsExpr = mkTypeLambda m generalizedTypars (rhsExpr, tauTy) diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index 2ac2a59b313..5159b3c9ade 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -1264,9 +1264,6 @@ and IlxGenEnv = /// We are generating a runtime-async method/closure body, which forbids tail prefixes. inRuntimeAsyncMethod: bool - /// Method parameters whose storage cannot be preserved across a runtime-async suspension. - runtimeAsyncMethodVars: ValRef list - /// Inline method bodies are templates whose suspension calls are checked at their eventual use site. inInlineMethod: bool @@ -2662,9 +2659,6 @@ let FeeFee (cenv: cenv) = let FeeFeeInstr (cenv: cenv) doc = I_seqpoint(ILDebugPoint.Create(document = doc, line = FeeFee cenv, column = 0, endLine = FeeFee cenv, endColumn = 0)) -let IsRuntimeAsyncNonPreservableVal (g: TcGlobals) (v: Val) = - v.IsFixed || isByrefTy g v.Type || isByrefLikeTy g v.Range v.Type - /// Buffers for IL code generation type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs: int) = @@ -2672,9 +2666,6 @@ type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs let locals = ResizeArray<(string * (Mark * Mark)) list * ILType * bool * bool>(10) let codebuf = ResizeArray(200) let exnSpecs = ResizeArray(10) - let runtimeAsyncTrackedLocals = HashSet() - let runtimeAsyncSuspendedLocals = HashSet() - let runtimeAsyncReportedLocals = HashSet() // Keep track of the current stack so we can spill stuff when we hit a "try" when some stuff // is on the stack. @@ -2939,25 +2930,6 @@ type CodeGenBuffer(m: range, mgbuf: AssemblyBuilder, methodName, alreadyUsedArgs member _.HasPinnedLocals() = locals |> Seq.exists (fun (_, _, isFixed, _) -> isFixed) - member _.TrackRuntimeAsyncLocal(vref: ValRef) = - runtimeAsyncTrackedLocals.Add(vref.Deref.Stamp) |> ignore - - member _.MarkRuntimeAsyncSuspension(locals: ValRef list) = - for vref in locals do - runtimeAsyncSuspendedLocals.Add(vref.Deref.Stamp) |> ignore - - for stamp in runtimeAsyncTrackedLocals do - runtimeAsyncSuspendedLocals.Add stamp |> ignore - - member _.CheckRuntimeAsyncLocalUse(vref: ValRef) = - let stamp = vref.Deref.Stamp - - if - runtimeAsyncSuspendedLocals.Contains stamp - && runtimeAsyncReportedLocals.Add stamp - then - errorR (Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension (RichText.mkText vref.Deref.LogicalName), vref.Deref.Range)) - member _.HasStackAllocatedLocals() = hasStackAllocatedLocals member _.Close() = @@ -5869,11 +5841,6 @@ and GenILCall then errorR (Error(FSComp.SR.ilRuntimeAsyncSuspensionOutsideRuntimeAsync (RichText.mkText ilMethRef.Name), m)) - if IsRuntimeAsyncSuspensionMethod cenv.g ilMethRef then - eenv.runtimeAsyncMethodVars @ eenv.letBoundVars - |> List.filter (fun vref -> IsRuntimeAsyncNonPreservableVal cenv.g vref.Deref) - |> cgbuf.MarkRuntimeAsyncSuspension - let tail = CanTailcall( hasStructObjArg, @@ -6017,7 +5984,6 @@ and GenGetAddrOfRefCellField cenv cgbuf eenv (e, ty, m) sequel = GenSequel cenv eenv.cloc cgbuf sequel and GenGetValAddr cenv cgbuf eenv (v: ValRef, m) sequel = - cgbuf.CheckRuntimeAsyncLocalUse v let vspec = v.Deref let ilTy = GenTypeOfVal cenv eenv vspec let storage = StorageForValRef m v eenv @@ -10049,11 +10015,6 @@ and GenMethodForBinding { eenvForMeth with inRuntimeAsyncMethod = isRuntimeAsync - runtimeAsyncMethodVars = - if isRuntimeAsync then - methLambdaVars |> List.map mkLocalValRef - else - [] inInlineMethod = v.InlineInfo = ValInline.Always } @@ -10507,7 +10468,6 @@ and GenBindings cenv cgbuf eenv binds stateVarFlagsOpt = //------------------------------------------------------------------------- and GenSetVal cenv cgbuf eenv (vref, e, m) sequel = - cgbuf.CheckRuntimeAsyncLocalUse vref let storage = StorageForValRef m vref eenv GetStoreValCtxt cgbuf eenv vref.Deref GenExpr cenv cgbuf eenv e Continue @@ -10515,7 +10475,6 @@ and GenSetVal cenv cgbuf eenv (vref, e, m) sequel = GenUnitThenSequel cenv eenv m eenv.cloc cgbuf sequel and GenGetValRefAndSequel cenv cgbuf eenv m (v: ValRef) storeSequel = - cgbuf.CheckRuntimeAsyncLocalUse v let ty = v.Type GenGetStorageAndSequel cenv cgbuf eenv m (ty, GenType cenv m eenv.tyenv ty) (StorageForValRef m v eenv) storeSequel @@ -10674,15 +10633,12 @@ and GenGetFreeVarForClosure cenv cgbuf eenv m (fv: Val) = CG.EmitInstr cgbuf (pop 1) (Push [ ilUnderlyingTy ]) (mkNormalLdobj ilUnderlyingTy) and GenGetLocalVal cenv cgbuf eenv m (vspec: Val) storeSequel = - cgbuf.CheckRuntimeAsyncLocalUse(mkLocalValRef vspec) GenGetStorageAndSequel cenv cgbuf eenv m (vspec.Type, GenTypeOfVal cenv eenv vspec) (StorageForVal m vspec eenv) storeSequel and GenGetLocalVRef cenv cgbuf eenv m (vref: ValRef) storeSequel = - cgbuf.CheckRuntimeAsyncLocalUse vref GenGetStorageAndSequel cenv cgbuf eenv m (vref.Type, GenTypeOfVal cenv eenv vref.Deref) (StorageForValRef m vref eenv) storeSequel and GenStoreVal cgbuf eenv m (vspec: Val) = - cgbuf.CheckRuntimeAsyncLocalUse(mkLocalValRef vspec) GenSetStorage vspec.Range cgbuf (StorageForVal m vspec eenv) and CanRealloc isFixed eenv ty i (_, ty2, isFixed2, canBeReallocd) = @@ -10714,9 +10670,6 @@ and AllocLocal cenv cgbuf eenv compgen (v, ty, isFixed) (scopeMarks: Mark * Mark and AllocLocalVal cenv cgbuf v eenv repr scopeMarks = let g = cenv.g - if eenv.inRuntimeAsyncMethod && IsRuntimeAsyncNonPreservableVal g v then - cgbuf.TrackRuntimeAsyncLocal(mkLocalValRef v) - let repr, eenv = let ty = v.Type @@ -13212,7 +13165,6 @@ let GetEmptyIlxGenEnv (g: TcGlobals) ccu = sigToImplRemapInfo = [] (* "module remap info" *) withinSEH = false inRuntimeAsyncMethod = false - runtimeAsyncMethodVars = [] inInlineMethod = false insideFinallyOrFaultHandler = false isInLoop = false diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index b274796ff49..534be0b759c 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -449,6 +449,7 @@ + diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index eed011f7bc4..bd6721c020e 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -15,6 +15,7 @@ open FSharp.Compiler.CompilerGlobalState open FSharp.Compiler.DelegateForwarding open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.Features +open FSharp.Compiler.RuntimeAsyncAnalysis open FSharp.Compiler.Text.Range open FSharp.Compiler.Syntax.PrettyNaming open FSharp.Compiler.Syntax @@ -2519,30 +2520,6 @@ let shouldForceInlineInDebug cenv env (vref: ValRef) : bool = HasFrameLocalBody cenv env vref -let private IsRuntimeAsyncSuspensionExpr expr = - match stripExpr expr with - | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) -> - ilMethodRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" - && ilMethodRef.Name - |> function - | "Await" - | "AwaitAwaiter" - | "UnsafeAwaitAwaiter" -> true - | _ -> false - | _ -> false - -let private ExprContainsRuntimeAsyncSuspension expr = - let folder = - { ExprFolder0 with - exprIntercept = - fun _ noInterceptF acc expr -> - if acc || IsRuntimeAsyncSuspensionExpr expr then - true - else - noInterceptF acc expr } - - FoldExpr folder false expr - let rec private HasRuntimeAsyncFragmentBody cenv env visiting (vref: ValRef) = if List.exists ((=) vref.Stamp) visiting then false @@ -2811,6 +2788,12 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App(Expr.Val(vref, flags, _), fty, [ _ ], [ body ], _) when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } body + let reportedStamps = HashSet() + + for v in GetRuntimeAsyncNonPreservableUses g bodyR do + if reportedStamps.Add v.Stamp then + errorR(Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension(RichText.mkText v.DisplayName), v.Range)) + let bodyR = RewriteRuntimeAsyncExceptionHandlers cenv bodyR Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), { bodyInfo with diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs new file mode 100644 index 00000000000..ff4ac770238 --- /dev/null +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -0,0 +1,299 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.RuntimeAsyncAnalysis + +open Internal.Utilities.Collections +open Internal.Utilities.Library +open Internal.Utilities.Library.Extras + +open FSharp.Compiler +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.Text +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TypeRelations + +let IsRuntimeAsyncSuspensionExpr expr = + match stripExpr expr with + | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) -> + ilMethodRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" + && ilMethodRef.Name + |> function + | "Await" + | "AwaitAwaiter" + | "UnsafeAwaitAwaiter" -> true + | _ -> false + | _ -> false + +let ExprContainsRuntimeAsyncSuspension expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc || IsRuntimeAsyncSuspensionExpr expr then + true + else + noInterceptF acc expr + } + + FoldExpr folder false expr + +type private RuntimeAsyncFlowSummary = + { + MaySuspend: bool + UsedAfterSuspend: FreeLocals + FreeLocals: FreeLocals + } + +let private emptyRuntimeAsyncFlowSummary = + { + MaySuspend = false + UsedAfterSuspend = emptyFreeLocals + FreeLocals = emptyFreeLocals + } + +let private mergeRuntimeAsyncFlowSummaries left right = + { + MaySuspend = left.MaySuspend || right.MaySuspend + UsedAfterSuspend = Zset.union left.UsedAfterSuspend right.UsedAfterSuspend + FreeLocals = Zset.union left.FreeLocals right.FreeLocals + } + +let private sequenceRuntimeAsyncFlowSummaries left right = + { + MaySuspend = left.MaySuspend || right.MaySuspend + UsedAfterSuspend = + if left.MaySuspend then + Zset.union left.UsedAfterSuspend (Zset.union right.UsedAfterSuspend right.FreeLocals) + else + Zset.union left.UsedAfterSuspend right.UsedAfterSuspend + FreeLocals = Zset.union left.FreeLocals right.FreeLocals + } + +let private removeRuntimeAsyncBoundVals vals (summary: RuntimeAsyncFlowSummary) = + let remove vals set = + (set, vals) ||> List.fold (fun set v -> Zset.remove v set) + + { summary with + FreeLocals = remove vals summary.FreeLocals + } + +let private addRuntimeAsyncSuspension summary = { summary with MaySuspend = true } + +let private IsRuntimeAsyncNonPreservableVal (g: TcGlobals) (v: Val) = + v.IsPinning || isByrefTy g v.Type || isByrefLikeTy g v.Range v.Type + +let private TryGetRuntimeAsyncNonPreservableAlias (g: TcGlobals) expr = + match stripExpr expr with + | Expr.Val(vref, _, _) when IsRuntimeAsyncNonPreservableVal g vref.Deref -> Some vref.Deref + | _ -> None + +let private analyzeRuntimeAsyncExpr (g: TcGlobals) expr = + let rec analyzeExpr expr = + match stripExpr expr with + | Expr.Const _ + | Expr.Val _ + | Expr.WitnessArg _ + | Expr.Lambda _ + | Expr.TyLambda _ -> + match stripExpr expr with + | Expr.Val(vref, _, _) -> + { emptyRuntimeAsyncFlowSummary with + FreeLocals = Zset.add vref.Deref (Zset.empty valOrder) + } + | _ -> emptyRuntimeAsyncFlowSummary + + | Expr.Sequential(expr1, expr2, _, _) -> sequenceRuntimeAsyncFlowSummaries (analyzeExpr expr1) (analyzeExpr expr2) + + | Expr.Let(TBind(v, rhs, _), body, _, _) -> + let rhsSummary = analyzeExpr rhs + let bodySummary = removeRuntimeAsyncBoundVals [ v ] (analyzeExpr body) + + let bodySummary = + match TryGetRuntimeAsyncNonPreservableAlias g rhs with + | Some source when Zset.contains v bodySummary.UsedAfterSuspend -> + { bodySummary with + UsedAfterSuspend = Zset.add source bodySummary.UsedAfterSuspend + } + | _ -> bodySummary + + sequenceRuntimeAsyncFlowSummaries rhsSummary bodySummary + + | Expr.LetRec(bindings, body, _, _) -> + let bindingSummary = + (emptyRuntimeAsyncFlowSummary, bindings) + ||> List.fold (fun summary (TBind(_, bindingExpr, _)) -> + sequenceRuntimeAsyncFlowSummaries summary (analyzeExpr bindingExpr)) + + let bodySummary = analyzeExpr body + let boundVals = bindings |> List.map (fun binding -> binding.Var) + let bodySummary = removeRuntimeAsyncBoundVals boundVals bodySummary + sequenceRuntimeAsyncFlowSummaries bindingSummary bodySummary + + | Expr.Match(_, _, decisionTree, targets, _, _) -> analyzeDecisionTree targets decisionTree + + | Expr.Op(TOp.While _, _, [ Expr.Lambda(_, _, _, _, guardExpr, _, _); Expr.Lambda(_, _, _, _, bodyExpr, _, _) ], _) -> + let guardSummary = analyzeExpr guardExpr + let bodySummary = analyzeExpr bodyExpr + let loopSummary = mergeRuntimeAsyncFlowSummaries guardSummary bodySummary + + if loopSummary.MaySuspend then + { loopSummary with + UsedAfterSuspend = Zset.union loopSummary.UsedAfterSuspend loopSummary.FreeLocals + } + else + loopSummary + + | Expr.Op(TOp.IntegerForLoop _, + _, + [ Expr.Lambda(_, _, _, _, startExpr, _, _) + Expr.Lambda(_, _, _, _, finishExpr, _, _) + Expr.Lambda(_, _, _, [ loopVal ], bodyExpr, _, _) ], + _) -> + let loopSummary = + [ analyzeExpr startExpr; analyzeExpr finishExpr; analyzeExpr bodyExpr ] + |> List.reduce sequenceRuntimeAsyncFlowSummaries + |> removeRuntimeAsyncBoundVals [ loopVal ] + + if loopSummary.MaySuspend then + { loopSummary with + UsedAfterSuspend = Zset.union loopSummary.UsedAfterSuspend loopSummary.FreeLocals + } + else + loopSummary + + | Expr.Op(TOp.TryFinally _, _, [ Expr.Lambda(_, _, _, _, bodyExpr, _, _); Expr.Lambda(_, _, _, _, compensationExpr, _, _) ], _) -> + let bodySummary = analyzeExpr bodyExpr + let compensationSummary = analyzeExpr compensationExpr + let summary = mergeRuntimeAsyncFlowSummaries bodySummary compensationSummary + + if bodySummary.MaySuspend then + { summary with + UsedAfterSuspend = Zset.union summary.UsedAfterSuspend compensationSummary.FreeLocals + } + else + summary + + | Expr.Op(TOp.TryWith _, + _, + [ Expr.Lambda(_, _, _, _, bodyExpr, _, _) + Expr.Lambda(_, _, _, [ _ ], filterExpr, _, _) + Expr.Lambda(_, _, _, [ _ ], handlerExpr, _, _) ], + _) -> + let bodySummary = analyzeExpr bodyExpr + let filterSummary = analyzeExpr filterExpr + let handlerSummary = analyzeExpr handlerExpr + + let summary = + mergeRuntimeAsyncFlowSummaries bodySummary (mergeRuntimeAsyncFlowSummaries filterSummary handlerSummary) + + let usedAfterSuspend = + summary.UsedAfterSuspend + |> fun used -> + if bodySummary.MaySuspend then + Zset.union used (Zset.union filterSummary.FreeLocals handlerSummary.FreeLocals) + else + used + |> fun used -> + if filterSummary.MaySuspend then + Zset.union used handlerSummary.FreeLocals + else + used + + { summary with + UsedAfterSuspend = usedAfterSuspend + } + + | Expr.Op(TOp.LValueOp(_, vref), _, args, _) -> + let argsSummary = + (emptyRuntimeAsyncFlowSummary, args) + ||> List.fold (fun summary arg -> sequenceRuntimeAsyncFlowSummaries summary (analyzeExpr arg)) + + { argsSummary with + FreeLocals = Zset.add vref.Deref argsSummary.FreeLocals + } + + | Expr.Op(_op, _, args, _) -> + let argsSummary = + (emptyRuntimeAsyncFlowSummary, args) + ||> List.fold (fun summary arg -> + match stripExpr arg with + | Expr.Lambda _ + | Expr.TyLambda _ -> summary + | _ -> sequenceRuntimeAsyncFlowSummaries summary (analyzeExpr arg)) + + if IsRuntimeAsyncSuspensionExpr expr then + addRuntimeAsyncSuspension argsSummary + else + argsSummary + + | Expr.App(funcExpr, _, _, argGroups, _) -> + let funcSummary = analyzeExpr funcExpr + + (funcSummary, argGroups) + ||> List.fold (fun summary arg -> sequenceRuntimeAsyncFlowSummaries summary (analyzeExpr arg)) + + | Expr.Obj(_, _, _, ctorCall, _, _, _) -> analyzeExpr ctorCall + + | Expr.StaticOptimization(_, expr1, expr2, _) -> mergeRuntimeAsyncFlowSummaries (analyzeExpr expr1) (analyzeExpr expr2) + + | Expr.Quote(_, splices, _, _, _) -> + let analyzeSplices (_, _, exprs, _) = + exprs + |> List.map analyzeExpr + |> List.fold mergeRuntimeAsyncFlowSummaries emptyRuntimeAsyncFlowSummary + + match splices.Value with + | None -> emptyRuntimeAsyncFlowSummary + | Some(data1, data2) -> mergeRuntimeAsyncFlowSummaries (analyzeSplices data1) (analyzeSplices data2) + + | Expr.Link eref -> analyzeExpr eref.Value + + | Expr.DebugPoint(_, innerExpr) -> analyzeExpr innerExpr + + | Expr.TyChoose(_, innerExpr, _) -> analyzeExpr innerExpr + + and analyzeDecisionTree targets decisionTree = + let analyzeTarget targetNum = + let (TTarget(boundVals, targetExpr, _)) = targets[targetNum] + analyzeExpr targetExpr |> removeRuntimeAsyncBoundVals boundVals + + let rec analyzeTree tree = + match tree with + | TDSuccess(results, targetNum) -> + let resultSummary = + (emptyRuntimeAsyncFlowSummary, results) + ||> List.fold (fun summary resultExpr -> sequenceRuntimeAsyncFlowSummaries summary (analyzeExpr resultExpr)) + + sequenceRuntimeAsyncFlowSummaries resultSummary (analyzeTarget targetNum) + + | TDBind(TBind(v, bindingExpr, _), rest) -> + let bindingSummary = analyzeExpr bindingExpr + let restSummary = analyzeTree rest |> removeRuntimeAsyncBoundVals [ v ] + sequenceRuntimeAsyncFlowSummaries bindingSummary restSummary + + | TDSwitch(inputExpr, cases, defaultOpt, _) -> + let inputSummary = analyzeExpr inputExpr + let branches = cases |> List.map (fun (TCase(_, tree)) -> analyzeTree tree) + + let branches = + match defaultOpt with + | Some tree -> analyzeTree tree :: branches + | None -> branches + + let branchSummary = + branches + |> List.fold mergeRuntimeAsyncFlowSummaries emptyRuntimeAsyncFlowSummary + + sequenceRuntimeAsyncFlowSummaries inputSummary branchSummary + + analyzeTree decisionTree + + analyzeExpr expr + +let GetRuntimeAsyncNonPreservableUses (g: TcGlobals) expr = + let summary = analyzeRuntimeAsyncExpr g expr + + summary.UsedAfterSuspend + |> Zset.elements + |> List.filter (IsRuntimeAsyncNonPreservableVal g) diff --git a/src/Compiler/TypedTree/TypedTree.fs b/src/Compiler/TypedTree/TypedTree.fs index 1c053557cf1..b3515831357 100644 --- a/src/Compiler/TypedTree/TypedTree.fs +++ b/src/Compiler/TypedTree/TypedTree.fs @@ -236,6 +236,10 @@ type ValFlags(flags: int64) = member x.WithIsFixed = ValFlags(flags ||| 0b01000000000000000000L) + member x.IsPinning = (flags &&& 0b100000000000000000000000L) <> 0L + + member x.WithIsPinning = ValFlags(flags ||| 0b100000000000000000000000L) + member x.IgnoresByrefScope = (flags &&& 0b10000000000000000000L) <> 0L member x.WithIgnoresByrefScope = ValFlags(flags ||| 0b10000000000000000000L) @@ -259,7 +263,7 @@ type ValFlags(flags: int64) = // Clear the HasBeenReferenced, only used to report "unreferenced variable" warnings and to help collect 'it' values in FSI.EXE // Clear the IsGeneratedEventVal, since there's no use in propagating specialname information for generated add/remove event vals // Clear the IsParameter, only used during type checking of the current compilation to specialize diagnostics - let bits = (flags &&& ~~~0b10010011001100000000000L) + let bits = (flags &&& ~~~(0b10010011001100000000000L ||| 0b100000000000000000000000L)) // Pickle ValInline.InlinedDefinition as ValInline.Always. if bits &&& 0b00000000000000110000L = 0L then bits ||| 0b00000000000000010000L @@ -3140,6 +3144,9 @@ type Val = /// Indicates if the value is pinned/fixed member x.IsFixed = x.val_flags.IsFixed + /// Indicates if the value names a binding whose lifetime keeps a fixed value pinned + member x.IsPinning = x.val_flags.IsPinning + /// Indicates if the value will ignore byref scoping rules member x.IgnoresByrefScope = x.val_flags.IgnoresByrefScope @@ -3429,6 +3436,8 @@ type Val = member x.SetIsFixed() = x.val_flags <- x.val_flags.WithIsFixed + member x.SetIsPinning() = x.val_flags <- x.val_flags.WithIsPinning + member x.SetIgnoresByrefScope() = x.val_flags <- x.val_flags.WithIgnoresByrefScope member x.SetInlineIfLambda() = x.val_flags <- x.val_flags.WithInlineIfLambda diff --git a/src/Compiler/TypedTree/TypedTree.fsi b/src/Compiler/TypedTree/TypedTree.fsi index d97811bdd6c..4c7d4bd31df 100644 --- a/src/Compiler/TypedTree/TypedTree.fsi +++ b/src/Compiler/TypedTree/TypedTree.fsi @@ -138,6 +138,8 @@ type ValFlags = member IsFixed: bool + member IsPinning: bool + member IsGeneratedEventVal: bool member IsIncrClassSpecialMember: bool @@ -173,6 +175,8 @@ type ValFlags = member WithIsFixed: ValFlags + member WithIsPinning: ValFlags + member WithIsMemberOrModuleBinding: ValFlags member WithMakesNoCriticalTailcalls: ValFlags @@ -2074,6 +2078,8 @@ type Val = member SetIsFixed: unit -> unit + member SetIsPinning: unit -> unit + member SetIsMemberOrModuleBinding: unit -> unit member SetLogicalName: nm: string -> unit @@ -2235,6 +2241,9 @@ type Val = /// Indicates if the value is pinned/fixed member IsFixed: bool + /// Indicates if the value names a binding whose lifetime keeps a fixed value pinned + member IsPinning: bool + /// Indicates if this is a constructor member generated from the de-sugaring of implicit constructor for a class type? member IsIncrClassConstructor: bool diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 163a43d7a98..a6830b03820 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -374,18 +374,60 @@ let ``exception handling block suspensions compile and run correctly`` (_label: [] +[) : Task = StateMachineHelpers.__runtimeAsyncReturn (try AsyncHelpers.Await(Task.Delay(1)); 1 finally AsyncHelpers.Await(Task.FromResult(1)) + x)")>] [ = StateMachineHelpers.__runtimeAsyncReturn (let data = [| 10; 20; 30 |] in let span = ReadOnlySpan(data) in AsyncHelpers.Await(Task.Delay(1)); span[0] + span[1] + span[2])")>] [) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); x)")>] [ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p 0)", - Skip = "TODO: Enable this test once the pinned local across suspension diagnostic is fixed")>] + "let f (arr: int[]) : Task = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p 0)")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let q = p in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get q 0)")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let p1 = p in let p2 = p1 in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p2 0)")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let mutable p1 = p in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get p1 0)")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let q = (p, 1) in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get (fst q) 0)")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let q = fun () -> FSharp.NativeInterop.NativePtr.get p 0 in AsyncHelpers.Await(Task.Delay(1)); q())")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let q = System.Func(fun () -> FSharp.NativeInterop.NativePtr.get p 0) in AsyncHelpers.Await(Task.Delay(1)); q.Invoke())", + Skip = "Known gap: pinned provenance is not propagated through captured delegates")>] +[ = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let q = ref p in AsyncHelpers.Await(Task.Delay(1)); FSharp.NativeInterop.NativePtr.get q.Value 0)", + Skip = "Known gap: pinned provenance is not propagated through ref cells")>] +[) : Task = StateMachineHelpers.__runtimeAsyncReturn (let mutable i = 0 in let _ = while i < 2 do (AsyncHelpers.Await(Task.Delay(1)); x <- x + 1; i <- i + 1) in 0)")>] let ``non-preservable values after suspension are rejected`` (_label: string) (body: string) = compileDirect body |> shouldFail |> withErrorCode 3917 +[] +let ``non-preservable value in an unrelated branch is allowed`` () = + compileDirect + "let f (x: int) : Task = StateMachineHelpers.__runtimeAsyncReturn (let span = ReadOnlySpan([| 1; 2; 3 |]) in if x > 0 then AsyncHelpers.Await(Task.Delay(1)); x else span[0] + span[1])" + |> shouldSucceed + +[] +let ``non-preservable value used before suspension is allowed`` () = + compileDirect + "let f () : Task = StateMachineHelpers.__runtimeAsyncReturn (let span = ReadOnlySpan([| 1; 2; 3 |]) in span[0] + AsyncHelpers.Await(Task.FromResult(1)))" + |> shouldSucceed + +[] +let ``non-preservable pinned value used before suspension is allowed`` () = + FSharp(directIntrinsicSource + "let f (arr: int[]) : Task = StateMachineHelpers.__runtimeAsyncReturn (use p = fixed arr in let value = FSharp.NativeInterop.NativePtr.get p 0 in AsyncHelpers.Await(Task.Delay(1)); value)" + ) + |> withFSharpCoreShippedNet + |> withLangVersionPreview + |> withNoWarn 9 + |> compile + |> shouldSucceed + [] let ``non-preservable value not used after suspension is allowed`` () = compileDirect From bbdab2b057b81a165987131a6ad13caef23f404e Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Mon, 24 Aug 2026 22:33:46 +0200 Subject: [PATCH 25/59] refactor --- .../Checking/Expressions/CheckExpressions.fs | 7 +- src/Compiler/CodeGen/IlxGen.fs | 26 +-- src/Compiler/FSharp.Compiler.Service.fsproj | 2 + src/Compiler/Optimize/Optimizer.fs | 154 +----------------- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 27 +-- .../Optimize/RuntimeAsyncExceptionRewrite.fs | 131 +++++++++++++++ src/Compiler/TypedTree/RuntimeAsync.fs | 51 ++++++ 7 files changed, 197 insertions(+), 201 deletions(-) create mode 100644 src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs create mode 100644 src/Compiler/TypedTree/RuntimeAsync.fs diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index e88ff04ca14..f35cabe5253 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -29,6 +29,7 @@ open FSharp.Compiler.MethodCalls open FSharp.Compiler.MethodOverrides open FSharp.Compiler.NameResolution open FSharp.Compiler.PatternMatchCompilation +open FSharp.Compiler.RuntimeAsync open FSharp.Compiler.Syntax open FSharp.Compiler.SyntaxTrivia open FSharp.Compiler.Syntax.PrettyNaming @@ -8708,7 +8709,7 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl match expr.Expr with | Expr.Val(vref, _, _) | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [], _) - when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> true + when IsRuntimeAsyncReturnVref g vref -> true | _ -> false match isRuntimeAsync, UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with @@ -9027,10 +9028,10 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let intrinsic = match leftExpr with | ApplicableExpr(expr=Expr.Val (vref, flags, m)) - when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> + when IsRuntimeAsyncReturnVref g vref -> Some(vref, flags, m) | ApplicableExpr(expr=Expr.App (Expr.Val (vref, flags, m), _, [ _ ], [], _)) - when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> + when IsRuntimeAsyncReturnVref g vref -> Some(vref, flags, m) | _ -> None diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index f182965ff33..e4f9ea0cb22 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -31,6 +31,7 @@ open FSharp.Compiler.Features open FSharp.Compiler.Infos open FSharp.Compiler.Import open FSharp.Compiler.LowerStateMachines +open FSharp.Compiler.RuntimeAsync open FSharp.Compiler.Syntax open FSharp.Compiler.Syntax.PrettyNaming open FSharp.Compiler.SyntaxTreeOps @@ -3168,31 +3169,6 @@ let ComputeDebugPointForBinding g bind = | _, (Expr.Lambda _ | Expr.TyLambda _) -> false, None | DebugPointAtBinding.Yes m, _ -> false, Some m -let IsRuntimeAsyncReturnVref (g: TcGlobals) (vref: ValRef) = - valRefEq g vref g.cgh__runtimeAsyncReturn_vref - -let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = - - match expr with - | Expr.DebugPoint(_, innerExpr) -> - match TryUnwrapRuntimeAsyncReturnExpr g innerExpr with - | true, body -> true, body - | false, _ -> false, expr - | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body - | _ -> false, expr - -let private IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = - let (TILObjectReprData(coreLibScope, _, _)) = g.system_Object_tcref.ILTyconInfo - - ilMethRef.DeclaringTypeRef.Scope = coreLibScope - && ilMethRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" - && ilMethRef.Name - |> function - | "Await" - | "AwaitAwaiter" - | "UnsafeAwaitAwaiter" -> true - | _ -> false - //------------------------------------------------------------------------- // Generate expressions //------------------------------------------------------------------------- diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index 534be0b759c..c304bf8d262 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -377,6 +377,7 @@ + @@ -450,6 +451,7 @@ + diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index bd6721c020e..cca62a6035a 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -15,7 +15,9 @@ open FSharp.Compiler.CompilerGlobalState open FSharp.Compiler.DelegateForwarding open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.Features +open FSharp.Compiler.RuntimeAsync open FSharp.Compiler.RuntimeAsyncAnalysis +open FSharp.Compiler.RuntimeAsyncExceptionRewrite open FSharp.Compiler.Text.Range open FSharp.Compiler.Syntax.PrettyNaming open FSharp.Compiler.Syntax @@ -2542,7 +2544,7 @@ and private ExprContainsRuntimeAsyncFragment cenv env visiting expr = | Expr.App(Expr.Val(vref, _, _), _, _, _, _) when valRefEq cenv.g vref cenv.g.cgh__runtimeAsyncReturn_vref -> true - | _ when IsRuntimeAsyncSuspensionExpr expr -> + | _ when IsRuntimeAsyncSuspensionExpr cenv.g expr -> true | Expr.Val(vref, _, _) when vref.ShouldInline || vref.IsLocalRef -> HasRuntimeAsyncFragmentBody cenv env visiting vref @@ -2577,150 +2579,6 @@ let private ShouldForceRuntimeAsyncApplication cenv env vref finfo args = | _ -> false) args) -let private RuntimeAsyncChoiceTy (g: TcGlobals) (ty: TType) = - TType_app(g.choice2_tcr, [ ty; g.exn_ty ], g.knownWithoutNull) - -let private RuntimeAsyncChoiceCase g m ty caseIndex expr = - mkUnionCaseExpr(mkChoiceCaseRef g m 2 caseIndex, [ ty; g.exn_ty ], [ expr ], m) - -let private RuntimeAsyncReraise m resultTy exnExpr = - mkThrow m resultTy exnExpr - -let private RuntimeAsyncFilterCondition m resultTy filter thenExpr elseExpr = - let matchBuilder = MatchBuilder(DebugPointAtBinding.NoneAtInvisible, m) - let matchCase = TCase(DecisionTreeTest.Const(Const.Int32 1), matchBuilder.AddResultTarget thenExpr) - let defaultCase = matchBuilder.AddResultTarget elseExpr - let decisionTree = TDSwitch(filter, [ matchCase ], Some defaultCase, m) - matchBuilder.Close(decisionTree, m, resultTy) - -let private IsRuntimeAsyncExceptionHandler expr = - match stripExpr expr with - | TryFinallyExpr(_, _, _, _, compensation, _) -> - ExprContainsRuntimeAsyncSuspension compensation - | TryWithExpr(_, _, _, _, _, filter, _, handler, _) -> - ExprContainsRuntimeAsyncSuspension filter - || ExprContainsRuntimeAsyncSuspension handler - | _ -> false - -let private ExprContainsRuntimeAsyncExceptionHandler expr = - let folder = - { ExprFolder0 with - exprIntercept = - fun _ noInterceptF acc expr -> - if acc || IsRuntimeAsyncExceptionHandler expr then - true - else - noInterceptF acc expr } - - FoldExpr folder false expr - -let private RewriteRuntimeAsyncExceptionHandlers cenv expr = - let g = cenv.g - - let rewriteCapturedException m resultTy body buildResult = - let choiceTy = RuntimeAsyncChoiceTy g resultTy - let resultVal, _ = mkCompGenLocal m "__runtimeAsyncResult" choiceTy - let caughtVal, _ = mkCompGenLocal m "__runtimeAsyncCaughtException" g.exn_ty - let captured = exprForVal m resultVal - let bodyValue = - mkUnionCaseFieldGetUnprovenViaExprAddr( - captured, - mkChoiceCaseRef g m 2 0, - [ resultTy; g.exn_ty ], - 0, - m - ) - let exceptionValue = - mkUnionCaseFieldGetUnprovenViaExprAddr( - captured, - mkChoiceCaseRef g m 2 1, - [ resultTy; g.exn_ty ], - 0, - m - ) - let bodySucceeded = - mkUnionCaseTest g ( - captured, - mkChoiceCaseRef g m 2 0, - [ resultTy; g.exn_ty ], - m - ) - let result = buildResult bodySucceeded bodyValue exceptionValue - - mkCompGenLet - m - resultVal - (mkTryWith - g - (RuntimeAsyncChoiceCase g m resultTy 0 body, - caughtVal, - mkTrue g m, - caughtVal, - RuntimeAsyncChoiceCase g m resultTy 1 (exprForVal m caughtVal), - m, - choiceTy, - DebugPointAtTry.No, - DebugPointAtWith.No)) - result - - let postTransform expr = - match expr with - | TryFinallyExpr(_, _, resultTy, body, compensation, m) when - IsRuntimeAsyncExceptionHandler expr -> - Some( - rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionValue -> - let result = - mkCond - DebugPointAtBinding.NoneAtInvisible - m - resultTy - bodySucceeded - bodyValue - (RuntimeAsyncReraise m resultTy exceptionValue) - - mkCompGenSequential m compensation result) - ) - | TryWithExpr(_, _, resultTy, body, filterVal, filter, handlerVal, handler, m) when - IsRuntimeAsyncExceptionHandler expr -> - Some( - rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionExpr -> - let filter = - mkCompGenLet - m - filterVal - exceptionExpr - (mkCompGenLet - m - handlerVal - exceptionExpr - (RuntimeAsyncFilterCondition - m - resultTy - filter - handler - (RuntimeAsyncReraise m resultTy exceptionExpr))) - - mkCond - DebugPointAtBinding.NoneAtInvisible - m - resultTy - bodySucceeded - bodyValue - filter) - ) - | _ -> None - - if ExprContainsRuntimeAsyncExceptionHandler expr then - RewriteExpr - { PreIntercept = None - PostTransform = postTransform - PreInterceptBinding = None - RewriteQuotations = false - StackGuard = StackGuard("RuntimeAsyncExceptionRewrite") } - expr - else - expr - /// Optimize/analyze an expression let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = cenv.stackGuard.Guard <| fun () -> @@ -2794,7 +2652,7 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = if reportedStamps.Add v.Stamp then errorR(Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension(RichText.mkText v.DisplayName), v.Range)) - let bodyR = RewriteRuntimeAsyncExceptionHandlers cenv bodyR + let bodyR = RewriteRuntimeAsyncExceptionHandlers g bodyR Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), { bodyInfo with HasEffect = true @@ -4059,7 +3917,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | _ -> reduced let reduced = InlineRuntimeAsyncLambdaArgument cenv env reduced let reduced = - if ExprContainsRuntimeAsyncSuspension reduced then + if ExprContainsRuntimeAsyncSuspension g reduced then fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) else reduced @@ -4099,7 +3957,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | _ -> reduced let reduced = InlineRuntimeAsyncLambdaArgument cenv env reduced let reduced = - if ExprContainsRuntimeAsyncSuspension reduced then + if ExprContainsRuntimeAsyncSuspension g reduced then fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) else reduced diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index ff4ac770238..fded781d0ca 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -13,30 +13,7 @@ open FSharp.Compiler.TypedTree open FSharp.Compiler.TypedTreeOps open FSharp.Compiler.TypeRelations -let IsRuntimeAsyncSuspensionExpr expr = - match stripExpr expr with - | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) -> - ilMethodRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" - && ilMethodRef.Name - |> function - | "Await" - | "AwaitAwaiter" - | "UnsafeAwaitAwaiter" -> true - | _ -> false - | _ -> false - -let ExprContainsRuntimeAsyncSuspension expr = - let folder = - { ExprFolder0 with - exprIntercept = - fun _ noInterceptF acc expr -> - if acc || IsRuntimeAsyncSuspensionExpr expr then - true - else - noInterceptF acc expr - } - - FoldExpr folder false expr +open FSharp.Compiler.RuntimeAsync type private RuntimeAsyncFlowSummary = { @@ -222,7 +199,7 @@ let private analyzeRuntimeAsyncExpr (g: TcGlobals) expr = | Expr.TyLambda _ -> summary | _ -> sequenceRuntimeAsyncFlowSummaries summary (analyzeExpr arg)) - if IsRuntimeAsyncSuspensionExpr expr then + if IsRuntimeAsyncSuspensionExpr g expr then addRuntimeAsyncSuspension argsSummary else argsSummary diff --git a/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs new file mode 100644 index 00000000000..2a467d1ab84 --- /dev/null +++ b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs @@ -0,0 +1,131 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.RuntimeAsyncExceptionRewrite + +open FSharp.Compiler +open FSharp.Compiler.DiagnosticsLogger +open FSharp.Compiler.RuntimeAsync +open FSharp.Compiler.Syntax +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeOps + +let private RuntimeAsyncChoiceTy (g: TcGlobals) (ty: TType) = + TType_app(g.choice2_tcr, [ ty; g.exn_ty ], g.knownWithoutNull) + +let private RuntimeAsyncChoiceCase g m ty caseIndex expr = + mkUnionCaseExpr (mkChoiceCaseRef g m 2 caseIndex, [ ty; g.exn_ty ], [ expr ], m) + +let private RuntimeAsyncReraise m resultTy exnExpr = mkThrow m resultTy exnExpr + +let private RuntimeAsyncFilterCondition m resultTy filter thenExpr elseExpr = + let matchBuilder = MatchBuilder(DebugPointAtBinding.NoneAtInvisible, m) + + let matchCase = + TCase(DecisionTreeTest.Const(Const.Int32 1), matchBuilder.AddResultTarget thenExpr) + + let defaultCase = matchBuilder.AddResultTarget elseExpr + let decisionTree = TDSwitch(filter, [ matchCase ], Some defaultCase, m) + matchBuilder.Close(decisionTree, m, resultTy) + +let private IsRuntimeAsyncExceptionHandler (g: TcGlobals) expr = + match stripExpr expr with + | TryFinallyExpr(_, _, _, _, compensation, _) -> ExprContainsRuntimeAsyncSuspension g compensation + | TryWithExpr(_, _, _, _, _, filter, _, handler, _) -> + ExprContainsRuntimeAsyncSuspension g filter + || ExprContainsRuntimeAsyncSuspension g handler + | _ -> false + +let private ExprContainsRuntimeAsyncExceptionHandler (g: TcGlobals) expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc || IsRuntimeAsyncExceptionHandler g expr then + true + else + noInterceptF acc expr + } + + FoldExpr folder false expr + +let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = + let rewriteCapturedException m resultTy body buildResult = + let choiceTy = RuntimeAsyncChoiceTy g resultTy + let resultVal, _ = mkCompGenLocal m "__runtimeAsyncResult" choiceTy + let caughtVal, _ = mkCompGenLocal m "__runtimeAsyncCaughtException" g.exn_ty + let captured = exprForVal m resultVal + + let bodyValue = + mkUnionCaseFieldGetUnprovenViaExprAddr (captured, mkChoiceCaseRef g m 2 0, [ resultTy; g.exn_ty ], 0, m) + + let exceptionValue = + mkUnionCaseFieldGetUnprovenViaExprAddr (captured, mkChoiceCaseRef g m 2 1, [ resultTy; g.exn_ty ], 0, m) + + let bodySucceeded = + mkUnionCaseTest g (captured, mkChoiceCaseRef g m 2 0, [ resultTy; g.exn_ty ], m) + + let result = buildResult bodySucceeded bodyValue exceptionValue + + mkCompGenLet + m + resultVal + (mkTryWith + g + (RuntimeAsyncChoiceCase g m resultTy 0 body, + caughtVal, + mkTrue g m, + caughtVal, + RuntimeAsyncChoiceCase g m resultTy 1 (exprForVal m caughtVal), + m, + choiceTy, + DebugPointAtTry.No, + DebugPointAtWith.No)) + result + + let postTransform expr = + match expr with + | TryFinallyExpr(_, _, resultTy, body, compensation, m) when IsRuntimeAsyncExceptionHandler g expr -> + Some( + rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionValue -> + let result = + mkCond + DebugPointAtBinding.NoneAtInvisible + m + resultTy + bodySucceeded + bodyValue + (RuntimeAsyncReraise m resultTy exceptionValue) + + mkCompGenSequential m compensation result) + ) + | TryWithExpr(_, _, resultTy, body, filterVal, filter, handlerVal, handler, m) when IsRuntimeAsyncExceptionHandler g expr -> + Some( + rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionExpr -> + let filter = + mkCompGenLet + m + filterVal + exceptionExpr + (mkCompGenLet + m + handlerVal + exceptionExpr + (RuntimeAsyncFilterCondition m resultTy filter handler (RuntimeAsyncReraise m resultTy exceptionExpr))) + + mkCond DebugPointAtBinding.NoneAtInvisible m resultTy bodySucceeded bodyValue filter) + ) + | _ -> None + + if ExprContainsRuntimeAsyncExceptionHandler g expr then + RewriteExpr + { + PreIntercept = None + PostTransform = postTransform + PreInterceptBinding = None + RewriteQuotations = false + StackGuard = StackGuard("RuntimeAsyncExceptionRewrite") + } + expr + else + expr diff --git a/src/Compiler/TypedTree/RuntimeAsync.fs b/src/Compiler/TypedTree/RuntimeAsync.fs new file mode 100644 index 00000000000..5330114493f --- /dev/null +++ b/src/Compiler/TypedTree/RuntimeAsync.fs @@ -0,0 +1,51 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.RuntimeAsync + +open FSharp.Compiler +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeOps + +let IsRuntimeAsyncReturnVref (g: TcGlobals) (vref: ValRef) = + valRefEq g vref g.cgh__runtimeAsyncReturn_vref + +let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = + match expr with + | Expr.DebugPoint(_, innerExpr) -> + match TryUnwrapRuntimeAsyncReturnExpr g innerExpr with + | true, body -> true, body + | false, _ -> false, expr + | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body + | _ -> false, expr + +let IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = + let (TILObjectReprData(coreLibScope, _, _)) = g.system_Object_tcref.ILTyconInfo + + ilMethRef.DeclaringTypeRef.Scope = coreLibScope + && ilMethRef.DeclaringTypeRef.FullName = "System.Runtime.CompilerServices.AsyncHelpers" + && ilMethRef.Name + |> function + | "Await" + | "AwaitAwaiter" + | "UnsafeAwaitAwaiter" -> true + | _ -> false + +let IsRuntimeAsyncSuspensionExpr (g: TcGlobals) expr = + match stripExpr expr with + | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) -> IsRuntimeAsyncSuspensionMethod g ilMethodRef + | _ -> false + +let ExprContainsRuntimeAsyncSuspension (g: TcGlobals) expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc || IsRuntimeAsyncSuspensionExpr g expr then + true + else + noInterceptF acc expr + } + + FoldExpr folder false expr From 54e5f818b86f3333e4bb275dc91384fb8ecb8f18 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 07:21:29 +0200 Subject: [PATCH 26/59] handle the rest of supported types --- .../Checking/Expressions/CheckExpressions.fs | 11 ++++--- src/Compiler/CodeGen/IlxGen.fs | 15 ++++++--- src/Compiler/Optimize/Optimizer.fs | 6 ++-- src/Compiler/TypedTree/RuntimeAsync.fs | 10 +++++- src/Compiler/TypedTree/TcGlobals.fs | 9 +++++ src/Compiler/TypedTree/TcGlobals.fsi | 6 ++++ src/FSharp.Core/resumable.fs | 17 ++++++++++ src/FSharp.Core/resumable.fsi | 9 +++++ .../Language/RuntimeAsyncTests.fs | 33 +++++++++++++++++++ 9 files changed, 103 insertions(+), 13 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index f35cabe5253..f4b73cfcc9b 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -9044,17 +9044,18 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let _, carrierTy = stripFunTy g exprTy - // The intrinsic's signature is 'T -> Task<'T>, so the carrier is always Task<'T>. - let bodyResultTy = + let bodyResultTy, markerTyargs = match stripTyEqns g carrierTy with - | AppTy g (_, [ resultTy ]) -> resultTy - | _ -> NewInferenceType g + | AppTy g (_, [ resultTy ]) -> resultTy, [ resultTy ] + | AppTy g (_, []) -> g.unit_ty, [] + | AppTy g (_, _) -> error (InternalError("Unexpected runtime-async return carrier arity", m)) + | _ -> error (InternalError("Unexpected runtime-async return carrier type", m)) checkLanguageFeatureRuntimeAndRecover cenv.infoReader LanguageFeature.RuntimeAsync m let arg, tpenv = TcExprFlex2 cenv bodyResultTy env false tpenv synArg let marker = - Expr.App(Expr.Val(vref, flags, m), vref.Type, [ bodyResultTy ], [ arg ], mExprAndArg) + Expr.App(Expr.Val(vref, flags, m), vref.Type, markerTyargs, [ arg ], mExprAndArg) Some( TcDelayed diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index e4f9ea0cb22..5b9966e07a3 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3316,7 +3316,7 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = // application of local type functions with type parameters = measure types and body = local value - inline the body GenExpr cenv cgbuf eenv v sequel - | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ _ ], _) when IsRuntimeAsyncReturnVref g vref -> + | Expr.App(Expr.Val(vref, _, _), _, _, [ _ ], _) when IsRuntimeAsyncReturnVref g vref -> GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel | Expr.App(f, fty, tyargs, curriedArgs, m) -> GenApp cenv cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel @@ -7201,6 +7201,7 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr strip cloinfo.ilCloLambdas + let isRuntimeAsyncUnit = IsRuntimeAsyncReturnUnitExpr g body let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body let eenvinner = @@ -7209,7 +7210,8 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr } let ilCloBody = - CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) + let sequel = if isRuntimeAsyncUnit then discardAndReturnVoid else Return + CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, sequel) let ilCloBody = if isRuntimeAsync then @@ -7262,6 +7264,7 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e let ilCloTypeRef = cloinfo.cloSpec.TypeRef + let isRuntimeAsyncUnit = IsRuntimeAsyncReturnUnitExpr g body let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body let eenvinner = @@ -7270,7 +7273,8 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e } let ilCloBody = - CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, Return) + let sequel = if isRuntimeAsyncUnit then discardAndReturnVoid else Return + CodeGenMethodForExpr cenv cgbuf.mgbuf (entryPointInfo, cloinfo.cloName, eenvinner, 1, None, body, sequel) let ilCloBody = if isRuntimeAsync then @@ -9931,6 +9935,8 @@ and GenMethodForBinding | h :: t -> [ h ], t, true | _ -> [], methLambdaVars, false + let isRuntimeAsyncUnit = IsRuntimeAsyncReturnUnitExpr g methLambdaBody + let isRuntimeAsync, methLambdaBody = TryUnwrapRuntimeAsyncReturnExpr g methLambdaBody @@ -10009,7 +10015,8 @@ and GenMethodForBinding // Discard the result on a 'void' return type. For a constructor just return 'void' let sequel = - if isUnitTy g returnTy then discardAndReturnVoid + if isRuntimeAsyncUnit then discardAndReturnVoid + elif isUnitTy g returnTy then discardAndReturnVoid elif isCtor then ReturnVoid else Return diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index cca62a6035a..c5da2a82d6a 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2542,7 +2542,7 @@ and private ExprContainsRuntimeAsyncFragment cenv env visiting expr = else match stripExpr expr with | Expr.App(Expr.Val(vref, _, _), _, _, _, _) - when valRefEq cenv.g vref cenv.g.cgh__runtimeAsyncReturn_vref -> + when IsRuntimeAsyncReturnVref cenv.g vref -> true | _ when IsRuntimeAsyncSuspensionExpr cenv.g expr -> true @@ -2643,8 +2643,8 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App (f, fty, tyargs, argsl, m) -> match expr with - | Expr.App(Expr.Val(vref, flags, _), fty, [ _ ], [ body ], _) - when valRefEq g vref g.cgh__runtimeAsyncReturn_vref -> + | Expr.App(Expr.Val(vref, flags, _), fty, _, [ body ], _) + when IsRuntimeAsyncReturnVref g vref -> let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } body let reportedStamps = HashSet() diff --git a/src/Compiler/TypedTree/RuntimeAsync.fs b/src/Compiler/TypedTree/RuntimeAsync.fs index 5330114493f..ab276779424 100644 --- a/src/Compiler/TypedTree/RuntimeAsync.fs +++ b/src/Compiler/TypedTree/RuntimeAsync.fs @@ -10,6 +10,14 @@ open FSharp.Compiler.TypedTreeOps let IsRuntimeAsyncReturnVref (g: TcGlobals) (vref: ValRef) = valRefEq g vref g.cgh__runtimeAsyncReturn_vref + || valRefEq g vref g.cgh__runtimeAsyncReturnValueTask_vref + || valRefEq g vref g.cgh__runtimeAsyncReturnUnit_vref + || valRefEq g vref g.cgh__runtimeAsyncReturnValueTaskUnit_vref + +let IsRuntimeAsyncReturnUnitExpr (g: TcGlobals) expr = + match stripExpr expr with + | Expr.App(Expr.Val(vref, _, _), _, [], [ _ ], _) when IsRuntimeAsyncReturnVref g vref -> true + | _ -> false let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = match expr with @@ -17,7 +25,7 @@ let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = match TryUnwrapRuntimeAsyncReturnExpr g innerExpr with | true, body -> true, body | false, _ -> false, expr - | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body + | Expr.App(Expr.Val(vref, _, _), _, _, [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body | _ -> false, expr let IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = diff --git a/src/Compiler/TypedTree/TcGlobals.fs b/src/Compiler/TypedTree/TcGlobals.fs index acd6e5ac788..281047f2248 100644 --- a/src/Compiler/TypedTree/TcGlobals.fs +++ b/src/Compiler/TypedTree/TcGlobals.fs @@ -410,6 +410,9 @@ type TcGlobals( let v_tcref_IObserver = findSysTyconRef sys "IObserver`1" let v_fslib_IDelegateEvent_tcr = mk_MFControl_tcref fslibCcu "IDelegateEvent`1" let v_task_tcr = findSysTyconRef ["System"; "Threading"; "Tasks"] "Task`1" + let v_task_nonGeneric_tcr = findSysTyconRef ["System"; "Threading"; "Tasks"] "Task" + let v_valueTask_tcr = findSysTyconRef ["System"; "Threading"; "Tasks"] "ValueTask`1" + let v_valueTask_nonGeneric_tcr = findSysTyconRef ["System"; "Threading"; "Tasks"] "ValueTask" let v_option_tcr_nice = mk_MFCore_tcref fslibCcu "option`1" let v_valueoption_tcr_nice = mk_MFCore_tcref fslibCcu "voption`1" @@ -902,6 +905,9 @@ type TcGlobals( let v_cgh__stateMachine_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__stateMachine" , None , None , [vara; varb], ([[varaTy]], varbTy)) // inaccurate type but it doesn't matter for linking let v_cgh__resumableEntry_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__resumableEntry" , None , None , [vara], ([[v_int_ty --> varaTy]; [v_unit_ty --> varaTy]], varaTy)) let v_cgh__runtimeAsyncReturn_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsyncReturn" , None , None , [vara], ([[varaTy]], TType_app(v_task_tcr, [varaTy], v_knownWithoutNull))) // handled specially by the checker + let v_cgh__runtimeAsyncReturnValueTask_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsyncReturnValueTask" , None , None , [vara], ([[varaTy]], TType_app(v_valueTask_tcr, [varaTy], v_knownWithoutNull))) // handled specially by the checker + let v_cgh__runtimeAsyncReturnUnit_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsyncReturnUnit" , None , None , [], ([[v_unit_ty]], mkNonGenericTy v_task_nonGeneric_tcr)) // handled specially by the checker + let v_cgh__runtimeAsyncReturnValueTaskUnit_info = makeIntrinsicValRef(fslib_MFStateMachineHelpers_nleref, "__runtimeAsyncReturnValueTaskUnit" , None , None , [], ([[v_unit_ty]], mkNonGenericTy v_valueTask_nonGeneric_tcr)) // handled specially by the checker let v_seq_to_array_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "toArray" , None , Some "ToArray", [varb], ([[mkSeqTy varbTy]], mkArrayType 1 varbTy)) let v_seq_to_list_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "toList" , None , Some "ToList" , [varb], ([[mkSeqTy varbTy]], mkListTy varbTy)) let v_seq_map_info = makeIntrinsicValRef(fslib_MFSeqModule_nleref, "map" , None , Some "Map" , [vara;varb], ([[varaTy --> varbTy]; [mkSeqTy varaTy]], mkSeqTy varbTy)) @@ -1844,6 +1850,9 @@ type TcGlobals( member val cgh__stateMachine_vref = ValRefForIntrinsic v_cgh__stateMachine_info member val cgh__runtimeAsyncReturn_vref = ValRefForIntrinsic v_cgh__runtimeAsyncReturn_info + member val cgh__runtimeAsyncReturnValueTask_vref = ValRefForIntrinsic v_cgh__runtimeAsyncReturnValueTask_info + member val cgh__runtimeAsyncReturnUnit_vref = ValRefForIntrinsic v_cgh__runtimeAsyncReturnUnit_info + member val cgh__runtimeAsyncReturnValueTaskUnit_vref = ValRefForIntrinsic v_cgh__runtimeAsyncReturnValueTaskUnit_info member val cgh__useResumableCode_vref = ValRefForIntrinsic v_cgh__useResumableCode_info member val cgh__debugPoint_vref = ValRefForIntrinsic v_cgh__debugPoint_info member val cgh__resumeAt_vref = ValRefForIntrinsic v_cgh__resumeAt_info diff --git a/src/Compiler/TypedTree/TcGlobals.fsi b/src/Compiler/TypedTree/TcGlobals.fsi index f7b1b16917b..b3b5d4557b0 100644 --- a/src/Compiler/TypedTree/TcGlobals.fsi +++ b/src/Compiler/TypedTree/TcGlobals.fsi @@ -460,6 +460,12 @@ type internal TcGlobals = member cgh__runtimeAsyncReturn_vref: TypedTree.ValRef + member cgh__runtimeAsyncReturnValueTask_vref: TypedTree.ValRef + + member cgh__runtimeAsyncReturnUnit_vref: TypedTree.ValRef + + member cgh__runtimeAsyncReturnValueTaskUnit_vref: TypedTree.ValRef + member cgh__useResumableCode_vref: TypedTree.ValRef member char_operator_info: IntrinsicValRef diff --git a/src/FSharp.Core/resumable.fs b/src/FSharp.Core/resumable.fs index defdfd39964..d5cb979c526 100644 --- a/src/FSharp.Core/resumable.fs +++ b/src/FSharp.Core/resumable.fs @@ -117,6 +117,23 @@ module StateMachineHelpers = ignore value failwith "__runtimeAsyncReturn is a compiler intrinsic and should only be used in runtime-async method bodies" + + [] + let __runtimeAsyncReturnValueTask (value: 'T) : ValueTask<'T> = + ignore value + + failwith + "__runtimeAsyncReturnValueTask is a compiler intrinsic and should only be used in runtime-async method bodies" + + [] + let __runtimeAsyncReturnUnit () : Task = + failwith + "__runtimeAsyncReturnUnit is a compiler intrinsic and should only be used in runtime-async method bodies" + + [] + let __runtimeAsyncReturnValueTaskUnit () : ValueTask = + failwith + "__runtimeAsyncReturnValueTaskUnit is a compiler intrinsic and should only be used in runtime-async method bodies" #endif module ResumableCode = diff --git a/src/FSharp.Core/resumable.fsi b/src/FSharp.Core/resumable.fsi index 439b1234639..7dcdb0b0489 100644 --- a/src/FSharp.Core/resumable.fsi +++ b/src/FSharp.Core/resumable.fsi @@ -199,6 +199,15 @@ module StateMachineHelpers = /// This function is compiler-recognised and must not be called directly. [] val __runtimeAsyncReturn : 'T -> System.Threading.Tasks.Task<'T> + + [] + val __runtimeAsyncReturnValueTask : 'T -> System.Threading.Tasks.ValueTask<'T> + + [] + val __runtimeAsyncReturnUnit : unit -> System.Threading.Tasks.Task + + [] + val __runtimeAsyncReturnValueTaskUnit : unit -> System.Threading.Tasks.ValueTask #endif /// Adding this attribute to the method adjusts the processing of some generic methods diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index ae5adbf1bd4..bad1ab81baa 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -164,6 +164,39 @@ let ``runtime async compiles functions and members`` () = |> compile |> shouldSucceed +[] +let ``runtime async supports Task and ValueTask return intrinsics`` () = + FSharp """ +module RuntimeAsyncReturnShapesTest + +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let taskResult () : Task = + StateMachineHelpers.__runtimeAsyncReturn 1 + +let valueTaskResult () : ValueTask = + StateMachineHelpers.__runtimeAsyncReturnValueTask 1 + +let taskUnit () : Task = + StateMachineHelpers.__runtimeAsyncReturnUnit () + +let valueTaskUnit () : ValueTask = + StateMachineHelpers.__runtimeAsyncReturnValueTaskUnit () + +[] +let main _ = + taskUnit().Wait() + taskResult().Result |> ignore + valueTaskResult().Result |> ignore + valueTaskUnit().AsTask().Wait() + 0 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun + |> shouldSucceed + [] let ``runtime async combines awaited chunks without delegates`` () = FSharp runtimeAsyncRawSource From 74f02b670ac87add2e1c8da340aad3d193a6492a Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 08:12:12 +0200 Subject: [PATCH 27/59] add to surface area --- .../FSharp.Core.SurfaceArea.netcore.release.bsl | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl index 59db3956794..92e494cb328 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl @@ -1001,7 +1001,10 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task __runtimeAsyncReturnUnit() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.ValueTask __runtimeAsyncReturnValueTaskUnit() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.ValueTask`1[T] __runtimeAsyncReturnValueTask[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) From 096b2c16df730c33939053577fc2e01d48cae0a2 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 08:12:26 +0200 Subject: [PATCH 28/59] use active pattern --- .../Checking/Expressions/CheckExpressions.fs | 19 ++++++++++--------- src/Compiler/CodeGen/IlxGen.fs | 3 +-- src/Compiler/Optimize/Optimizer.fs | 8 +++----- src/Compiler/TypedTree/RuntimeAsync.fs | 6 +++--- 4 files changed, 17 insertions(+), 19 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index f4b73cfcc9b..6cc75d2cb74 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -8707,9 +8707,8 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl let isRuntimeAsync = match expr.Expr with - | Expr.Val(vref, _, _) - | Expr.App(Expr.Val(vref, _, _), _, [ _ ], [], _) - when IsRuntimeAsyncReturnVref g vref -> true + | Expr.Val(RuntimeAsyncReturn g, _, _) + | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, [ _ ], [], _) -> true | _ -> false match isRuntimeAsync, UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with @@ -9027,12 +9026,14 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let tryTcRuntimeAsyncApplication () = let intrinsic = match leftExpr with - | ApplicableExpr(expr=Expr.Val (vref, flags, m)) - when IsRuntimeAsyncReturnVref g vref -> - Some(vref, flags, m) - | ApplicableExpr(expr=Expr.App (Expr.Val (vref, flags, m), _, [ _ ], [], _)) - when IsRuntimeAsyncReturnVref g vref -> - Some(vref, flags, m) + | ApplicableExpr(expr=Expr.Val (vref, flags, m)) -> + match vref with + | RuntimeAsyncReturn g -> Some(vref, flags, m) + | _ -> None + | ApplicableExpr(expr=Expr.App (Expr.Val (vref, flags, m), _, [ _ ], [], _)) -> + match vref with + | RuntimeAsyncReturn g -> Some(vref, flags, m) + | _ -> None | _ -> None diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index 5b9966e07a3..e56905dc3a0 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3316,8 +3316,7 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = // application of local type functions with type parameters = measure types and body = local value - inline the body GenExpr cenv cgbuf eenv v sequel - | Expr.App(Expr.Val(vref, _, _), _, _, [ _ ], _) when IsRuntimeAsyncReturnVref g vref -> - GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel + | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, _, [ _ ], _) -> GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel | Expr.App(f, fty, tyargs, curriedArgs, m) -> GenApp cenv cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index c5da2a82d6a..a929aa5d4a0 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2541,8 +2541,7 @@ and private ExprContainsRuntimeAsyncFragment cenv env visiting expr = true else match stripExpr expr with - | Expr.App(Expr.Val(vref, _, _), _, _, _, _) - when IsRuntimeAsyncReturnVref cenv.g vref -> + | Expr.App(Expr.Val(RuntimeAsyncReturn cenv.g, _, _), _, _, _, _) -> true | _ when IsRuntimeAsyncSuspensionExpr cenv.g expr -> true @@ -2643,8 +2642,7 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App (f, fty, tyargs, argsl, m) -> match expr with - | Expr.App(Expr.Val(vref, flags, _), fty, _, [ body ], _) - when IsRuntimeAsyncReturnVref g vref -> + | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), fty, _, [ body ], _) -> let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } body let reportedStamps = HashSet() @@ -2653,7 +2651,7 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = errorR(Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension(RichText.mkText v.DisplayName), v.Range)) let bodyR = RewriteRuntimeAsyncExceptionHandlers g bodyR - Expr.App(Expr.Val(vref, flags, m), fty, tyargs, [ bodyR ], m), + Expr.App(f, fty, tyargs, [ bodyR ], m), { bodyInfo with HasEffect = true Info = UnknownValue } diff --git a/src/Compiler/TypedTree/RuntimeAsync.fs b/src/Compiler/TypedTree/RuntimeAsync.fs index ab276779424..702efb737d7 100644 --- a/src/Compiler/TypedTree/RuntimeAsync.fs +++ b/src/Compiler/TypedTree/RuntimeAsync.fs @@ -8,7 +8,7 @@ open FSharp.Compiler.TcGlobals open FSharp.Compiler.TypedTree open FSharp.Compiler.TypedTreeOps -let IsRuntimeAsyncReturnVref (g: TcGlobals) (vref: ValRef) = +let (|RuntimeAsyncReturn|_|) (g: TcGlobals) (vref: ValRef) = valRefEq g vref g.cgh__runtimeAsyncReturn_vref || valRefEq g vref g.cgh__runtimeAsyncReturnValueTask_vref || valRefEq g vref g.cgh__runtimeAsyncReturnUnit_vref @@ -16,7 +16,7 @@ let IsRuntimeAsyncReturnVref (g: TcGlobals) (vref: ValRef) = let IsRuntimeAsyncReturnUnitExpr (g: TcGlobals) expr = match stripExpr expr with - | Expr.App(Expr.Val(vref, _, _), _, [], [ _ ], _) when IsRuntimeAsyncReturnVref g vref -> true + | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, [], [ _ ], _) -> true | _ -> false let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = @@ -25,7 +25,7 @@ let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = match TryUnwrapRuntimeAsyncReturnExpr g innerExpr with | true, body -> true, body | false, _ -> false, expr - | Expr.App(Expr.Val(vref, _, _), _, _, [ body ], _) when IsRuntimeAsyncReturnVref g vref -> true, body + | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, _, [ body ], _) -> true, body | _ -> false, expr let IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = From 3cd61649fe96c1922c7f0960f63946a16c142ba3 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 08:36:19 +0200 Subject: [PATCH 29/59] simplify --- .../Checking/Expressions/CheckExpressions.fs | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 6cc75d2cb74..7f508dab31d 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -9026,16 +9026,11 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let tryTcRuntimeAsyncApplication () = let intrinsic = match leftExpr with - | ApplicableExpr(expr=Expr.Val (vref, flags, m)) -> - match vref with - | RuntimeAsyncReturn g -> Some(vref, flags, m) - | _ -> None - | ApplicableExpr(expr=Expr.App (Expr.Val (vref, flags, m), _, [ _ ], [], _)) -> - match vref with - | RuntimeAsyncReturn g -> Some(vref, flags, m) - | _ -> None + | ApplicableExpr(expr=Expr.Val (RuntimeAsyncReturn g as vref, flags, m)) + | ApplicableExpr(expr=Expr.App (Expr.Val (RuntimeAsyncReturn g as vref, flags, m), _, [ _ ], [], _)) -> + Some(vref, flags, m) | _ -> - None + None match intrinsic with | None -> From cf3187b1d72d70838c332961957677f15187e3c1 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 10:27:00 +0200 Subject: [PATCH 30/59] simplify --- .../Checking/Expressions/CheckExpressions.fs | 33 ++++++++----------- 1 file changed, 14 insertions(+), 19 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 7f508dab31d..c8e17f5b5ec 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -9023,19 +9023,10 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg else None - let tryTcRuntimeAsyncApplication () = - let intrinsic = - match leftExpr with - | ApplicableExpr(expr=Expr.Val (RuntimeAsyncReturn g as vref, flags, m)) - | ApplicableExpr(expr=Expr.App (Expr.Val (RuntimeAsyncReturn g as vref, flags, m), _, [ _ ], [], _)) -> - Some(vref, flags, m) - | _ -> - None - - match intrinsic with - | None -> - None - | Some(vref, flags, m) -> + let (|RuntimeAsyncApplication|_|) = + function + | ApplicableExpr(expr=Expr.Val (RuntimeAsyncReturn g as vref, flags, m)) + | ApplicableExpr(expr=Expr.App (Expr.Val (RuntimeAsyncReturn g as vref, flags, m), _, [ _ ], [], _)) -> checkLanguageFeatureAndRecover g.langVersion LanguageFeature.RuntimeAsync m let _, carrierTy = stripFunTy g exprTy @@ -9053,7 +9044,7 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let marker = Expr.App(Expr.Val(vref, flags, m), vref.Type, markerTyargs, [ arg ], mExprAndArg) - Some( + ValueSome( TcDelayed cenv overallTy @@ -9065,13 +9056,17 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg atomicFlag delayed ) + | _ -> + ValueNone + + match leftExpr with + | RuntimeAsyncApplication result -> result + | _ -> // If the type of 'synArg' unifies as a function type, then this is a function application, otherwise // it is an error or a computation expression or indexer or delegate invoke - match tryTcRuntimeAsyncApplication (), UnifyFunctionTypeUndoIfFailed cenv denv mLeftExpr exprTy with - | Some result, _ -> - result - | None, ValueSome (domainTy, resultTy) -> + match UnifyFunctionTypeUndoIfFailed cenv denv mLeftExpr exprTy with + | ValueSome (domainTy, resultTy) -> // atomicLeftExpr[idx] unifying as application gives a warning if not isSugar then @@ -9137,7 +9132,7 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let exprAndArg, resultTy = buildApp cenv leftExpr resultTy arg mExprAndArg TcDelayed cenv overallTy env tpenv mExprAndArg exprAndArg resultTy atomicFlag delayed - | None, ValueNone -> + | ValueNone -> // Type-directed invocables match synArg with From 398ad53a0b96bf2f59e7b72745660410e6de340c Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 13:41:27 +0200 Subject: [PATCH 31/59] update to supporting ildasm version --- eng/Versions.props | 2 +- .../Language/RuntimeAsyncEdgeCaseTests.fs | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/eng/Versions.props b/eng/Versions.props index 32cd8b7b8c9..5bad2f343cb 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -112,7 +112,7 @@ inlined into eng/Packages.props. --> 4.3.0-1.22220.8 5.0.0-preview.7.20364.11 - 5.0.0-preview.7.20364.11 + 10.0.11 0.13.10 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index a6830b03820..039bedbb509 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -97,7 +97,7 @@ let ``runtime async edge cases execute through the CE builder`` (optimize: bool) // `Await(Task); 1` — direct call to the non-generic Await overload, then push 1 and ret. let private simpleAwaitBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - f() cil managed noinlining + f() cil managed noinlining async { // Code size 13 (0xd) .maxstack 8 @@ -113,7 +113,7 @@ let private simpleAwaitBody = """ // into `add` with no spill local (optimized). let private genericAwaitBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - f(class [System.Runtime]System.Threading.Tasks.Task`1 t) cil managed noinlining + f(class [System.Runtime]System.Threading.Tasks.Task`1 t) cil managed noinlining async { // Code size 9 (0x9) .maxstack 8 @@ -128,7 +128,7 @@ let private genericAwaitBody = """ // `Await(ValueTask); 1` — the ValueTask (non-generic) Await overload bound by operand type. let private valueTaskAwaitBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - f(valuetype [System.Runtime]System.Threading.Tasks.ValueTask vt) cil managed noinlining + f(valuetype [System.Runtime]System.Threading.Tasks.ValueTask vt) cil managed noinlining async { // Code size 8 (0x8) .maxstack 8 @@ -183,7 +183,7 @@ let ``the CE builder lowers to Await with no state machine`` () = let private tailPrefixBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 f(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2 g, - int32 x) cil managed noinlining + int32 x) cil managed noinlining async { .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) // Code size 20 (0x14) From e1a6a5cc528aaf50b0e413e420b9d30335a0b7de Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 15:13:04 +0200 Subject: [PATCH 32/59] handle local mutables --- docs/runtime-async.md | 8 + src/Compiler/Optimize/LowerLocalMutables.fs | 11 + .../Language/RuntimeAsync/RuntimeTasks.fs | 189 ++++++++++++++---- 3 files changed, 173 insertions(+), 35 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 440e4c1056f..e323591af4d 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -176,6 +176,14 @@ catch-all case (3), so compilation stays correct — the cost is an extra nested runtime-async helper method rather than marking the enclosing method directly. +Case (3) re-homes the marker argument into a compiler-synthesized closure +during code generation, *after* `LowerLocalMutables` has run. Without special +handling, mutable locals used both in that body and in the enclosing scope +would be copied into the closure by value, silently disconnecting the two +copies. `LowerLocalMutables` therefore treats the marker argument as a lambda +body (`DecideExpr`), promoting its free mutable locals to reference cells so +the synthesized closure and the enclosing scope share them. + ## Runtime capability check `InfoReader` gates `LanguageFeature.RuntimeAsync` on the target reference diff --git a/src/Compiler/Optimize/LowerLocalMutables.fs b/src/Compiler/Optimize/LowerLocalMutables.fs index 9d969d8fd34..cb7ab2807b2 100644 --- a/src/Compiler/Optimize/LowerLocalMutables.fs +++ b/src/Compiler/Optimize/LowerLocalMutables.fs @@ -6,6 +6,7 @@ open Internal.Utilities.Collections open Internal.Utilities.Library.Extras open FSharp.Compiler open FSharp.Compiler.DiagnosticsLogger +open FSharp.Compiler.RuntimeAsync open FSharp.Compiler.TypedTree open FSharp.Compiler.TypedTreeBasics open FSharp.Compiler.TypedTreeOps @@ -101,6 +102,16 @@ let DecideExpr cenv exprF noInterceptF z expr = let z = (z, iimpls) ||> List.fold CheckInterfaceImpl z + // A __runtimeAsyncReturn application that does not end up at the top of a method or + // closure body is re-homed into a compiler-synthesized closure during code generation + // (GenRuntimeAsyncReturnAsStartedTask). Treat the argument as a lambda body so that its + // free mutable locals escape and are promoted to reference cells shared with the + // enclosing scope. When the application already is a lambda body this recomputes the + // same escapes, which is harmless. + | Expr.App (Expr.Val (RuntimeAsyncReturn g, _, _), _, _, [ body ], _) -> + let z = Zset.union z (DecideEscapes [] body) + exprF z body + | Expr.Op (c, tyargs, args, _m) -> DecideExprOp exprF noInterceptF z expr (c, tyargs, args) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs index 0a5f91d4a3d..eda375892b8 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs @@ -3,12 +3,7 @@ // with `task {` replaced by `runtimeTask {`. Test names and bodies are kept as // close to the originals as possible. // -// Tests that require suspending inside an exception-handling region are in the -// "Known failing" section at the bottom and are NOT called from main: the .NET -// runtime-async contract forbids suspension in EH regions, and depending on the -// case this currently either loses the finally or terminates the process -// (0xC0000409). `backgroundTask` tests have no runtimeTask equivalent and are -// omitted. +// `backgroundTask` tests have no runtimeTask equivalent and are omitted. module RuntimeTasks @@ -355,12 +350,9 @@ let testNonBlocking () = continueToFinish.Set() t.Wait() -// The knownFailing_* tests below suspend inside try/with in non-tail position -// (or require synchronous start before the first suspension). Suspension in -// exception-handling regions is forbidden by the runtime-async contract; these -// compile but are not run from main. +// Exception-handling and disposal coverage. -let knownFailing_testCatching1 () = +let testCatching1 () = let mutable x = 0 let mutable y = 0 let t = @@ -381,7 +373,7 @@ let knownFailing_testCatching1 () = require (y = 1) "bailed after exn" require (x = 0) "ran past failure" -let knownFailing_testCatching2 () = +let testCatching2 () = let mutable x = 0 let mutable y = 0 let t = @@ -402,7 +394,7 @@ let knownFailing_testCatching2 () = require (y = 1) "bailed after exn" require (x = 0) "ran past failure" -let knownFailing_testCatchingInApplicative () = +let testCatchingInApplicative () = let mutable x = 0 let mutable y = 0 let t = @@ -427,7 +419,7 @@ let knownFailing_testCatchingInApplicative () = require (y = 1) "bailed after exn" require (x = 1) "exit too early" -let knownFailing_testNestedCatching () = +let testNestedCatching () = let mutable counter = 1 let mutable caughtInner = 0 let mutable caughtOuter = 0 @@ -589,7 +581,7 @@ let testForLoopSadPath () = } require (t.Result = 1) "wrong result" -let knownFailing_testForLoopSadPathComplex () = +let testForLoopSadPathComplex () = for i in 1 .. 5 do let mutable disposed = false let wrapList = @@ -933,16 +925,7 @@ module Issue12184f = } // --------------------------------------------------------------------------- -// Known failing: these tests suspend inside an exception-handling region -// (try/finally or an `Using` finally that awaits an IAsyncDisposable), which -// the runtime-async contract forbids. Today they either lose the finally or -// terminate the process (0xC0000409), so they are compiled but not run. -// RuntimeTasksAsyncDisposalException.fs keeps the minimal crash repro. -// -// A second group relies on synchronous (hot) start of the task body up to the -// first suspension. On the current runtime build a runtime-async body does not -// observably run before the returned Task is awaited, so these are not run -// either. +// Exception-handling and disposal coverage. // --------------------------------------------------------------------------- let knownDivergent_testNoDelay () = @@ -956,7 +939,7 @@ let knownDivergent_testNoDelay () = require (x = 1) "first part didn't run yet" t.Wait() -let knownFailing_testTryFinallyHappyPath () = +let testTryFinallyHappyPath () = for i in 1 .. 5 do let mutable ran = false let t = @@ -971,7 +954,7 @@ let knownFailing_testTryFinallyHappyPath () = t.Wait() require ran "never ran" -let knownFailing_testTryFinallySadPath () = +let testTryFinallySadPath () = for i in 1 .. 5 do let mutable ran = false let t = @@ -990,7 +973,7 @@ let knownFailing_testTryFinallySadPath () = | _ -> () require ran "never ran" -let knownFailing_testTryFinallyCaught () = +let testTryFinallyCaught () = for i in 1 .. 5 do let mutable ran = false let t = @@ -1010,7 +993,7 @@ let knownFailing_testTryFinallyCaught () = require (t.Result = 2) "wrong return" require ran "never ran" -let knownFailing_testUsing () = +let testUsing () = for i in 1 .. 5 do let mutable disposed = false let t = @@ -1023,7 +1006,7 @@ let knownFailing_testUsing () = t.Wait() require disposed "never disposed B" -let knownFailing_testUsingFromTask () = +let testUsingFromTask () = let mutable disposedInner = false let mutable disposed = false let t = @@ -1043,7 +1026,7 @@ let knownFailing_testUsingFromTask () = t.Wait() require disposed "never disposed C" -let knownFailing_testUsingSadPath () = +let testUsingSadPath () = let mutable disposedInner = false let mutable disposed = false let t = @@ -1088,7 +1071,123 @@ let testUsingAsyncDisposableSync () = require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" -let knownFailing_testExceptionThrownInFinally () = +let testUsingAsyncDisposableAsync () = + for i in 1 .. 5 do + let mutable disposed = 0 + let t = + runtimeTask { + use d = + { new IAsyncDisposable with + member _.DisposeAsync() = + runtimeTask { + do! Task.Delay(10) + disposed <- disposed + 1 + } + |> ValueTask } + require (disposed = 0) "disposed way early" + do! Task.Delay(100) + require (disposed = 0) "disposed kinda early" + } + t.Wait() + require (disposed >= 1) "never disposed B" + require (disposed <= 1) "too many dispose on B" + +let testUsingAsyncDisposableExnAsync () = + for i in 1 .. 5 do + let mutable disposed = 0 + let t = + runtimeTask { + use d = + { new IAsyncDisposable with + member _.DisposeAsync() = + runtimeTask { + do! Task.Delay(10) + disposed <- disposed + 1 + } + |> ValueTask } + require (disposed = 0) "disposed way early" + failtest "oops" + } + try + t.Wait() + with + | :? AggregateException -> + require (disposed >= 1) "never disposed B" + require (disposed <= 1) "too many dispose on B" + +let testUsingAsyncDisposableExnSync () = + for i in 1 .. 5 do + let mutable disposed = 0 + let t = + runtimeTask { + use d = + { new IAsyncDisposable with + member _.DisposeAsync() = + runtimeTask { + disposed <- disposed + 1 + do! Task.Delay(10) + } + |> ValueTask } + require (disposed = 0) "disposed way early" + failtest "oops" + } + try + t.Wait() + with + | :? AggregateException -> + require (disposed >= 1) "never disposed B" + require (disposed <= 1) "too many dispose on B" + +let testUsingAsyncDisposableDelayExnSync () = + for i in 1 .. 5 do + let mutable disposed = 0 + let t = + runtimeTask { + use d = + { new IAsyncDisposable with + member _.DisposeAsync() = + runtimeTask { + disposed <- disposed + 1 + do! Task.Delay(10) + } + |> ValueTask } + require (disposed = 0) "disposed way early" + do! Task.Delay(10) + require (disposed = 0) "disposed kind of early" + failtest "oops" + } + try + t.Wait() + with + | :? AggregateException -> + require (disposed >= 1) "never disposed B" + require (disposed <= 1) "too many dispose on B" + +let testUsingBindAsyncDisposableSync () = + for i in 1 .. 5 do + let mutable disposed = 0 + let t = + runtimeTask { + use! d = + runtimeTask { + do! Task.Delay(10) + return + { new IAsyncDisposable with + member _.DisposeAsync() = + runtimeTask { + disposed <- disposed + 1 + } + |> ValueTask } + } + require (disposed = 0) "disposed way early" + do! Task.Delay(100) + require (disposed = 0) "disposed kinda early" + } + t.Wait() + require (disposed >= 1) "never disposed B" + require (disposed <= 1) "too many dispose on B" + +let testExceptionThrownInFinally () = for i in 1 .. 5 do use stepOutside = new SemaphoreSlim(0) use ranInitial = new ManualResetEventSlim() @@ -1116,7 +1215,7 @@ let knownFailing_testExceptionThrownInFinally () = require ranNext.IsSet "didn't run next" require (ranFinally = 1) "didn't run finally exactly once" -let knownFailing_test2ndExceptionThrownInFinally () = +let test2ndExceptionThrownInFinally () = for i in 1 .. 5 do use ranInitial = new ManualResetEventSlim() use continueTask = new SemaphoreSlim(0) @@ -1144,7 +1243,7 @@ let knownFailing_test2ndExceptionThrownInFinally () = require ranNext.IsSet "didn't run next" require (ranFinally = 1) "didn't run finally exactly once" -let knownFailing_testTryFinallyOverReturnFromWithException () = +let testTryFinallyOverReturnFromWithException () = let inner() = runtimeTask { do! Task.Yield() @@ -1166,7 +1265,7 @@ let knownFailing_testTryFinallyOverReturnFromWithException () = | :? AggregateException -> () require (m = 1) "didn't run finally" -let knownFailing_testTryFinallyOverReturnFromWithoutException () = +let testTryFinallyOverReturnFromWithoutException () = let inner() = runtimeTask { do! Task.Yield() @@ -1272,6 +1371,10 @@ let main _ = testShortCircuitResult() testDelay() testNonBlocking() + testCatching1() + testCatching2() + testCatchingInApplicative() + testNestedCatching() testWhileLoopSync() testWhileLoopAsyncZeroIteration() testWhileLoopAsyncOneIteration() @@ -1279,14 +1382,30 @@ let main _ = testForLoopA() testForLoopComplex() testForLoopSadPath() + testForLoopSadPathComplex() testFixedStackWhileLoop() testTypeInference() testNoStackOverflowWithImmediateResult() testNoStackOverflowWithYieldResult() testSmallTailRecursion() testTryOverReturnFrom() + testTryFinallyOverReturnFromWithException() + testTryFinallyOverReturnFromWithoutException() testAsyncsMixedWithTasks() testAsyncsMixedWithTasks_ShouldNotSwitchContext() testCustomAwaitable() testUsingAsyncDisposableSync() + testUsingAsyncDisposableAsync() + testUsingAsyncDisposableExnAsync() + testUsingAsyncDisposableExnSync() + testUsingAsyncDisposableDelayExnSync() + testUsingBindAsyncDisposableSync() + testTryFinallyHappyPath() + testTryFinallySadPath() + testTryFinallyCaught() + testUsing() + testUsingFromTask() + testUsingSadPath() + testExceptionThrownInFinally() + test2ndExceptionThrownInFinally() 0 From 3a0b2b978ad1019f39bb86e411717d643dd6c71f Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 15:23:11 +0200 Subject: [PATCH 33/59] Revert "update to supporting ildasm version" This reverts commit 398ad53a0b96bf2f59e7b72745660410e6de340c. --- eng/Versions.props | 2 +- .../Language/RuntimeAsyncEdgeCaseTests.fs | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/eng/Versions.props b/eng/Versions.props index 5bad2f343cb..32cd8b7b8c9 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -112,7 +112,7 @@ inlined into eng/Packages.props. --> 4.3.0-1.22220.8 5.0.0-preview.7.20364.11 - 10.0.11 + 5.0.0-preview.7.20364.11 0.13.10 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index 039bedbb509..a6830b03820 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -97,7 +97,7 @@ let ``runtime async edge cases execute through the CE builder`` (optimize: bool) // `Await(Task); 1` — direct call to the non-generic Await overload, then push 1 and ret. let private simpleAwaitBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - f() cil managed noinlining async + f() cil managed noinlining { // Code size 13 (0xd) .maxstack 8 @@ -113,7 +113,7 @@ let private simpleAwaitBody = """ // into `add` with no spill local (optimized). let private genericAwaitBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - f(class [System.Runtime]System.Threading.Tasks.Task`1 t) cil managed noinlining async + f(class [System.Runtime]System.Threading.Tasks.Task`1 t) cil managed noinlining { // Code size 9 (0x9) .maxstack 8 @@ -128,7 +128,7 @@ let private genericAwaitBody = """ // `Await(ValueTask); 1` — the ValueTask (non-generic) Await overload bound by operand type. let private valueTaskAwaitBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 - f(valuetype [System.Runtime]System.Threading.Tasks.ValueTask vt) cil managed noinlining async + f(valuetype [System.Runtime]System.Threading.Tasks.ValueTask vt) cil managed noinlining { // Code size 8 (0x8) .maxstack 8 @@ -183,7 +183,7 @@ let ``the CE builder lowers to Await with no state machine`` () = let private tailPrefixBody = """ .method public static class [System.Runtime]System.Threading.Tasks.Task`1 f(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2 g, - int32 x) cil managed noinlining async + int32 x) cil managed noinlining { .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) // Code size 20 (0x14) From 8ca1f2e1a9a26d6d6a3bbc401a6aa751dc5b707b Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 18:44:58 +0200 Subject: [PATCH 34/59] add some IAsyncEnumerable tests --- .../RuntimeAsync/RuntimeAsyncEnumerable.fs | 85 +++++++++++++++++++ .../Language/RuntimeAsyncTests.fs | 9 ++ 2 files changed, 94 insertions(+) create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs new file mode 100644 index 00000000000..b86560dda4c --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs @@ -0,0 +1,85 @@ +module RuntimeAsyncEnumerable + +open System +open System.Collections.Generic +open System.Diagnostics +open System.Runtime.CompilerServices +open System.Threading +open System.Threading.Tasks +open Microsoft.FSharp.Control +open Microsoft.FSharp.Core.CompilerServices + +type CounterEnumerator(count: int) = + let mutable current = -1 + + member private _.MoveNextCore() : ValueTask = + StateMachineHelpers.__runtimeAsyncReturnValueTask ( + AsyncHelpers.Await(Task.Delay(1)) + current <- current + 1 + current < count) + + interface IAsyncEnumerator with + member _.Current = current + member this.MoveNextAsync() = this.MoveNextCore() + member _.DisposeAsync() = ValueTask() + +type CounterEnumerable(count: int) = + interface IAsyncEnumerable with + member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = + CounterEnumerator(count) :> IAsyncEnumerator + +let objectExpressionEnumerable count : IAsyncEnumerable = + { new IAsyncEnumerable with + member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = + let mutable current = -1 + + { new IAsyncEnumerator with + member _.Current = current + + member _.MoveNextAsync() : ValueTask = + StateMachineHelpers.__runtimeAsyncReturnValueTask ( + AsyncHelpers.Await(Task.Delay(100)) + current <- current + 1 + current < count) + + member _.DisposeAsync() = ValueTask() } } + +let collect (enumerable: IAsyncEnumerable) : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + let enumerator = enumerable.GetAsyncEnumerator(CancellationToken.None) + let values = ResizeArray() + let mutable hasNext = AsyncHelpers.Await(enumerator.MoveNextAsync()) + + while hasNext do + values.Add enumerator.Current + hasNext <- AsyncHelpers.Await(enumerator.MoveNextAsync()) + + AsyncHelpers.Await(enumerator.DisposeAsync()) + Seq.toArray values) + +let collectWithTaskCe (enumerable: IAsyncEnumerable) = + task { + use enumerator = enumerable.GetAsyncEnumerator(CancellationToken.None) + let values = ResizeArray() + let stopwatch = Stopwatch.StartNew() + + while! enumerator.MoveNextAsync() do + values.Add enumerator.Current + + return Seq.toArray values, stopwatch.Elapsed + } + +[] +let main _ = + let expected = [| 0; 1; 2 |] + let classEnumerable = CounterEnumerable(3) :> IAsyncEnumerable + let classValues = collect classEnumerable |> fun task -> task.GetAwaiter().GetResult() + let taskValues, elapsed = + collectWithTaskCe (objectExpressionEnumerable 3) |> fun task -> task.GetAwaiter().GetResult() + + if classValues = expected + && taskValues = expected + && elapsed >= TimeSpan.FromMilliseconds(300.) then + 0 + else + 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index bad1ab81baa..c4e8ed3e2db 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -241,6 +241,15 @@ let ``runtime async direct intrinsic fixture executes`` () = |> compileExeAndRun |> shouldSucceed +[] +let ``runtime async low level async enumerable fixture executes`` () = + Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncEnumerable.fs") + |> FsFromPath + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun + |> shouldSucceed + [] let ``runtime async suspension in exception region executes`` () = Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasksAsyncDisposalException.fs") From 51705d9f307abbdd306923ee37a1b65f94a703fa Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 26 Aug 2026 19:04:47 +0200 Subject: [PATCH 35/59] test basic AsyncLocal propagation --- .../RuntimeAsync/RuntimeAsyncAsyncLocal.fs | 55 +++++++++++++++++++ .../Language/RuntimeAsyncTests.fs | 10 ++++ 2 files changed, 65 insertions(+) create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs new file mode 100644 index 00000000000..c8065514342 --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs @@ -0,0 +1,55 @@ +module RuntimeAsyncAsyncLocal + +open System.Threading +open System.Threading.Tasks + +open RuntimeTaskBuilder.RuntimeTask + +let private context = AsyncLocal() + +let private preservesValueAcrossAwait () = + runtimeTask { + context.Value <- "before" + do! Task.Delay(1) + if context.Value <> "before" then failwith "AsyncLocal value was not preserved across await" + } + +let private propagatesValueToNestedRuntimeTask () = + runtimeTask { + context.Value <- "parent" + + let! nestedValue = + runtimeTask { + do! Task.Delay(1) + return context.Value + } + + if nestedValue <> "parent" then failwith "AsyncLocal value was not propagated to nested runtimeTask" + } + +let private isolatesChildTaskChanges () = + runtimeTask { + context.Value <- "parent" + + let! childValue = + Task.Run(fun () -> + context.Value <- "child" + context.Value) + + if childValue <> "child" then failwith "AsyncLocal child value was not set" + if context.Value <> "parent" then failwith "AsyncLocal child change leaked to parent" + } + +[] +let main _ = + context.Value <- "main" + [| preservesValueAcrossAwait() + propagatesValueToNestedRuntimeTask() + isolatesChildTaskChanges() |] + |> Task.WhenAll + |> _.Result + |> ignore + + if context.Value <> "main" then failwith "AsyncLocal value was not preserved after all tasks completed" + + 0 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index c4e8ed3e2db..5a1b693937c 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -230,6 +230,16 @@ let ``runtime task builder fixture executes through runtime async`` (optimize: b |> withFSharpCoreShippedNet |> withOptimization optimize |> compileExeAndRun + +[] +let ``runtime task AsyncLocal values propagate through runtime async`` () = + FsFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTaskBuilder.fs")) + |> withAdditionalSourceFile ( + SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncAsyncLocal.fs")) + ) + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun |> shouldSucceed [] From d6f1bad160af5dabad2dbb0a65b833b746265f12 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 28 Aug 2026 13:31:26 +0200 Subject: [PATCH 36/59] format fixture and some cleanup --- .../RuntimeAsync/RuntimeAsyncAsyncLocal.fs | 26 +- .../RuntimeAsync/RuntimeAsyncBasic.fs | 23 +- .../RuntimeAsync/RuntimeAsyncEdgeCases.fs | 22 +- .../RuntimeAsync/RuntimeAsyncEnumerable.fs | 31 +- .../RuntimeAsync/RuntimeTaskBuilder.fs | 104 ++- .../Language/RuntimeAsync/RuntimeTasks.fs | 721 +++++++++++------- .../RuntimeTasksAsyncDisposalException.fs | 21 +- 7 files changed, 616 insertions(+), 332 deletions(-) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs index c8065514342..0bd7899d658 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncAsyncLocal.fs @@ -11,7 +11,9 @@ let private preservesValueAcrossAwait () = runtimeTask { context.Value <- "before" do! Task.Delay(1) - if context.Value <> "before" then failwith "AsyncLocal value was not preserved across await" + + if context.Value <> "before" then + failwith "AsyncLocal value was not preserved across await" } let private propagatesValueToNestedRuntimeTask () = @@ -24,7 +26,8 @@ let private propagatesValueToNestedRuntimeTask () = return context.Value } - if nestedValue <> "parent" then failwith "AsyncLocal value was not propagated to nested runtimeTask" + if nestedValue <> "parent" then + failwith "AsyncLocal value was not propagated to nested runtimeTask" } let private isolatesChildTaskChanges () = @@ -36,20 +39,27 @@ let private isolatesChildTaskChanges () = context.Value <- "child" context.Value) - if childValue <> "child" then failwith "AsyncLocal child value was not set" - if context.Value <> "parent" then failwith "AsyncLocal child change leaked to parent" + if childValue <> "child" then + failwith "AsyncLocal child value was not set" + + if context.Value <> "parent" then + failwith "AsyncLocal child change leaked to parent" } [] let main _ = context.Value <- "main" - [| preservesValueAcrossAwait() - propagatesValueToNestedRuntimeTask() - isolatesChildTaskChanges() |] + + [| + preservesValueAcrossAwait () + propagatesValueToNestedRuntimeTask () + isolatesChildTaskChanges () + |] |> Task.WhenAll |> _.Result |> ignore - if context.Value <> "main" then failwith "AsyncLocal value was not preserved after all tasks completed" + if context.Value <> "main" then + failwith "AsyncLocal value was not preserved after all tasks completed" 0 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs index 8974f367b0b..5022f08f153 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncBasic.fs @@ -11,26 +11,27 @@ let private delayed value = let add (x: int) (y: int) : Task = StateMachineHelpers.__runtimeAsyncReturn ( let first = AsyncHelpers.Await(delayed x) - first + y) + first + y + ) -let lambdaAdd : int -> Task = +let lambdaAdd: int -> Task = fun value -> StateMachineHelpers.__runtimeAsyncReturn ( let result = AsyncHelpers.Await(delayed value) - result + 1) + result + 1 + ) let makeAdder (offset: int) : int -> Task = fun value -> StateMachineHelpers.__runtimeAsyncReturn ( let result = AsyncHelpers.Await(delayed value) - result + offset) + result + offset + ) -let inline apply ([] operation: int -> int) (value: int) = - operation value +let inline apply ([] operation: int -> int) (value: int) = operation value let inline awaitAndAdd (value: int) = - let result = - AsyncHelpers.Await(Task.Delay(1).ContinueWith(fun (_: Task) -> value)) + let result = AsyncHelpers.Await(Task.Delay(1).ContinueWith(fun (_: Task) -> value)) apply (fun current -> current + 1) result @@ -41,13 +42,13 @@ type Calculator() = member _.Add(x: int, y: int) : Task = StateMachineHelpers.__runtimeAsyncReturn ( let first = AsyncHelpers.Await(delayed x) - first + y) + first + y + ) static member Double(value: int) : Task = StateMachineHelpers.__runtimeAsyncReturn (value * 2) -let private resultOf (task: Task) = - task.GetAwaiter().GetResult() +let private resultOf (task: Task) = task.GetAwaiter().GetResult() [] let main _ = diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs index c1efa0c48f7..85bd3634c17 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEdgeCases.fs @@ -9,7 +9,9 @@ open System.Runtime.CompilerServices open Microsoft.FSharp.Core.CompilerServices open RuntimeTaskBuilder.RuntimeTask -let private delayed v = Task.Delay(1).ContinueWith(fun (_: Task) -> v) +let private delayed v = + Task.Delay(1).ContinueWith(fun (_: Task) -> v) + let private resultOf (t: Task<'T>) = t.GetAwaiter().GetResult() // locals: a normal local is hoisted by the JIT and preserved across a suspension. @@ -25,14 +27,18 @@ let loopsAcrossAwait () : Task = runtimeTask { let mutable whileAcc = 0 let mutable i = 0 + while i < 3 do let! x = delayed 1 whileAcc <- whileAcc + x i <- i + 1 + let mutable forAcc = 0 + for x in [ 1; 2; 3 ] do let! y = delayed x forAcc <- forAcc + y + return (whileAcc, forAcc) } @@ -80,7 +86,11 @@ let useAsyncDisposable (sink: int ref) : Task = [] let main _ = let mutable failures = 0 - let check name cond = if not cond then eprintfn "FAILED: %s" name; failures <- failures + 1 + + let check name cond = + if not cond then + eprintfn "FAILED: %s" name + failures <- failures + 1 check "normalLocalAcross" (resultOf (normalLocalAcross ()) = 42) let (whileAcc, forAcc) = resultOf (loopsAcrossAwait ()) @@ -90,8 +100,12 @@ let main _ = check "awaitValueTask" (resultOf (awaitValueTask ()) = 42) let threw = - try resultOf (exnAfterAwait ()) |> ignore; false - with _ -> true + try + resultOf (exnAfterAwait ()) |> ignore + false + with _ -> + true + check "exnAfterAwait propagates" threw let sink = ref 0 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs index b86560dda4c..5807a91e414 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs @@ -16,7 +16,8 @@ type CounterEnumerator(count: int) = StateMachineHelpers.__runtimeAsyncReturnValueTask ( AsyncHelpers.Await(Task.Delay(1)) current <- current + 1 - current < count) + current < count + ) interface IAsyncEnumerator with member _.Current = current @@ -40,9 +41,12 @@ let objectExpressionEnumerable count : IAsyncEnumerable = StateMachineHelpers.__runtimeAsyncReturnValueTask ( AsyncHelpers.Await(Task.Delay(100)) current <- current + 1 - current < count) + current < count + ) - member _.DisposeAsync() = ValueTask() } } + member _.DisposeAsync() = ValueTask() + } + } let collect (enumerable: IAsyncEnumerable) : Task = StateMachineHelpers.__runtimeAsyncReturn ( @@ -55,7 +59,8 @@ let collect (enumerable: IAsyncEnumerable) : Task = hasNext <- AsyncHelpers.Await(enumerator.MoveNextAsync()) AsyncHelpers.Await(enumerator.DisposeAsync()) - Seq.toArray values) + Seq.toArray values + ) let collectWithTaskCe (enumerable: IAsyncEnumerable) = task { @@ -73,13 +78,19 @@ let collectWithTaskCe (enumerable: IAsyncEnumerable) = let main _ = let expected = [| 0; 1; 2 |] let classEnumerable = CounterEnumerable(3) :> IAsyncEnumerable - let classValues = collect classEnumerable |> fun task -> task.GetAwaiter().GetResult() - let taskValues, elapsed = - collectWithTaskCe (objectExpressionEnumerable 3) |> fun task -> task.GetAwaiter().GetResult() - if classValues = expected - && taskValues = expected - && elapsed >= TimeSpan.FromMilliseconds(300.) then + let classValues = + collect classEnumerable |> fun task -> task.GetAwaiter().GetResult() + + let taskValues, elapsed = + collectWithTaskCe (objectExpressionEnumerable 3) + |> fun task -> task.GetAwaiter().GetResult() + + if + classValues = expected + && taskValues = expected + && elapsed >= TimeSpan.FromMilliseconds(300.) + then 0 else 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs index 5181bf1869d..691f0cb7b40 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs @@ -6,53 +6,69 @@ open System.Threading.Tasks open Microsoft.FSharp.Control open Microsoft.FSharp.Core.CompilerServices -type RuntimeTask<'T> = unit -> 'T - let inline bindAwaiter ([] getAwaiter: unit -> 'Awaiter) ([] getResult: 'Awaiter -> 'T) ([] continuation: 'T -> 'U) = - let awaiter = getAwaiter() + let awaiter = getAwaiter () AsyncHelpers.AwaitAwaiter awaiter let result = getResult awaiter continuation result type RuntimeTaskBuilder() = - member inline _.Delay([] generator: unit -> 'T) : unit -> 'T = generator - member inline _.Run([] code: unit -> 'T) : Task<'T> = - StateMachineHelpers.__runtimeAsyncReturn (code()) + member inline _.Delay([] generator: unit -> 'T) = generator + + member inline _.Run([] code) = + StateMachineHelpers.__runtimeAsyncReturn (code ()) + member inline _.Zero() = () - member inline _.Return(value: 'T) = value + + member inline _.Return(value) = value + member inline _.ReturnFrom(task: Task<'T>) = AsyncHelpers.Await task member inline _.ReturnFrom(task: Task) = AsyncHelpers.Await task member inline _.ReturnFrom(task: ValueTask<'T>) = AsyncHelpers.Await task member inline _.ReturnFrom(task: ValueTask) = AsyncHelpers.Await task - member inline _.ReturnFrom(computation: Async<'T>) = AsyncHelpers.Await(Async.StartImmediateAsTask computation) + + member inline _.ReturnFrom(computation: Async<'T>) = + AsyncHelpers.Await(Async.StartImmediateAsTask computation) + member inline _.Bind(task: Task, [] continuation: unit -> 'U) = AsyncHelpers.Await task - continuation() - member inline _.Bind(task: Task<'T>, [] continuation: 'T -> 'U) = - continuation (AsyncHelpers.Await task) - member inline _.Bind(code: struct ('T1 * 'T2), [] continuation: struct ('T1 * 'T2) -> 'U) = - continuation code - member inline _.Bind(computation: RuntimeTask<'T>, [] continuation: 'T -> 'U) = - continuation (computation ()) + continuation () + + member inline _.Bind(task: Task<'T>, [] continuation: 'T -> 'U) = continuation (AsyncHelpers.Await task) + + member inline _.Bind(code: struct ('T1 * 'T2), [] continuation: struct ('T1 * 'T2) -> 'U) = continuation code + member inline _.Bind(task: ValueTask, [] continuation: unit -> 'U) = AsyncHelpers.Await task - continuation() - member inline _.Bind(task: ValueTask<'T>, [] continuation: 'T -> 'U) = - continuation (AsyncHelpers.Await task) + continuation () + + member inline _.Bind(task: ValueTask<'T>, [] continuation: 'T -> 'U) = continuation (AsyncHelpers.Await task) + member inline _.Bind(computation: Async<'T>, [] continuation: 'T -> 'U) = continuation (AsyncHelpers.Await(Async.StartImmediateAsTask computation)) + member inline _.Combine(first, [] second) = - first() - second() - member inline _.Combine(first: unit, [] second: unit -> 'T) = second() + first () + second () + + member inline _.Combine(first: unit, [] second: unit -> 'T) = second () + member inline _.TryWith([] body: unit -> 'T, [] handler: exn -> 'T) = - try body() with error -> handler error + try + body () + with error -> + handler error + member inline _.TryFinally([] body: unit -> 'T, [] compensation: unit -> unit) = - try body() finally compensation() + try + body () + finally + compensation () + member inline _.Using(resource, [] body) = try body resource @@ -63,64 +79,86 @@ type RuntimeTaskBuilder() = | _ -> () member inline _.While(guard: unit -> bool, [] body: unit -> unit) = - while guard() do body() + while guard () do + body () + member inline _.For(sequence: seq<'T>, [] body: 'T -> unit) = - for item in sequence do body item + for item in sequence do + body item + member inline _.MergeSources(left: Task<'T1>, right: Task<'T2>) = struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: ValueTask<'T2>) = struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: Task<'T1>, right: ValueTask<'T2>) = struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: Task<'T2>) = struct (AsyncHelpers.Await left, AsyncHelpers.Await right) + member inline _.MergeSources(left: Task<'T1>, right: Async<'T2>) = struct (AsyncHelpers.Await left, AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: Async<'T1>, right: Task<'T2>) = struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), AsyncHelpers.Await right) + member inline _.MergeSources(left: Async<'T1>, right: Async<'T2>) = struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: Async<'T1>, right: ValueTask<'T2>) = struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: Async<'T2>) = struct (AsyncHelpers.Await left, AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: YieldAwaitable, right: Task<'T2>) = AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) struct ((), AsyncHelpers.Await right) + member inline _.MergeSources(left: Task<'T1>, right: YieldAwaitable) = let leftResult = AsyncHelpers.Await left AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) struct (leftResult, ()) + member inline _.MergeSources(left: YieldAwaitable, right: ValueTask<'T2>) = AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) struct ((), AsyncHelpers.Await right) + member inline _.MergeSources(left: ValueTask<'T1>, right: YieldAwaitable) = let leftResult = AsyncHelpers.Await left AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) struct (leftResult, ()) + member inline _.MergeSources(left: YieldAwaitable, right: Async<'T2>) = AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) struct ((), AsyncHelpers.Await(Async.StartImmediateAsTask right)) + member inline _.MergeSources(left: Async<'T1>, right: YieldAwaitable) = let leftResult = AsyncHelpers.Await(Async.StartImmediateAsTask left) AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) struct (leftResult, ()) + member inline _.MergeSources(left: YieldAwaitable, right: struct ('T2 * 'T3)) = AsyncHelpers.AwaitAwaiter(left.GetAwaiter()) struct ((), right) + member inline _.MergeSources(left: struct ('T1 * 'T2), right: YieldAwaitable) = AsyncHelpers.AwaitAwaiter(right.GetAwaiter()) struct (left, ()) - member inline _.MergeSources(left: Task<'T1>, right: struct ('T2 * 'T3)) = - struct (AsyncHelpers.Await left, right) - member inline _.MergeSources(left: ValueTask<'T1>, right: struct ('T2 * 'T3)) = - struct (AsyncHelpers.Await left, right) + + member inline _.MergeSources(left: Task<'T1>, right: struct ('T2 * 'T3)) = struct (AsyncHelpers.Await left, right) + + member inline _.MergeSources(left: ValueTask<'T1>, right: struct ('T2 * 'T3)) = struct (AsyncHelpers.Await left, right) + member inline _.MergeSources(left: Async<'T1>, right: struct ('T2 * 'T3)) = struct (AsyncHelpers.Await(Async.StartImmediateAsTask left), right) - member inline _.MergeSources(left: struct ('T1 * 'T2), right: Task<'T3>) = - struct (left, AsyncHelpers.Await right) - member inline _.MergeSources(left: struct ('T1 * 'T2), right: ValueTask<'T3>) = - struct (left, AsyncHelpers.Await right) + + member inline _.MergeSources(left: struct ('T1 * 'T2), right: Task<'T3>) = struct (left, AsyncHelpers.Await right) + + member inline _.MergeSources(left: struct ('T1 * 'T2), right: ValueTask<'T3>) = struct (left, AsyncHelpers.Await right) + member inline _.MergeSources(left: struct ('T1 * 'T2), right: Async<'T3>) = struct (left, AsyncHelpers.Await(Async.StartImmediateAsTask right)) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs index eda375892b8..f785e743108 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs @@ -22,7 +22,11 @@ open RuntimeTaskBuilder.RuntimeTaskAwaitableExtensions exception TestException of string let BIG = 10 -let require x msg = if not x then failwith msg + +let require x msg = + if not x then + failwith msg + let failtest str = raise (TestException str) let resultOf (task: Task<'T>) = task.GetAwaiter().GetResult() @@ -34,12 +38,12 @@ let private delayed value = // --------------------------------------------------------------------------- let tinyTask () = - runtimeTask { - return 1 - } + runtimeTask { return 1 } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let tbind () = runtimeTask { @@ -48,7 +52,9 @@ let tbind () = } |> fun t -> t.Wait() - if t.Result <> 2 then failwith "failed" + + if t.Result <> 2 then + failwith "failed" let tnested () = runtimeTask { @@ -57,46 +63,55 @@ let tnested () = } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let tcatch0 () = runtimeTask { try - return 1 + return 1 with e -> - return 2 + return 2 } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let tcatch1 () = runtimeTask { try - let! x = Task.FromResult 1 - return x + let! x = Task.FromResult 1 + return x with e -> - return 2 + return 2 } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let t3 () = - let t2() = + let t2 () = runtimeTask { System.Console.WriteLine("hello") return 1 } + runtimeTask { System.Console.WriteLine("hello") - let! x = t2() + let! x = t2 () System.Console.WriteLine("world") return 1 + x } |> fun t -> t.Wait() - if t.Result <> 2 then failwith "failed" + + if t.Result <> 2 then + failwith "failed" let t3b () = runtimeTask { @@ -107,7 +122,9 @@ let t3b () = } |> fun t -> t.Wait() - if t.Result <> 2 then failwith "failed" + + if t.Result <> 2 then + failwith "failed" let t3c () = runtimeTask { @@ -118,7 +135,9 @@ let t3c () = } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" // This tests an exception match let t67 () = @@ -126,39 +145,44 @@ let t67 () = try do! Task.Delay(0) with - | :? ArgumentException -> - () - | _ -> - () + | :? ArgumentException -> () + | _ -> () } |> fun t -> t.Wait() - if t.Result <> () then failwith "failed" + + if t.Result <> () then + failwith "failed" // This tests compiling an incomplete exception match let t68 () = runtimeTask { try do! Task.Delay(0) - with - | :? ArgumentException -> + with :? ArgumentException -> () } |> fun t -> t.Wait() - if t.Result <> () then failwith "failed" + + if t.Result <> () then + failwith "failed" let testCompileAsyncWhileLoop () = runtimeTask { let mutable i = 0 + while i < 5 do i <- i + 1 do! Task.Yield() + return i } |> fun t -> t.Wait() - if t.Result <> 5 then failwith "failed" + + if t.Result <> 5 then + failwith "failed" let merge2tasks () = runtimeTask { @@ -168,7 +192,9 @@ let merge2tasks () = } |> fun t -> t.Wait() - if t.Result <> 3 then failwith "failed" + + if t.Result <> 3 then + failwith "failed" let merge3tasks () = runtimeTask { @@ -179,7 +205,9 @@ let merge3tasks () = } |> fun t -> t.Wait() - if t.Result <> 6 then failwith "failed" + + if t.Result <> 6 then + failwith "failed" let mergeYieldAndTask () = runtimeTask { @@ -189,7 +217,9 @@ let mergeYieldAndTask () = } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let mergeTaskAndYield () = runtimeTask { @@ -199,7 +229,9 @@ let mergeTaskAndYield () = } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let merge2valueTasks () = runtimeTask { @@ -209,7 +241,9 @@ let merge2valueTasks () = } |> fun t -> t.Wait() - if t.Result <> 3 then failwith "failed" + + if t.Result <> 3 then + failwith "failed" let merge2valueTasksAndYield () = runtimeTask { @@ -220,7 +254,9 @@ let merge2valueTasksAndYield () = } |> fun t -> t.Wait() - if t.Result <> 3 then failwith "failed" + + if t.Result <> 3 then + failwith "failed" let mergeYieldAnd2tasks () = runtimeTask { @@ -231,7 +267,9 @@ let mergeYieldAnd2tasks () = } |> fun t -> t.Wait() - if t.Result <> 3 then failwith "failed" + + if t.Result <> 3 then + failwith "failed" let merge2tasksAndValueTask () = runtimeTask { @@ -242,7 +280,9 @@ let merge2tasksAndValueTask () = } |> fun t -> t.Wait() - if t.Result <> 6 then failwith "failed" + + if t.Result <> 6 then + failwith "failed" let merge2asyncs () = runtimeTask { @@ -252,7 +292,9 @@ let merge2asyncs () = } |> fun t -> t.Wait() - if t.Result <> 3 then failwith "failed" + + if t.Result <> 3 then + failwith "failed" let merge3asyncs () = runtimeTask { @@ -263,7 +305,9 @@ let merge3asyncs () = } |> fun t -> t.Wait() - if t.Result <> 6 then failwith "failed" + + if t.Result <> 6 then + failwith "failed" let mergeYieldAndAsync () = runtimeTask { @@ -273,7 +317,9 @@ let mergeYieldAndAsync () = } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let mergeAsyncAndYield () = runtimeTask { @@ -283,7 +329,9 @@ let mergeAsyncAndYield () = } |> fun t -> t.Wait() - if t.Result <> 1 then failwith "failed" + + if t.Result <> 1 then + failwith "failed" let mergeYieldAnd2asyncs () = runtimeTask { @@ -294,7 +342,9 @@ let mergeYieldAnd2asyncs () = } |> fun t -> t.Wait() - if t.Result <> 3 then failwith "failed" + + if t.Result <> 3 then + failwith "failed" let merge2asyncsAndValueTask () = runtimeTask { @@ -305,7 +355,9 @@ let merge2asyncsAndValueTask () = } |> fun t -> t.Wait() - if t.Result <> 6 then failwith "failed" + + if t.Result <> 6 then + failwith "failed" // --------------------------------------------------------------------------- // Basics @@ -318,16 +370,19 @@ let testShortCircuitResult () = let! y = Task.FromResult(2) return x + y } + require t.IsCompleted "didn't short-circuit already completed tasks" require (t.Result = 3) "wrong result" let testDelay () = let mutable x = 0 + let t = runtimeTask { do! Task.Delay(50) x <- x + 1 } + require (x = 0) "task already ran" t.Wait() @@ -339,12 +394,14 @@ let testNonBlocking () = let allowContinue = new SemaphoreSlim(0) let continueToFinish = new ManualResetEventSlim(false) let finished = new ManualResetEventSlim() + let t = runtimeTask { do! allowContinue.WaitAsync() continueToFinish.Wait() finished.Set() } + allowContinue.Release() |> ignore require (not finished.IsSet) "sleep blocked caller" continueToFinish.Set() @@ -355,6 +412,7 @@ let testNonBlocking () = let testCatching1 () = let mutable x = 0 let mutable y = 0 + let t = runtimeTask { try @@ -363,12 +421,12 @@ let testCatching1 () = x <- 1 do! Task.Delay(100) with - | TestException msg -> - require (msg = "hello") "message tampered" - | _ -> - require false "other exn type" + | TestException msg -> require (msg = "hello") "message tampered" + | _ -> require false "other exn type" + y <- 1 } + t.Wait() require (y = 1) "bailed after exn" require (x = 0) "ran past failure" @@ -376,6 +434,7 @@ let testCatching1 () = let testCatching2 () = let mutable x = 0 let mutable y = 0 + let t = runtimeTask { try @@ -384,12 +443,12 @@ let testCatching2 () = x <- 1 do! Task.Delay(100) with - | TestException msg -> - require (msg = "hello") "message tampered" - | _ -> - require false "other exn type" + | TestException msg -> require (msg = "hello") "message tampered" + | _ -> require false "other exn type" + y <- 1 } + t.Wait() require (y = 1) "bailed after exn" require (x = 0) "ran past failure" @@ -397,24 +456,25 @@ let testCatching2 () = let testCatchingInApplicative () = let mutable x = 0 let mutable y = 0 + let t = runtimeTask { try - let! _ = runtimeTask { - do! Task.Delay(100) - x <- 1 - } - and! _ = runtimeTask { - failtest "hello" - } + let! _ = + runtimeTask { + do! Task.Delay(100) + x <- 1 + } + + and! _ = runtimeTask { failtest "hello" } () with - | TestException msg -> - require (msg = "hello") "message tampered" - | _ -> - require false "other exn type" + | TestException msg -> require (msg = "hello") "message tampered" + | _ -> require false "other exn type" + y <- 1 } + t.Wait() require (y = 1) "bailed after exn" require (x = 1) "exit too early" @@ -423,34 +483,35 @@ let testNestedCatching () = let mutable counter = 1 let mutable caughtInner = 0 let mutable caughtOuter = 0 - let t1() = + + let t1 () = runtimeTask { try do! Task.Yield() failtest "hello" - with - | TestException msg as exn -> + with TestException msg as exn -> caughtInner <- counter counter <- counter + 1 raise exn } + let t2 = runtimeTask { try - do! t1() + do! t1 () with | TestException msg as exn -> caughtOuter <- counter raise exn - | e -> - require false (sprintf "invalid msg type %s" e.Message) + | e -> require false (sprintf "invalid msg type %s" e.Message) } + try t2.Wait() require false "ran past failed task wait" - with - | :? AggregateException as exn -> + with :? AggregateException as exn -> require (exn.InnerExceptions.Count = 1) "more than 1 exn" + require (caughtInner = 1) "didn't catch inner" require (caughtOuter = 2) "didn't catch outer" @@ -458,8 +519,10 @@ let testWhileLoopSync () = let t = runtimeTask { let mutable i = 0 + while i < 10 do i <- i + 1 + return i } //t.Wait() no wait required for sync loop @@ -467,183 +530,229 @@ let testWhileLoopSync () = require (t.Result = 10) "didn't do sync while loop properly - wrong result" let testWhileLoopAsyncZeroIteration () = - for i in 1 .. 5 do + for i in 1..5 do let t = runtimeTask { let mutable i = 0 + while i < 0 do i <- i + 1 do! Task.Yield() + return i } + t.Wait() require (t.Result = 0) "didn't do while loop properly" let testWhileLoopAsyncOneIteration () = - for i in 1 .. 5 do + for i in 1..5 do let t = runtimeTask { let mutable i = 0 + while i < 1 do i <- i + 1 do! Task.Yield() + return i } + t.Wait() require (t.Result = 1) "didn't do while loop properly" let testWhileLoopAsync () = - for i in 1 .. 5 do + for i in 1..5 do let t = runtimeTask { let mutable i = 0 + while i < 10 do i <- i + 1 do! Task.Yield() + return i } + t.Wait() require (t.Result = 10) "didn't do while loop properly" let testForLoopA () = - let list = ["a"; "b"; "c"] |> Seq.ofList + let list = [ "a"; "b"; "c" ] |> Seq.ofList + let t = runtimeTask { let mutable x = Unchecked.defaultof<_> let e = list.GetEnumerator() + while e.MoveNext() do x <- e.Current do! Task.Yield() } + t.Wait() let testForLoopComplex () = let mutable disposed = false + let wrapList = - let raw = ["a"; "b"; "c"] |> Seq.ofList - let getEnumerator() = + let raw = [ "a"; "b"; "c" ] |> Seq.ofList + + let getEnumerator () = let raw = raw.GetEnumerator() + { new IEnumerator with member _.MoveNext() = require (not disposed) "moved next after disposal" raw.MoveNext() + member _.Current = require (not disposed) "accessed current after disposal" raw.Current + member _.Current = require (not disposed) "accessed current (boxed) after disposal" box raw.Current + member _.Dispose() = require (not disposed) "disposed twice" disposed <- true raw.Dispose() + member _.Reset() = require (not disposed) "reset after disposal" raw.Reset() } + { new IEnumerable with - member _.GetEnumerator() : IEnumerator = getEnumerator() - member _.GetEnumerator() : IEnumerator = upcast getEnumerator() + member _.GetEnumerator() : IEnumerator = getEnumerator () + member _.GetEnumerator() : IEnumerator = upcast getEnumerator () } + let t = runtimeTask { let mutable index = 0 do! Task.Yield() + for x in wrapList do do! Task.Yield() do! Task.Yield() + match index with | 0 -> require (x = "a") "wrong first value" | 1 -> require (x = "b") "wrong second value" | 2 -> require (x = "c") "wrong third value" | _ -> require false "iterated too far!" + index <- index + 1 do! Task.Yield() do! Task.Yield() + do! Task.Yield() return 1 } + t.Wait() require disposed "never disposed D" require (t.Result = 1) "wrong result" let testForLoopSadPath () = - for i in 1 .. 5 do - let wrapList = ["a"; "b"; "c"] + for i in 1..5 do + let wrapList = [ "a"; "b"; "c" ] + let t = runtimeTask { - let mutable index = 0 + let mutable index = 0 + do! Task.Yield() + + for x in wrapList do do! Task.Yield() - for x in wrapList do - do! Task.Yield() - index <- index + 1 - return 1 + index <- index + 1 + + return 1 } + require (t.Result = 1) "wrong result" let testForLoopSadPathComplex () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = false + let wrapList = - let raw = ["a"; "b"; "c"] |> Seq.ofList - let getEnumerator() = + let raw = [ "a"; "b"; "c" ] |> Seq.ofList + + let getEnumerator () = let raw = raw.GetEnumerator() + { new IEnumerator with member _.MoveNext() = require (not disposed) "moved next after disposal" raw.MoveNext() + member _.Current = require (not disposed) "accessed current after disposal" raw.Current + member _.Current = require (not disposed) "accessed current (boxed) after disposal" box raw.Current + member _.Dispose() = require (not disposed) "disposed twice" disposed <- true raw.Dispose() + member _.Reset() = require (not disposed) "reset after disposal" raw.Reset() } + { new IEnumerable with - member _.GetEnumerator() : IEnumerator = getEnumerator() - member _.GetEnumerator() : IEnumerator = upcast getEnumerator() + member _.GetEnumerator() : IEnumerator = getEnumerator () + member _.GetEnumerator() : IEnumerator = upcast getEnumerator () } + let mutable caught = false + let t = runtimeTask { try let mutable index = 0 do! Task.Yield() + for x in wrapList do do! Task.Yield() + match index with | 0 -> require (x = "a") "wrong first value" | _ -> failtest "uhoh" + index <- index + 1 do! Task.Yield() + do! Task.Yield() return 1 - with - | TestException "uhoh" -> + with TestException "uhoh" -> caught <- true return 2 } + require (t.Result = 2) "wrong result" require caught "didn't catch exception" require disposed "never disposed A" let knownFailing_testExceptionAttachedToTaskWithoutAwait () = - for i in 1 .. 5 do + for i in 1..5 do let mutable ranA = false let mutable ranB = false + let t = runtimeTask { ranA <- true failtest "uhoh" ranB <- true } + require ranA "didn't run immediately" require (not ranB) "ran past exception" require (not (isNull t.Exception)) "didn't capture exception" @@ -651,25 +760,27 @@ let knownFailing_testExceptionAttachedToTaskWithoutAwait () = require (t.Exception.InnerException = TestException "uhoh") "wrong exception" let mutable caught = false let mutable ranCatcher = false + let catcher = runtimeTask { try ranCatcher <- true let! result = t return false - with - | TestException "uhoh" -> + with TestException "uhoh" -> caught <- true return true } + require ranCatcher "didn't run" require catcher.Result "didn't catch" require caught "didn't catch" let knownFailing_testExceptionAttachedToTaskWithAwait () = - for i in 1 .. 5 do + for i in 1..5 do let mutable ranA = false let mutable ranB = false + let t = runtimeTask { ranA <- true @@ -677,6 +788,7 @@ let knownFailing_testExceptionAttachedToTaskWithAwait () = do! Task.Delay(100) ranB <- true } + require ranA "didn't run immediately" require (not ranB) "ran past exception" require (not (isNull t.Exception)) "didn't capture exception" @@ -684,64 +796,76 @@ let knownFailing_testExceptionAttachedToTaskWithAwait () = require (t.Exception.InnerException = TestException "uhoh") "wrong exception" let mutable caught = false let mutable ranCatcher = false + let catcher = runtimeTask { try ranCatcher <- true let! result = t return false - with - | TestException "uhoh" -> + with TestException "uhoh" -> caught <- true return true } + require ranCatcher "didn't run" require catcher.Result "didn't catch" require caught "didn't catch" let testFixedStackWhileLoop () = - for i in 1 .. 100 do + for i in 1..100 do let t = runtimeTask { let mutable maxDepth = Nullable() let mutable i = 0 + while i < BIG do i <- i + 1 do! Task.Yield() + if i % 100 = 0 then let stackDepth = StackTrace().FrameCount + if maxDepth.HasValue && stackDepth > maxDepth.Value then failwith "Stack depth increased!" + maxDepth <- Nullable(stackDepth) + return i } + t.Wait() require (t.Result = BIG) "didn't get to big number" let knownFailing_testFixedStackForLoop () = // needs investigation: code after a suspending for loop is not run - for i in 1 .. 100 do + for i in 1..100 do let mutable ran = false + let t = runtimeTask { let mutable maxDepth = Nullable() + for i in Seq.init BIG id do do! Task.Yield() + if i % 100 = 0 then let stackDepth = StackTrace().FrameCount + if maxDepth.HasValue && stackDepth > maxDepth.Value then failwith "Stack depth increased!" + maxDepth <- Nullable(stackDepth) + ran <- true return () } + t.Wait() require ran "didn't run all" let testTypeInference () = - let t1 : string Task = - runtimeTask { - return "hello" - } + let t1: string Task = runtimeTask { return "hello" } + let t2 = runtimeTask { // Divergence from task {}: the runtimeTask Bind overload set does not @@ -749,22 +873,26 @@ let testTypeInference () = let! (s: string) = t1 return s.Length } + t2.Wait() let testNoStackOverflowWithImmediateResult () = let longLoop = runtimeTask { let mutable n = 0 + while n < BIG do n <- n + 1 return! Task.FromResult(()) } + longLoop.Wait() let testNoStackOverflowWithYieldResult () = let longLoop = runtimeTask { let mutable n = 0 + while n < BIG do let! _ = runtimeTask { @@ -772,8 +900,10 @@ let testNoStackOverflowWithYieldResult () = let! _ = Task.FromResult(0) n <- n + 1 } + n <- n + 1 } + longLoop.Wait() let testSmallTailRecursion () = @@ -786,27 +916,27 @@ let testSmallTailRecursion () = else return () } - let shortLoop = - runtimeTask { - return! loop 0 - } + + let shortLoop = runtimeTask { return! loop 0 } shortLoop.Wait() let testTryOverReturnFrom () = - let inner() = + let inner () = runtimeTask { do! Task.Yield() failtest "inner" return 1 } + let t = runtimeTask { try do! Task.Yield() - return! inner() - with - | TestException "inner" -> return 2 + return! inner () + with TestException "inner" -> + return 2 } + require (t.Result = 2) "didn't catch" let testAsyncsMixedWithTasks () = @@ -814,39 +944,42 @@ let testAsyncsMixedWithTasks () = runtimeTask { do! Task.Delay(1) do! Async.Sleep(1) + let! x = async { do! Async.Sleep(1) return 5 } + return! async { return x + 3 } } + let result = t.Result require (result = 8) "something weird happened" let testAsyncsMixedWithTasks_ShouldNotSwitchContext () = - let t = runtimeTask { - let a = Thread.CurrentThread.ManagedThreadId - let! b = async { - return Thread.CurrentThread.ManagedThreadId + let t = + runtimeTask { + let a = Thread.CurrentThread.ManagedThreadId + let! b = async { return Thread.CurrentThread.ManagedThreadId } + let c = Thread.CurrentThread.ManagedThreadId + return $"Before: {a}, in async: {b}, after async: {c}" } - let c = Thread.CurrentThread.ManagedThreadId - return $"Before: {a}, in async: {b}, after async: {c}" - } + let d = Thread.CurrentThread.ManagedThreadId let actual = $"{t.Result}, after task: {d}" require (actual = $"Before: {d}, in async: {d}, after async: {d}, after task: {d}") actual // no need to call this, we just want to check that it compiles w/o warnings -let testTrivialReturnCompiles (x : 'a) : 'a Task = +let testTrivialReturnCompiles (x: 'a) : 'a Task = runtimeTask { do! Task.Yield() return x } // no need to call this, we just want to check that it compiles w/o warnings -let testTrivialTransformedReturnCompiles (x : 'a) (f : 'a -> 'b) : 'b Task = +let testTrivialTransformedReturnCompiles (x: 'a) (f: 'a -> 'b) : 'b Task = runtimeTask { do! Task.Yield() return f x @@ -855,12 +988,14 @@ let testTrivialTransformedReturnCompiles (x : 'a) (f : 'a -> 'b) : 'b Task = // no need to call this, we just want to check that it compiles w/o warnings let testDefaultInferenceForReturnFrom () = let t = runtimeTask { return Some "x" } + runtimeTask { let! r = t + if r = None then // Divergence from task {}: ReturnFrom is overloaded, so the generic // failwithf result needs an explicit Task<_> annotation. - return! (failwithf "Could not find x" : string option Task) + return! (failwithf "Could not find x": string option Task) else return r } @@ -868,10 +1003,7 @@ let testDefaultInferenceForReturnFrom () = // no need to call this, just check that it compiles let testCompilerInfersArgumentOfReturnFrom () = - runtimeTask { - if true then return 1 - else return! (failwith "" : int Task) - } + runtimeTask { if true then return 1 else return! (failwith "": int Task) } |> ignore // Overload-resolution cases from the bottom of Tasks.fs (Issue12184*), compile-only. @@ -883,10 +1015,7 @@ type Issue12184() = return result } - member _.AsyncMethod(value: int) : Async = - async { - return (value * 2) - } + member _.AsyncMethod(value: int) : Async = async { return (value * 2) } type Issue12184b() = member this.TaskMethod() = @@ -896,29 +1025,28 @@ type Issue12184b() = return result } - member _.AsyncMethod(_value: int) : System.Runtime.CompilerServices.YieldAwaitable = - Task.Yield() + member _.AsyncMethod(_value: int) : System.Runtime.CompilerServices.YieldAwaitable = Task.Yield() // Issue12184c from Tasks.fs is omitted: it relies on task {}'s Bind overload // resolution committing to Task<_> for an unannotated argument, which the // runtimeTask builder's overload set does not support. module Issue12184d = - let TaskMethod(t: ValueTask) = + let TaskMethod (t: ValueTask) = runtimeTask { let! result = t return result } module Issue12184e = - let TaskMethod(t: ValueTask) = + let TaskMethod (t: ValueTask) = runtimeTask { let! result = t return result } module Issue12184f = - let TaskMethod(t: Task) = + let TaskMethod (t: Task) = runtimeTask { let! result = t return result @@ -930,18 +1058,21 @@ module Issue12184f = let knownDivergent_testNoDelay () = let mutable x = 0 + let t = runtimeTask { x <- x + 1 do! Task.Delay(5) x <- x + 1 } + require (x = 1) "first part didn't run yet" t.Wait() let testTryFinallyHappyPath () = - for i in 1 .. 5 do + for i in 1..5 do let mutable ran = false + let t = runtimeTask { try @@ -951,12 +1082,14 @@ let testTryFinallyHappyPath () = finally ran <- true } + t.Wait() require ran "never ran" let testTryFinallySadPath () = - for i in 1 .. 5 do + for i in 1..5 do let mutable ran = false + let t = runtimeTask { try @@ -967,15 +1100,18 @@ let testTryFinallySadPath () = finally ran <- true } + try t.Wait() - with - | _ -> () + with _ -> + () + require ran "never ran" let testTryFinallyCaught () = - for i in 1 .. 5 do + for i in 1..5 do let mutable ran = false + let t = runtimeTask { try @@ -986,94 +1122,127 @@ let testTryFinallyCaught () = failtest "uhoh" finally ran <- true + return 1 - with - | _ -> return 2 + with _ -> + return 2 } + require (t.Result = 2) "wrong return" require ran "never ran" let testUsing () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = false + let t = runtimeTask { - use d = { new IDisposable with member _.Dispose() = disposed <- true } + use d = + { new IDisposable with + member _.Dispose() = disposed <- true + } + require (not disposed) "disposed way early" do! Task.Delay(100) require (not disposed) "disposed kinda early" } + t.Wait() require disposed "never disposed B" let testUsingFromTask () = let mutable disposedInner = false let mutable disposed = false + let t = runtimeTask { use! d = runtimeTask { do! Task.Delay(50) - use i = { new IDisposable with member _.Dispose() = disposedInner <- true } + + use i = + { new IDisposable with + member _.Dispose() = disposedInner <- true + } + require (not disposed && not disposedInner) "disposed inner early" - return { new IDisposable with member _.Dispose() = disposed <- true } + + return + { new IDisposable with + member _.Dispose() = disposed <- true + } } + require disposedInner "did not dispose inner after task completion" require (not disposed) "disposed way early" do! Task.Delay(50) require (not disposed) "disposed kinda early" } + t.Wait() require disposed "never disposed C" let testUsingSadPath () = let mutable disposedInner = false let mutable disposed = false + let t = runtimeTask { try use! d = runtimeTask { do! Task.Delay(50) - use i = { new IDisposable with member _.Dispose() = disposedInner <- true } + + use i = + { new IDisposable with + member _.Dispose() = disposedInner <- true + } + failtest "uhoh" require (not disposed && not disposedInner) "disposed inner early" - return { new IDisposable with member _.Dispose() = disposed <- true } + + return + { new IDisposable with + member _.Dispose() = disposed <- true + } } + () - with - | TestException msg -> + with TestException msg -> require disposedInner "did not dispose inner after task completion" require (not disposed) "disposed way early" do! Task.Delay(50) require (not disposed) "disposed kinda early" } + t.Wait() require (not disposed) "disposed thing that never should've existed" let testUsingAsyncDisposableSync () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = 0 + let t = runtimeTask { use d = { new IAsyncDisposable with member _.DisposeAsync() = - runtimeTask { - disposed <- disposed + 1 } - |> ValueTask + runtimeTask { disposed <- disposed + 1 } |> ValueTask } + require (disposed = 0) "disposed way early" do! Task.Delay(100) require (disposed = 0) "disposed kinda early" } + t.Wait() require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" let testUsingAsyncDisposableAsync () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = 0 + let t = runtimeTask { use d = @@ -1083,18 +1252,22 @@ let testUsingAsyncDisposableAsync () = do! Task.Delay(10) disposed <- disposed + 1 } - |> ValueTask } + |> ValueTask + } + require (disposed = 0) "disposed way early" do! Task.Delay(100) require (disposed = 0) "disposed kinda early" } + t.Wait() require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" let testUsingAsyncDisposableExnAsync () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = 0 + let t = runtimeTask { use d = @@ -1104,20 +1277,23 @@ let testUsingAsyncDisposableExnAsync () = do! Task.Delay(10) disposed <- disposed + 1 } - |> ValueTask } + |> ValueTask + } + require (disposed = 0) "disposed way early" failtest "oops" } + try t.Wait() - with - | :? AggregateException -> + with :? AggregateException -> require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" let testUsingAsyncDisposableExnSync () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = 0 + let t = runtimeTask { use d = @@ -1127,20 +1303,23 @@ let testUsingAsyncDisposableExnSync () = disposed <- disposed + 1 do! Task.Delay(10) } - |> ValueTask } + |> ValueTask + } + require (disposed = 0) "disposed way early" failtest "oops" } + try t.Wait() - with - | :? AggregateException -> + with :? AggregateException -> require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" let testUsingAsyncDisposableDelayExnSync () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = 0 + let t = runtimeTask { use d = @@ -1150,49 +1329,54 @@ let testUsingAsyncDisposableDelayExnSync () = disposed <- disposed + 1 do! Task.Delay(10) } - |> ValueTask } + |> ValueTask + } + require (disposed = 0) "disposed way early" do! Task.Delay(10) require (disposed = 0) "disposed kind of early" failtest "oops" } + try t.Wait() - with - | :? AggregateException -> + with :? AggregateException -> require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" let testUsingBindAsyncDisposableSync () = - for i in 1 .. 5 do + for i in 1..5 do let mutable disposed = 0 + let t = runtimeTask { use! d = runtimeTask { do! Task.Delay(10) + return { new IAsyncDisposable with member _.DisposeAsync() = - runtimeTask { - disposed <- disposed + 1 - } - |> ValueTask } + runtimeTask { disposed <- disposed + 1 } |> ValueTask + } } + require (disposed = 0) "disposed way early" do! Task.Delay(100) require (disposed = 0) "disposed kinda early" } + t.Wait() require (disposed >= 1) "never disposed B" require (disposed <= 1) "too many dispose on B" let testExceptionThrownInFinally () = - for i in 1 .. 5 do + for i in 1..5 do use stepOutside = new SemaphoreSlim(0) use ranInitial = new ManualResetEventSlim() use ranNext = new ManualResetEventSlim() let mutable ranFinally = 0 + let t = runtimeTask { try @@ -1204,23 +1388,27 @@ let testExceptionThrownInFinally () = ranFinally <- ranFinally + 1 failtest "finally exn!" } + require ranInitial.IsSet "didn't run initial" require (not ranNext.IsSet) "ran next too early" stepOutside.Release() |> ignore + try t.Wait() require false "shouldn't get here" - with - | _ -> () + with _ -> + () + require ranNext.IsSet "didn't run next" require (ranFinally = 1) "didn't run finally exactly once" let test2ndExceptionThrownInFinally () = - for i in 1 .. 5 do + for i in 1..5 do use ranInitial = new ManualResetEventSlim() use continueTask = new SemaphoreSlim(0) use ranNext = new ManualResetEventSlim() let mutable ranFinally = 0 + let t = runtimeTask { try @@ -1233,57 +1421,68 @@ let test2ndExceptionThrownInFinally () = ranFinally <- ranFinally + 1 failtest "2nd exn!" } + ranInitial.Wait() continueTask.Release() |> ignore + try t.Wait() require false "shouldn't get here" - with - | _ -> () + with _ -> + () + require ranNext.IsSet "didn't run next" require (ranFinally = 1) "didn't run finally exactly once" let testTryFinallyOverReturnFromWithException () = - let inner() = + let inner () = runtimeTask { do! Task.Yield() failtest "inner" return 1 } + let mutable m = 0 + let t = runtimeTask { try do! Task.Yield() - return! inner() + return! inner () finally m <- 1 } + try t.Wait() - with - | :? AggregateException -> () + with :? AggregateException -> + () + require (m = 1) "didn't run finally" let testTryFinallyOverReturnFromWithoutException () = - let inner() = + let inner () = runtimeTask { do! Task.Yield() return 1 } + let mutable m = 0 + let t = runtimeTask { try do! Task.Yield() - return! inner() + return! inner () finally m <- 1 } + try t.Wait() - with - | :? AggregateException -> () + with :? AggregateException -> + () + require (m = 1) "didn't run finally" // A minimal custom awaitable, exercising the SRTP Bind/ReturnFrom/MergeSources @@ -1298,12 +1497,10 @@ let testCustomAwaitable () = let! y = CustomAwaitable 20 return x + y } + require (t.Result = 40) "custom awaitable bind" - let t2 = - runtimeTask { - return! CustomAwaitable 42 - } + let t2 = runtimeTask { return! CustomAwaitable 42 } require (t2.Result = 42) "custom awaitable return from" let t3 = @@ -1312,19 +1509,28 @@ let testCustomAwaitable () = and! y = CustomAwaitable 22 return x + y } + require (t3.Result = 42) "custom awaitable merge sources" let knownFailing_testTaskUsesSyncContext () = // task completes without the body observably running when a SynchronizationContext is installed - for i in 1 .. 5 do + for i in 1..5 do let mutable ran = false let mutable posted = false let oldSyncContext = SynchronizationContext.Current - let syncContext = { new SynchronizationContext() with member _.Post(d,state) = posted <- true; d.Invoke(state) } + + let syncContext = + { new SynchronizationContext() with + member _.Post(d, state) = + posted <- true + d.Invoke(state) + } + try SynchronizationContext.SetSynchronizationContext syncContext let tid = System.Threading.Thread.CurrentThread.ManagedThreadId require (not (isNull SynchronizationContext.Current)) "need sync context non null on foreground thread A" require (SynchronizationContext.Current = syncContext) "need sync context known on foreground thread A" + let t = runtimeTask { let tid2 = System.Threading.Thread.CurrentThread.ManagedThreadId @@ -1335,6 +1541,7 @@ let knownFailing_testTaskUsesSyncContext () = // task completes without the body require (SynchronizationContext.Current = syncContext) "need sync context known on foreground thread C" ran <- true } + t.Wait() require ran "never ran" require posted "never posted" @@ -1343,69 +1550,69 @@ let knownFailing_testTaskUsesSyncContext () = // task completes without the body [] let main _ = - tinyTask() - tbind() - tnested() - tcatch0() - tcatch1() - t3() - t3b() - t3c() - t67() - t68() - testCompileAsyncWhileLoop() - merge2tasks() - merge3tasks() - mergeYieldAndTask() - mergeTaskAndYield() - merge2valueTasks() - merge2valueTasksAndYield() - mergeYieldAnd2tasks() - merge2tasksAndValueTask() - merge2asyncs() - merge3asyncs() - mergeYieldAndAsync() - mergeAsyncAndYield() - mergeYieldAnd2asyncs() - merge2asyncsAndValueTask() - testShortCircuitResult() - testDelay() - testNonBlocking() - testCatching1() - testCatching2() - testCatchingInApplicative() - testNestedCatching() - testWhileLoopSync() - testWhileLoopAsyncZeroIteration() - testWhileLoopAsyncOneIteration() - testWhileLoopAsync() - testForLoopA() - testForLoopComplex() - testForLoopSadPath() - testForLoopSadPathComplex() - testFixedStackWhileLoop() - testTypeInference() - testNoStackOverflowWithImmediateResult() - testNoStackOverflowWithYieldResult() - testSmallTailRecursion() - testTryOverReturnFrom() - testTryFinallyOverReturnFromWithException() - testTryFinallyOverReturnFromWithoutException() - testAsyncsMixedWithTasks() - testAsyncsMixedWithTasks_ShouldNotSwitchContext() - testCustomAwaitable() - testUsingAsyncDisposableSync() - testUsingAsyncDisposableAsync() - testUsingAsyncDisposableExnAsync() - testUsingAsyncDisposableExnSync() - testUsingAsyncDisposableDelayExnSync() - testUsingBindAsyncDisposableSync() - testTryFinallyHappyPath() - testTryFinallySadPath() - testTryFinallyCaught() - testUsing() - testUsingFromTask() - testUsingSadPath() - testExceptionThrownInFinally() - test2ndExceptionThrownInFinally() + tinyTask () + tbind () + tnested () + tcatch0 () + tcatch1 () + t3 () + t3b () + t3c () + t67 () + t68 () + testCompileAsyncWhileLoop () + merge2tasks () + merge3tasks () + mergeYieldAndTask () + mergeTaskAndYield () + merge2valueTasks () + merge2valueTasksAndYield () + mergeYieldAnd2tasks () + merge2tasksAndValueTask () + merge2asyncs () + merge3asyncs () + mergeYieldAndAsync () + mergeAsyncAndYield () + mergeYieldAnd2asyncs () + merge2asyncsAndValueTask () + testShortCircuitResult () + testDelay () + testNonBlocking () + testCatching1 () + testCatching2 () + testCatchingInApplicative () + testNestedCatching () + testWhileLoopSync () + testWhileLoopAsyncZeroIteration () + testWhileLoopAsyncOneIteration () + testWhileLoopAsync () + testForLoopA () + testForLoopComplex () + testForLoopSadPath () + testForLoopSadPathComplex () + testFixedStackWhileLoop () + testTypeInference () + testNoStackOverflowWithImmediateResult () + testNoStackOverflowWithYieldResult () + testSmallTailRecursion () + testTryOverReturnFrom () + testTryFinallyOverReturnFromWithException () + testTryFinallyOverReturnFromWithoutException () + testAsyncsMixedWithTasks () + testAsyncsMixedWithTasks_ShouldNotSwitchContext () + testCustomAwaitable () + testUsingAsyncDisposableSync () + testUsingAsyncDisposableAsync () + testUsingAsyncDisposableExnAsync () + testUsingAsyncDisposableExnSync () + testUsingAsyncDisposableDelayExnSync () + testUsingBindAsyncDisposableSync () + testTryFinallyHappyPath () + testTryFinallySadPath () + testTryFinallyCaught () + testUsing () + testUsingFromTask () + testUsingSadPath () + testExceptionThrownInFinally () + test2ndExceptionThrownInFinally () 0 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs index b3ee6986e6c..8e0b9188ede 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasksAsyncDisposalException.fs @@ -17,8 +17,7 @@ let runCatch () : Task = StateMachineHelpers.__runtimeAsyncReturn ( try failwith "boom" - with - | _ -> + with _ -> AsyncHelpers.Await(Task.Delay(1)) 2 ) @@ -28,11 +27,12 @@ let runFilter () : Task = try try raise (System.InvalidOperationException()) - with - | :? System.InvalidOperationException when (AsyncHelpers.Await(Task.Delay(1)); false) -> + with :? System.InvalidOperationException when + (AsyncHelpers.Await(Task.Delay(1)) + false) -> 2 - with - | :? System.InvalidOperationException -> 3 + with :? System.InvalidOperationException -> + 3 ) [] @@ -40,9 +40,12 @@ let main _ = let first = run () let second = runCatch () let third = runFilter () + let results = - [| first.GetAwaiter().GetResult() - second.GetAwaiter().GetResult() - third.GetAwaiter().GetResult() |] + [| + first.GetAwaiter().GetResult() + second.GetAwaiter().GetResult() + third.GetAwaiter().GetResult() + |] if results = [| 1; 2; 3 |] then 0 else 1 From 8880d1eb575063cc00444b2f28a074ffe1471ec5 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Sun, 30 Aug 2026 10:50:51 +0200 Subject: [PATCH 37/59] Refactor runtime async optimizer helpers --- src/Compiler/Optimize/Optimizer.fs | 128 ++++-------------- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 102 ++++++++++++++ 2 files changed, 129 insertions(+), 101 deletions(-) diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index a929aa5d4a0..5c6ebffd590 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2522,62 +2522,6 @@ let shouldForceInlineInDebug cenv env (vref: ValRef) : bool = HasFrameLocalBody cenv env vref -let rec private HasRuntimeAsyncFragmentBody cenv env visiting (vref: ValRef) = - if List.exists ((=) vref.Stamp) visiting then - false - else - match TryGetInfoForVal cenv env vref |> Option.map (fun info -> stripValue info.ValExprInfo) with - | Some(CurriedLambdaValue (_, _, _, body, _)) -> - ExprContainsRuntimeAsyncFragment cenv env (vref.Stamp :: visiting) body - | _ -> - false - -and private ExprContainsRuntimeAsyncFragment cenv env visiting expr = - let folder = - { ExprFolder0 with - exprIntercept = - fun _ noInterceptF acc expr -> - if acc then - true - else - match stripExpr expr with - | Expr.App(Expr.Val(RuntimeAsyncReturn cenv.g, _, _), _, _, _, _) -> - true - | _ when IsRuntimeAsyncSuspensionExpr cenv.g expr -> - true - | Expr.Val(vref, _, _) when vref.ShouldInline || vref.IsLocalRef -> - HasRuntimeAsyncFragmentBody cenv env visiting vref - | _ -> - noInterceptF acc expr } - - FoldExpr folder false expr - -let private ShouldForceRuntimeAsyncInline cenv env (vref: ValRef) (finfo: Summary) = - if env.runtimeAsyncContext && vref.InlineIfLambda && not vref.ShouldInline then - true - elif not (vref.ShouldInline || vref.IsLocalRef) then - false - else - match stripValue finfo.Info with - | CurriedLambdaValue (_, _, _, body, _) -> - ExprContainsRuntimeAsyncFragment cenv env [ vref.Stamp ] body - | _ -> - HasRuntimeAsyncFragmentBody cenv env [] vref - -let private ShouldForceRuntimeAsyncApplication cenv env vref finfo args = - ShouldForceRuntimeAsyncInline cenv env vref finfo - || ((vref.ShouldInline || vref.InlineIfLambda) - && List.exists (ExprContainsRuntimeAsyncFragment cenv env []) args) - || (env.runtimeAsyncContext - && vref.ShouldInline - && List.exists - (fun arg -> - match stripExpr arg with - | Expr.Lambda _ - | Expr.TyLambda _ -> true - | _ -> false) - args) - /// Optimize/analyze an expression let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = cenv.stackGuard.Guard <| fun () -> @@ -2879,47 +2823,6 @@ and OptimizeExprOp cenv env (op, tyargs, args, m) = // Reductions OptimizeExprOpReductions cenv env (op, tyargs, args, m) -and InlineRuntimeAsyncLambdaArgument cenv env expr = - let g = cenv.g - let inlineBinding (boundVal: Val) boundExpr body = - let rwenv = - { PreIntercept = - Some(fun _ expr -> - match stripExpr expr with - | Expr.Val(vref, _, _) when valEq boundVal vref.Deref -> - Some(copyExpr g CloneAll boundExpr) - | _ -> - None) - PreInterceptBinding = None - PostTransform = fun _ -> None - RewriteQuotations = false - StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") } - - RewriteExpr rwenv body - - let rwenv = - { PreIntercept = - Some(fun cont expr -> - match stripExpr expr with - | Expr.Let(TBind(boundVal, boundExpr, _), body, _, _) - when boundVal.InlineIfLambda - || ((match stripExpr boundExpr with - | Expr.Lambda _ - | Expr.TyLambda _ -> - true - | _ -> - false) - && ExprContainsRuntimeAsyncFragment cenv env [] boundExpr) -> - Some(cont (inlineBinding boundVal boundExpr body)) - | _ -> - None) - PreInterceptBinding = None - PostTransform = fun _ -> None - RewriteQuotations = false - StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") } - - RewriteExpr rwenv expr - and OptimizeExprOpReductions cenv env (op, tyargs, args, m) = let argsR, arginfos = OptimizeExprsThenConsiderSplits cenv env args OptimizeExprOpReductionsAfter cenv env (op, tyargs, argsR, arginfos, m) @@ -3774,14 +3677,37 @@ and TryDevirtualizeApplication cenv env (f, tyargs, args, m) = /// Attempt to inline an application of a known value at callsites and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, args: Expr list, m) = let g = cenv.g + let getRuntimeAsyncLambdaBody (vref: ValRef) = + TryGetInfoForVal cenv env vref + |> Option.map (fun info -> stripValue info.ValExprInfo) + |> Option.bind (function + | CurriedLambdaValue (_, _, _, body, _) -> Some body + | _ -> None) + + let inlineBody = + match stripValue finfo.Info with + | CurriedLambdaValue (_, _, _, body, _) -> Some body + | _ -> None + + let containsRuntimeAsyncFragment = ExprContainsRuntimeAsyncFragment g getRuntimeAsyncLambdaBody + let mustInlineRuntimeAsync = + match stripExpr valExpr with + | Expr.Val(vref, _, _) -> + ShouldForceRuntimeAsyncApplication + g + env.runtimeAsyncContext + getRuntimeAsyncLambdaBody + vref + inlineBody + args + | _ -> false match cenv.settings.alwaysInline, stripExpr valExpr with | alwaysInline, Expr.Val(vref, _, _) - when ShouldForceRuntimeAsyncApplication cenv env vref finfo args + when mustInlineRuntimeAsync || (not alwaysInline && vref.ShouldInline && not (shouldForceInlineInDebug cenv env vref)) -> - let mustInlineRuntimeAsync = ShouldForceRuntimeAsyncApplication cenv env vref finfo args let hasNoTraits = let tps, _ = tryDestForallTy g vref.Type GetTraitConstraintInfosOfTypars g tps |> List.isEmpty @@ -3913,7 +3839,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg match reduced with | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) | _ -> reduced - let reduced = InlineRuntimeAsyncLambdaArgument cenv env reduced + let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced let reduced = if ExprContainsRuntimeAsyncSuspension g reduced then fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) @@ -3953,7 +3879,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg match reduced with | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) | _ -> reduced - let reduced = InlineRuntimeAsyncLambdaArgument cenv env reduced + let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced let reduced = if ExprContainsRuntimeAsyncSuspension g reduced then fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index fded781d0ca..75ff8dce081 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -7,14 +7,116 @@ open Internal.Utilities.Library open Internal.Utilities.Library.Extras open FSharp.Compiler +open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.TcGlobals open FSharp.Compiler.Text open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics open FSharp.Compiler.TypedTreeOps open FSharp.Compiler.TypeRelations open FSharp.Compiler.RuntimeAsync +let rec private hasRuntimeAsyncFragmentBody (g: TcGlobals) (getLambdaBody: ValRef -> Expr option) visiting (vref: ValRef) = + if List.exists ((=) vref.Stamp) visiting then + false + else + match getLambdaBody vref with + | Some body -> exprContainsRuntimeAsyncFragment g getLambdaBody (vref.Stamp :: visiting) body + | None -> false + +and private exprContainsRuntimeAsyncFragment (g: TcGlobals) (getLambdaBody: ValRef -> Expr option) visiting expr = + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc then + true + else + match stripExpr expr with + | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, _, _, _) -> true + | _ when IsRuntimeAsyncSuspensionExpr g expr -> true + | Expr.Val(vref, _, _) when vref.ShouldInline || vref.IsLocalRef -> + hasRuntimeAsyncFragmentBody g getLambdaBody visiting vref + | _ -> noInterceptF acc expr + } + + FoldExpr folder false expr + +let ExprContainsRuntimeAsyncFragment (g: TcGlobals) (getLambdaBody: ValRef -> Expr option) expr = + exprContainsRuntimeAsyncFragment g getLambdaBody [] expr + +let ShouldForceRuntimeAsyncInline (g: TcGlobals) runtimeAsyncContext (getLambdaBody: ValRef -> Expr option) (vref: ValRef) inlineBody = + if runtimeAsyncContext && vref.InlineIfLambda && not vref.ShouldInline then + true + elif not (vref.ShouldInline || vref.IsLocalRef) then + false + else + match inlineBody with + | Some body -> ExprContainsRuntimeAsyncFragment g getLambdaBody body + | None -> hasRuntimeAsyncFragmentBody g getLambdaBody [] vref + +let ShouldForceRuntimeAsyncApplication + (g: TcGlobals) + runtimeAsyncContext + (getLambdaBody: ValRef -> Expr option) + (vref: ValRef) + inlineBody + args + = + ShouldForceRuntimeAsyncInline g runtimeAsyncContext getLambdaBody vref inlineBody + || ((vref.ShouldInline || vref.InlineIfLambda) + && List.exists (ExprContainsRuntimeAsyncFragment g getLambdaBody) args) + || (runtimeAsyncContext + && vref.ShouldInline + && List.exists + (fun arg -> + match stripExpr arg with + | Expr.Lambda _ + | Expr.TyLambda _ -> true + | _ -> false) + args) + +let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Expr -> bool) expr = + let inlineBinding (boundVal: Val) boundExpr body = + let rwenv = + { + PreIntercept = + Some(fun _ expr -> + match stripExpr expr with + | Expr.Val(vref, _, _) when valEq boundVal vref.Deref -> Some(copyExpr g CloneAll boundExpr) + | _ -> None) + PreInterceptBinding = None + PostTransform = fun _ -> None + RewriteQuotations = false + StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") + } + + RewriteExpr rwenv body + + let rwenv = + { + PreIntercept = + Some(fun cont expr -> + match stripExpr expr with + | Expr.Let(TBind(boundVal, boundExpr, _), body, _, _) when + boundVal.InlineIfLambda + || ((match stripExpr boundExpr with + | Expr.Lambda _ + | Expr.TyLambda _ -> true + | _ -> false) + && isRuntimeAsyncFragment boundExpr) + -> + Some(cont (inlineBinding boundVal boundExpr body)) + | _ -> None) + PreInterceptBinding = None + PostTransform = fun _ -> None + RewriteQuotations = false + StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") + } + + RewriteExpr rwenv expr + type private RuntimeAsyncFlowSummary = { MaySuspend: bool From b14385a33162b14f37ad80d7fb6daf187ace26ec Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 1 Sep 2026 15:13:42 +0200 Subject: [PATCH 38/59] Fix runtime async fragment fusion --- src/Compiler/Optimize/Optimizer.fs | 25 ++-- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 74 ++++++++++- .../Language/RuntimeAsyncTests.fs | 125 ++++++++++++++++++ 3 files changed, 207 insertions(+), 17 deletions(-) diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index 719bee085c0..40075378f10 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -3690,6 +3690,17 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | _ -> None let containsRuntimeAsyncFragment = ExprContainsRuntimeAsyncFragment g getRuntimeAsyncLambdaBody + let reoptimizeRuntimeAsync reduced = + let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced + + let reduced = + if containsRuntimeAsyncFragment reduced then + fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) + else + reduced + + InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced + let mustInlineRuntimeAsync = match stripExpr valExpr with | Expr.Val(vref, _, _) -> @@ -3839,12 +3850,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg match reduced with | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) | _ -> reduced - let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced - let reduced = - if ExprContainsRuntimeAsyncSuspension g reduced then - fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) - else - reduced + let reduced = reoptimizeRuntimeAsync reduced Some(reduced, info) else @@ -3879,12 +3885,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg match reduced with | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) | _ -> reduced - let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced - let reduced = - if ExprContainsRuntimeAsyncSuspension g reduced then - fst (OptimizeExpr cenv { env with runtimeAsyncContext = true } reduced) - else - reduced + let reduced = reoptimizeRuntimeAsync reduced Some(reduced, info) else // Static method path (no witnesses needed): abstract over free typars so IlxGen emits diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index 75ff8dce081..20d4059b89f 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -78,16 +78,80 @@ let ShouldForceRuntimeAsyncApplication args) let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Expr -> bool) expr = + let rec stripLambdaDebugPoints expr = + match expr with + | Expr.DebugPoint(_, innerExpr) -> + match stripDebugPoints innerExpr with + | Expr.Lambda _ + | Expr.TyLambda _ -> stripLambdaDebugPoints innerExpr + | _ -> expr + | Expr.Lambda(unique, ctorThisValOpt, baseValOpt, valParams, bodyExpr, m, overallType) -> + match bodyExpr with + | Expr.DebugPoint(_, innerExpr) -> + match stripDebugPoints innerExpr with + | Expr.Lambda _ + | Expr.TyLambda _ -> + Expr.Lambda(unique, ctorThisValOpt, baseValOpt, valParams, stripLambdaDebugPoints bodyExpr, m, overallType) + | _ -> expr + | _ -> expr + | Expr.TyLambda(unique, typeParams, bodyExpr, m, overallType) -> + match bodyExpr with + | Expr.DebugPoint(_, innerExpr) -> + match stripDebugPoints innerExpr with + | Expr.Lambda _ + | Expr.TyLambda _ -> Expr.TyLambda(unique, typeParams, stripLambdaDebugPoints bodyExpr, m, overallType) + | _ -> expr + | _ -> expr + | _ -> expr + + let rec betaReduceLambdaApplication expr = + let rec apply f fty tyargs args m = + match args with + | [] -> None + | firstArg :: rest -> + let f = stripLambdaDebugPoints f + + match f with + | Expr.Let(bind, body, mLet, _) -> apply body (tyOfExpr g body) tyargs args m |> Option.map (mkLetBind mLet bind) + | Expr.Lambda(_, _, _, valParams, _, _, _) when valParams.Length = 1 && not rest.IsEmpty -> + let reduced = MakeApplicationAndBetaReduce g (f, fty, [ tyargs ], [ firstArg ], m) + + match reduced with + | Expr.Let(bind, body, mLet, _) -> + match apply body (tyOfExpr g body) [] rest m with + | Some bodyR -> Some(mkLetBind mLet bind bodyR) + | None -> Some(mkAppsAux g reduced (tyOfExpr g reduced) [] rest m) + | _ -> Some reduced + | Expr.Lambda _ + | Expr.TyLambda _ -> Some(MakeApplicationAndBetaReduce g (f, fty, [ tyargs ], args, m)) + | _ -> None + + match stripDebugPoints expr with + | Expr.App(f, fty, tyargs, args, m) -> apply f fty tyargs args m + | _ -> None + let inlineBinding (boundVal: Val) boundExpr body = let rwenv = { PreIntercept = Some(fun _ expr -> - match stripExpr expr with - | Expr.Val(vref, _, _) when valEq boundVal vref.Deref -> Some(copyExpr g CloneAll boundExpr) - | _ -> None) + match betaReduceLambdaApplication expr with + | Some reduced -> Some reduced + | None -> + match stripExpr expr with + | Expr.App(f, _, tyargs, args, m) -> + match stripDebugPoints f with + | Expr.Val(vref, _, _) when valEq boundVal vref.Deref -> + Some( + MakeApplicationAndBetaReduce + g + (copyExpr g CloneAll boundExpr, tyOfExpr g boundExpr, [ tyargs ], args, m) + ) + | _ -> None + | Expr.Val(vref, _, _) when valEq boundVal vref.Deref -> Some(copyExpr g CloneAll boundExpr) + | _ -> None) PreInterceptBinding = None - PostTransform = fun _ -> None + PostTransform = betaReduceLambdaApplication RewriteQuotations = false StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") } @@ -110,7 +174,7 @@ let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Exp Some(cont (inlineBinding boundVal boundExpr body)) | _ -> None) PreInterceptBinding = None - PostTransform = fun _ -> None + PostTransform = betaReduceLambdaApplication RewriteQuotations = false StackGuard = StackGuard("InlineRuntimeAsyncLambdaArgument") } diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 5a1b693937c..382eb9700d0 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -197,6 +197,131 @@ let main _ = |> compileExeAndRun |> shouldSucceed +[] +let ``runtime async supports inlining of a lambda`` () = + FSharp """ +module RuntimeAsyncInlineLambdaTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers + +let inline makeFragment () = + fun x -> + AsyncHelpers.Await (Task.Delay 1000) + printfn "Hello from async function with input: %d" x + +let inline consume([] f) = + __runtimeAsyncReturn(f 42) + +[] +let main _ = + consume (makeFragment()) |> _.Result |> ignore + 0 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async supports inlining of a multi argument lambda`` () = + FSharp """ +module RuntimeAsyncInlineMultiArgumentLambdaTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers + +let inline makeFragment () = + fun x y -> + AsyncHelpers.Await (Task.Delay 1) + x + y + +let inline consume([] f) = + __runtimeAsyncReturn(f 40 2) + +[] +let main _ = + if (consume (makeFragment())).Result <> 42 then 1 else 0 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async fuses suspension in inline returned closures`` () = + FSharp """ +module RuntimeAsyncInlineReturnedClosureTest + +open System +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +type Code = obj -> unit + +type Builder() = + member inline _.Delay([] generator: unit -> Code) : Code = + fun state -> generator() state + + member inline _.Zero() : Code = + fun _ -> () + + member inline _.Yield(_: int) : Code = + fun _ -> () + + member inline _.Bind(task: Task, [] continuation: unit -> Code) : Code = + fun state -> + AsyncHelpers.Await task + continuation() state + + member inline _.Combine(first: Code, [] second: Code) : Code = + fun state -> + first state + second state + + member inline _.Run([] code: Code) : Task = + StateMachineHelpers.__runtimeAsyncReturnUnit (code null) + +[] +let main _ = + let builder = Builder() + builder { + yield 1 + do! Task.Delay(1) + } + |> _.Wait() + 0 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async ignores unreachable suspension`` () = + FSharp """ +module RuntimeAsyncUnreachableSuspensionTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices + +let f () = + if false then + AsyncHelpers.Await (Task.Delay 1) + +[] +let main _ = + f () + 0 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compileExeAndRun + |> shouldSucceed + [] let ``runtime async combines awaited chunks without delegates`` () = FSharp runtimeAsyncRawSource From 3ca8b3d8d3bddc53096b4c9be1f6a89a8b6d524d Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 1 Sep 2026 15:20:39 +0200 Subject: [PATCH 39/59] Synchronize runtime async documentation --- docs/runtime-async.md | 98 ++++++++++++++++++++++++++++--------------- 1 file changed, 64 insertions(+), 34 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index e323591af4d..8db8fe78a8e 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -17,9 +17,9 @@ implemented, not an aspirational design. The .NET design is still evolving: how C# lowers `await` (including the exception-handling hoisting described below) The implementation targets functions, lambdas, and members returning -`System.Threading.Tasks.Task<'T>`. A computation-expression builder exists in -the component tests and works for a subset of the surface, but is not part of -FSharp.Core. +`System.Threading.Tasks.Task<'T>`, `Task`, `ValueTask<'T>`, or `ValueTask`. A +computation-expression builder exists in the component tests and works for a +subset of the surface, but is not part of FSharp.Core. ## Runtime contract @@ -27,13 +27,14 @@ Runtime-async methods are CIL methods marked with `MethodImplOptions.Async` (`0x2000`). The runtime, rather than a compiler generated state machine and method builder, owns suspension and resumption. -Only the generic return shape `System.Threading.Tasks.Task<'T>` is supported. -Non-generic `Task` and `ValueTask`/`ValueTask<'T>` returns are not. +The compiler provides a return intrinsic for each of these carrier shapes: +generic and non-generic `Task`, and generic and non-generic `ValueTask`. Suspension is explicit, via `System.Runtime.CompilerServices.AsyncHelpers`: * `Await` for `Task`, `ValueTask`, and configured awaitables -* `AwaitAwaiter` for awaiters (used by the test builder's SRTP `Bind`) +* `AwaitAwaiter` and `UnsafeAwaitAwaiter` for awaiters (used by the test + builder's SRTP `Bind`) The compiler emits the adjacent IL sequence the runtime specification expects: @@ -68,18 +69,21 @@ are treated as templates and checked at their eventual use site. ## F# surface -The source-level marker is the compiler intrinsic -`Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers.__runtimeAsyncReturn`, -available from the `net10.0` FSharp.Core target, -declared in `resumable.fsi` alongside the other compiler intrinsics: +The source-level markers are compiler intrinsics on +`Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers`, available from +the `net10.0` FSharp.Core target and declared in `resumable.fsi` alongside the +other compiler intrinsics: ```fsharp val __runtimeAsyncReturn<'T> : 'T -> System.Threading.Tasks.Task<'T> +val __runtimeAsyncReturnValueTask<'T> : 'T -> System.Threading.Tasks.ValueTask<'T> +val __runtimeAsyncReturnUnit : unit -> System.Threading.Tasks.Task +val __runtimeAsyncReturnValueTaskUnit : unit -> System.Threading.Tasks.ValueTask ``` -Its FSharp.Core implementation throws; the compiler consumes every -occurrence before code generation, so the body is never executed. It is -marked `NoInlining` so a missed consumption does not silently fold into a +Their FSharp.Core implementations throw; the compiler consumes every +occurrence before code generation, so those bodies are never executed. They +are marked `NoInlining` so a missed consumption does not silently fold into a caller. The feature is gated on `langversion:preview` @@ -105,30 +109,28 @@ type C() = let answer : Task = __runtimeAsyncReturn 42 ``` -There is no implicit awaiting: the argument of `__runtimeAsyncReturn` is checked -as the logical `'T` result, and flattening requires an explicit +There is no implicit awaiting: the argument of a generic return marker is +checked as the logical `'T` result, and flattening requires an explicit `AsyncHelpers.Await`. ## Type checking -`__runtimeAsyncReturn` is an ordinary generic value in the typed tree; no new -expression node or `Val` flag is added. Type checking special-cases its -application in two places in `CheckExpressions.fs`: +The return intrinsics are ordinary values in the typed tree; no new expression +node or `Val` flag is added. Type checking special-cases their applications in +two places in `CheckExpressions.fs`: * `Propagate` skips function-type propagation for the intrinsic so the argument is not checked against a function domain. * `TcApplicationThen` (`tryTcRuntimeAsyncApplication`) recognises the intrinsic (possibly type-applied), gates the language feature and runtime - capability, extracts the result type `'T` from the intrinsic's own - instantiated signature `'T -> Task<'T>`, and checks the argument against - `'T` with `TcExprFlex2`. The result type of the application is `Task<'T>`, - which unifies with the declared return type of the enclosing binding in - the usual way. A non-`Task<'T>` declared return type therefore fails with - the ordinary FS0001 type-mismatch error. + capability, extracts the result carrier and argument type from the + intrinsic's instantiated signature, and checks the argument with + `TcExprFlex2`. The result carrier then unifies with the declared return + type of the enclosing binding in the usual way. -User code that defines its own `__runtimeAsyncReturn` is unaffected: the intrinsic -is only recognised when the `ValRef` resolves (via `valRefEq`) to the -FSharp.Core declaration. +User code that defines its own same-named marker is unaffected: the intrinsic is +only recognised when the `ValRef` resolves (via `valRefEq`) to the FSharp.Core +declaration. ## Optimization @@ -139,15 +141,26 @@ the optimizer never inlines, duplicates, or discards it. The marker therefore survives optimization as an ordinary `Expr.App` node; nothing else in the typed tree records that a method is runtime-async. -Inline values whose bodies contain the marker or an `AsyncHelpers` suspension -are recursively specialized at their call sites, including when optimization -is disabled. The optimizer follows nested inline calls and does not create a -generated helper method for the specialized suspension fragment, keeping every -suspension in the eventual runtime-async method. +Inline values whose bodies contain a return marker or an `AsyncHelpers` +suspension are recursively specialized at their call sites, including when +optimization is disabled. The analysis follows inline and local values with a +cycle guard, and `InlineIfLambda` arguments are forced through when the caller +is already in a runtime-async context. The optimizer follows nested inline +calls and does not create a generated helper method for the specialized +suspension fragment, keeping every suspension in the eventual runtime-async +method. + +After specialization, lambda arguments are substituted and their applications +are beta-reduced before and after runtime-async reoptimization. This includes +debug-point-wrapped lambdas, curried applications, and multi-argument lambdas. +That step is required for computation-expression shapes where `Bind` returns a +closure containing `Await`, and later `Combine`/`Delay` calls apply that closure. +Dead branches eliminated by optimization do not reach code generation and do +not produce a suspension-outside-runtime-async diagnostic. ## Code generation -`IlxGen.fs` recognises the marker in three placements +`IlxGen.fs` recognises the return-marker family in three placements (`TryUnwrapRuntimeAsyncReturnExpr`, which strips `DebugPoint` wrappers): 1. **Method body** (`GenMethodForBinding`): the marker is unwrapped from the @@ -184,6 +197,12 @@ copies. `LowerLocalMutables` therefore treats the marker argument as a lambda body (`DecideExpr`), promoting its free mutable locals to reference cells so the synthesized closure and the enclosing scope share them. +`InvokeFast` is not a separate runtime-async path. It is the closure-erasure +shape for an indirect call with multiple arguments. Fragment substitution and +beta reduction happen before closure erasure; if a suspending fragment survives +until an indirect `InvokeFast` call, it is still outside a runtime-async method +and is rejected by code generation. + ## Runtime capability check `InfoReader` gates `LanguageFeature.RuntimeAsync` on the target reference @@ -207,6 +226,9 @@ Tests live in `tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync*`: * Execution tests (`RuntimeAsyncBasic.fs`, `RuntimeTasks.fs` with the shared `RuntimeTaskBuilder.fs`) run with `compileExeAndRun`, so they compile with the compiler under test and execute on the host runtime. +* Inline-fragment tests cover single- and multi-argument lambdas, returned + closures composed through `Bind`/`Combine`/`Delay`, and suspension in a + branch that is eliminated before code generation. * `RuntimeTasksAsyncDisposalException.fs` documents the known EH-region-suspension crash: it is compiled but not executed. @@ -244,11 +266,19 @@ Two `task {}` inference behaviors are not matched by the overload set: element-type propagation through `Bind` without an annotation, and unannotated `return! failwith ...` (both need explicit annotations in the port). +### Unsupported inline-fragment positions + +An inline fragment that escapes as a first-class value, is passed to a +non-inline function, or is dynamically dispatched cannot be preserved as a +runtime-async suspension fragment. If the suspension remains in the generated +non-runtime-async method, code generation reports FS3916 rather than emitting +an unsafe closure. Fragments in statically eliminated branches do not trigger +this diagnostic. + ## Not yet implemented * Diagnostics for suspension in exception-handling regions, `tail.`, and `localloc`. -* Non-generic `Task` and `ValueTask`/`ValueTask<'T>` return shapes. * Any FSharp.Core builder (the test builder is test-only). * Compile-time enforcement that the marker was actually consumed before code generation (a missed marker throws only when its FSharp.Core stub is From e999079a8961545a0723c11bfbe8fe97ba0c7f96 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 1 Sep 2026 22:41:36 +0200 Subject: [PATCH 40/59] fix merge --- src/Compiler/FSComp.txt | 1 - src/Compiler/Facilities/LanguageFeatures.fs | 2 -- src/Compiler/Facilities/LanguageFeatures.fsi | 1 - 3 files changed, 4 deletions(-) diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt index d3c3b0df33c..09cc8a55de4 100644 --- a/src/Compiler/FSComp.txt +++ b/src/Compiler/FSComp.txt @@ -1564,7 +1564,6 @@ featureFromEndSlicing,"from-end slicing" featureNullnessChecking,"nullness checking" featureResumableStateMachines,"resumable state machines" featureRuntimeAsync,"runtime async" -featureNullableOptionalInterop,"nullable optional interop" featureDefaultInterfaceMemberConsumption,"default interface member consumption" featureStringInterpolation,"string interpolation" featureWitnessPassing,"witness passing for trait constraints in F# quotations" diff --git a/src/Compiler/Facilities/LanguageFeatures.fs b/src/Compiler/Facilities/LanguageFeatures.fs index a2881209932..b03cdd0d920 100644 --- a/src/Compiler/Facilities/LanguageFeatures.fs +++ b/src/Compiler/Facilities/LanguageFeatures.fs @@ -21,7 +21,6 @@ type LanguageFeature = | FromEndSlicing | ResumableStateMachines | RuntimeAsync - | NullableOptionalInterop | DefaultInterfaceMemberConsumption | WitnessPassing | AdditionalTypeDirectedConversions @@ -321,7 +320,6 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) | LanguageFeature.NullnessChecking -> FSComp.SR.featureNullnessChecking () | LanguageFeature.ResumableStateMachines -> FSComp.SR.featureResumableStateMachines () | LanguageFeature.RuntimeAsync -> FSComp.SR.featureRuntimeAsync () - | LanguageFeature.NullableOptionalInterop -> FSComp.SR.featureNullableOptionalInterop () | LanguageFeature.DefaultInterfaceMemberConsumption -> FSComp.SR.featureDefaultInterfaceMemberConsumption () | LanguageFeature.WitnessPassing -> FSComp.SR.featureWitnessPassing () | LanguageFeature.AdditionalTypeDirectedConversions -> FSComp.SR.featureAdditionalImplicitConversions () diff --git a/src/Compiler/Facilities/LanguageFeatures.fsi b/src/Compiler/Facilities/LanguageFeatures.fsi index a480a3e6179..33bdf058184 100644 --- a/src/Compiler/Facilities/LanguageFeatures.fsi +++ b/src/Compiler/Facilities/LanguageFeatures.fsi @@ -11,7 +11,6 @@ type LanguageFeature = | FromEndSlicing | ResumableStateMachines | RuntimeAsync - | NullableOptionalInterop | DefaultInterfaceMemberConsumption | WitnessPassing | AdditionalTypeDirectedConversions From f32ef0926e3bb8d35e5c302bcf85ac43466a7eb3 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 1 Sep 2026 22:43:11 +0200 Subject: [PATCH 41/59] add sample asyncSeq builder --- .../RuntimeAsync/RuntimeAsyncEnumerable.fs | 402 ++++++++++++++---- .../RuntimeAsyncEnumerableLowLevel.fs | 96 +++++ .../RuntimeAsyncEnumerableTests.fs | 264 ++++++++++++ .../RuntimeAsync/RuntimeTaskBuilder.fs | 2 + .../Language/RuntimeAsyncTests.fs | 26 +- 5 files changed, 704 insertions(+), 86 deletions(-) create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableLowLevel.fs create mode 100644 tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs index 5807a91e414..76873bc92c2 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs @@ -2,95 +2,331 @@ module RuntimeAsyncEnumerable open System open System.Collections.Generic -open System.Diagnostics open System.Runtime.CompilerServices open System.Threading +open System.Threading.Channels open System.Threading.Tasks +open System.Threading.Tasks.Sources open Microsoft.FSharp.Control open Microsoft.FSharp.Core.CompilerServices +open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers +open RuntimeTaskBuilder -type CounterEnumerator(count: int) = - let mutable current = -1 +[] +type AsyncSequenceEvent<'t> = + | Item of 't + | Completed + | Faulted of exn - member private _.MoveNextCore() : ValueTask = - StateMachineHelpers.__runtimeAsyncReturnValueTask ( - AsyncHelpers.Await(Task.Delay(1)) - current <- current + 1 - current < count - ) +type AsyncManualResetSignal<'t>() = + let mutable source = ManualResetValueTaskSourceCore<'t>() + do source.RunContinuationsAsynchronously <- true - interface IAsyncEnumerator with + member this.WaitAsync() = ValueTask<'t>(this, source.Version) + member _.SetResult value = source.SetResult value + member _.Reset() = source.Reset() + + interface IValueTaskSource<'t> with + member _.GetResult(token) = source.GetResult(token) + member _.GetStatus(token) = source.GetStatus(token) + member _.OnCompleted(continuation, state, token, flags) = + source.OnCompleted(continuation, state, token, flags) + +[] +type AsyncSequenceState<'T> = { + MoveNextRequest: AsyncManualResetSignal + ItemResponse: AsyncManualResetSignal> + CancellationToken: CancellationToken +} + +module AsyncSequenceState = + let publishItem state item = state.ItemResponse.SetResult(Item item) + let publishCompleted state = state.ItemResponse.SetResult(Completed) + let create cancellationToken = + { + MoveNextRequest = AsyncManualResetSignal() + ItemResponse = AsyncManualResetSignal>() + CancellationToken = cancellationToken + } + + +type AsyncSeqEnumerator<'T>(state: AsyncSequenceState<'T>) = + let mutable current = Unchecked.defaultof<'T> + let mutable moveNextInProgress = 0 + + interface IAsyncEnumerator<'T> with member _.Current = current - member this.MoveNextAsync() = this.MoveNextCore() - member _.DisposeAsync() = ValueTask() - -type CounterEnumerable(count: int) = - interface IAsyncEnumerable with - member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = - CounterEnumerator(count) :> IAsyncEnumerator - -let objectExpressionEnumerable count : IAsyncEnumerable = - { new IAsyncEnumerable with - member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = - let mutable current = -1 - - { new IAsyncEnumerator with - member _.Current = current - - member _.MoveNextAsync() : ValueTask = - StateMachineHelpers.__runtimeAsyncReturnValueTask ( - AsyncHelpers.Await(Task.Delay(100)) - current <- current + 1 - current < count - ) - - member _.DisposeAsync() = ValueTask() - } - } - -let collect (enumerable: IAsyncEnumerable) : Task = - StateMachineHelpers.__runtimeAsyncReturn ( - let enumerator = enumerable.GetAsyncEnumerator(CancellationToken.None) - let values = ResizeArray() - let mutable hasNext = AsyncHelpers.Await(enumerator.MoveNextAsync()) - - while hasNext do - values.Add enumerator.Current - hasNext <- AsyncHelpers.Await(enumerator.MoveNextAsync()) - - AsyncHelpers.Await(enumerator.DisposeAsync()) - Seq.toArray values - ) - -let collectWithTaskCe (enumerable: IAsyncEnumerable) = - task { - use enumerator = enumerable.GetAsyncEnumerator(CancellationToken.None) - let values = ResizeArray() - let stopwatch = Stopwatch.StartNew() - - while! enumerator.MoveNextAsync() do - values.Add enumerator.Current - - return Seq.toArray values, stopwatch.Elapsed - } - -[] -let main _ = - let expected = [| 0; 1; 2 |] - let classEnumerable = CounterEnumerable(3) :> IAsyncEnumerable - - let classValues = - collect classEnumerable |> fun task -> task.GetAwaiter().GetResult() - - let taskValues, elapsed = - collectWithTaskCe (objectExpressionEnumerable 3) - |> fun task -> task.GetAwaiter().GetResult() - - if - classValues = expected - && taskValues = expected - && elapsed >= TimeSpan.FromMilliseconds(300.) - then - 0 - else - 1 + + member this.MoveNextAsync() = + if Interlocked.Exchange(&moveNextInProgress, 1) = 1 then + invalidOp "MoveNextAsync cannot be called concurrently." + + __runtimeAsyncReturnValueTask( + try + state.MoveNextRequest.SetResult() + + match AsyncHelpers.Await(state.ItemResponse.WaitAsync()) with + | Item value -> + current <- value + true + | Completed -> + current <- Unchecked.defaultof<'T> + false + | Faulted error -> + raise error + finally + state.ItemResponse.Reset() + Interlocked.Exchange(&moveNextInProgress, 0) |> ignore + ) + + member this.DisposeAsync() = ValueTask.CompletedTask + +type AsyncSequenceBody<'T> = AsyncSequenceState<'T> -> unit + +type AsyncSeqBuilder() = + member inline _.Delay([] generator: unit -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> generator() state + + member inline _.Run([] code: AsyncSequenceBody<'T>) : IAsyncEnumerable<'T> = + let getEnumerator ct = + let state = AsyncSequenceState.create ct + + let runProducer () = + __runtimeAsyncReturnUnit( + AsyncHelpers.Await(state.MoveNextRequest.WaitAsync()) + state.MoveNextRequest.Reset() + code(state) + state.ItemResponse.SetResult(Completed) + ) + Task.Run<_>(runProducer) |> ignore + AsyncSeqEnumerator<'T>(state) + + { new IAsyncEnumerable<'T> with + member _.GetAsyncEnumerator(cancellationToken: CancellationToken) = getEnumerator cancellationToken } + + member inline _.Zero() : AsyncSequenceBody<'T> = + fun _ -> () + + member inline _.Return(_: unit) : AsyncSequenceBody<'T> = + fun _ -> () + + member inline _.ReturnFrom(task: Task) : AsyncSequenceBody<'T> = + fun _ -> AsyncHelpers.Await task + + member inline _.ReturnFrom(task: Task<'U>) : AsyncSequenceBody<'T> = + fun _ -> AsyncHelpers.Await task |> ignore + + member inline _.ReturnFrom(task: ValueTask) : AsyncSequenceBody<'T> = + fun _ -> AsyncHelpers.Await task + + member inline _.ReturnFrom(task: ValueTask<'U>) : AsyncSequenceBody<'T> = + fun _ -> AsyncHelpers.Await task |> ignore + + member inline _.ReturnFrom(computation: Async<'U>) : AsyncSequenceBody<'T> = + fun _ -> AsyncHelpers.Await(Async.StartImmediateAsTask computation) |> ignore + + member inline _.ReturnFrom(computation: RuntimeTask<'U>) : AsyncSequenceBody<'T> = + fun _ -> computation() |> ignore + + member inline _.Bind(task: Task, [] continuation: unit -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> + AsyncHelpers.Await task + continuation() state + + member inline _.Bind(task: Task<'U>, [] continuation: 'U -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> + continuation (AsyncHelpers.Await task) state + + member inline _.Bind(task: ValueTask, [] continuation: unit -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> + AsyncHelpers.Await task + continuation() state + + member inline _.Bind(task: ValueTask<'U>, [] continuation: 'U -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> + continuation (AsyncHelpers.Await task) state + + member inline _.Bind(computation: Async<'U>, [] continuation: 'U -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> + continuation (AsyncHelpers.Await(Async.StartImmediateAsTask computation)) state + + member inline _.Bind(computation: RuntimeTask<'U>, [] continuation: 'U -> AsyncSequenceBody<'T>) : AsyncSequenceBody<'T> = + fun state -> + continuation (computation()) state + + member inline _.Bind( + values: struct ('U1 * 'U2), + [] continuation: struct ('U1 * 'U2) -> AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> continuation values state + + member inline _.Combine( + first: AsyncSequenceBody<'T>, + [] second: AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> + first state + second state + + member inline _.TryWith( + [] body: AsyncSequenceBody<'T>, + [] handler: exn -> AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> + try + body state + with error -> + handler error state + + member inline _.TryFinally( + [] body: AsyncSequenceBody<'T>, + [] compensation: unit -> unit + ) : AsyncSequenceBody<'T> = + fun state -> + try + body state + finally + compensation() + + member inline _.Using( + resource: 'Resource, + [] body: 'Resource -> AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> + try + body resource state + finally + match box resource with + | :? IAsyncDisposable as disposable -> AsyncHelpers.Await(disposable.DisposeAsync()) + | :? IDisposable as disposable -> disposable.Dispose() + | _ -> () + + member inline _.While( + guard: unit -> bool, + [] body: AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> + while guard() do + body state + + member inline _.For( + sequence: seq<'U>, + [] body: 'U -> AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> + for item in sequence do + body item state + + member inline _.For( + sequence: IAsyncEnumerable<'U>, + [] body: 'U -> AsyncSequenceBody<'T> + ) : AsyncSequenceBody<'T> = + fun state -> + let innerEnumerator = sequence.GetAsyncEnumerator(state.CancellationToken) + + try + let mutable hasNextItem = AsyncHelpers.Await(innerEnumerator.MoveNextAsync()) + + while hasNextItem do + let value = innerEnumerator.Current + body value state + hasNextItem <- AsyncHelpers.Await(innerEnumerator.MoveNextAsync()) + finally + AsyncHelpers.Await(innerEnumerator.DisposeAsync()) + + member inline _.Yield(value: 'T) : AsyncSequenceBody<'T> = + fun state -> + AsyncSequenceState.publishItem state value + AsyncHelpers.Await(state.MoveNextRequest.WaitAsync()) + state.MoveNextRequest.Reset() + + member inline _.YieldFrom(sequence: seq<'T>) : AsyncSequenceBody<'T> = + fun state -> + for value in sequence do + AsyncSequenceState.publishItem state value + AsyncHelpers.Await(state.MoveNextRequest.WaitAsync()) + state.MoveNextRequest.Reset() + + member inline _.YieldFrom(sequence: IAsyncEnumerable<'T>) : AsyncSequenceBody<'T> = + fun state -> + let innerEnumerator = sequence.GetAsyncEnumerator(state.CancellationToken) + + try + while AsyncHelpers.Await(innerEnumerator.MoveNextAsync()) do + let value = innerEnumerator.Current + AsyncSequenceState.publishItem state value + AsyncHelpers.Await(state.MoveNextRequest.WaitAsync()) + state.MoveNextRequest.Reset() + finally + AsyncHelpers.Await(innerEnumerator.DisposeAsync()) + + +module AsyncSeqAwaitableExtensions = + let inline awaitTaskLike + ([] getAwaiter: unit -> 'Awaiter) + ([] getResult: 'Awaiter -> 'T) + = + let awaiter = getAwaiter() + AsyncHelpers.AwaitAwaiter awaiter + getResult awaiter + + type AsyncSeqBuilder with + [] + member inline _.Bind< ^TaskLike, ^Awaiter, 'U, 'T + when ^TaskLike: (member GetAwaiter: unit -> ^Awaiter) + and ^Awaiter :> ICriticalNotifyCompletion + and ^Awaiter: (member get_IsCompleted: unit -> bool) + and ^Awaiter: (member GetResult: unit -> 'U)> + (task: ^TaskLike, [] continuation: 'U -> AsyncSequenceBody<'T>) + : AsyncSequenceBody<'T> = + fun state -> + let result = + awaitTaskLike + (fun () -> (^TaskLike: (member GetAwaiter: unit -> ^Awaiter) task)) + (fun awaiter -> (^Awaiter: (member GetResult: unit -> 'U) awaiter)) + + continuation result state + + [] + member inline _.ReturnFrom< ^TaskLike, ^Awaiter, 'U, 'T + when ^TaskLike: (member GetAwaiter: unit -> ^Awaiter) + and ^Awaiter :> ICriticalNotifyCompletion + and ^Awaiter: (member get_IsCompleted: unit -> bool) + and ^Awaiter: (member GetResult: unit -> 'U)> + (task: ^TaskLike) + : AsyncSequenceBody<'T> = + fun _ -> + awaitTaskLike + (fun () -> (^TaskLike: (member GetAwaiter: unit -> ^Awaiter) task)) + (fun awaiter -> (^Awaiter: (member GetResult: unit -> 'U) awaiter)) + |> ignore + + [] + member inline _.MergeSources< ^TaskLike1, ^TaskLike2, ^Awaiter1, ^Awaiter2, 'U1, 'U2 + when ^TaskLike1: (member GetAwaiter: unit -> ^Awaiter1) + and ^TaskLike2: (member GetAwaiter: unit -> ^Awaiter2) + and ^Awaiter1 :> ICriticalNotifyCompletion + and ^Awaiter2 :> ICriticalNotifyCompletion + and ^Awaiter1: (member get_IsCompleted: unit -> bool) + and ^Awaiter1: (member GetResult: unit -> 'U1) + and ^Awaiter2: (member get_IsCompleted: unit -> bool) + and ^Awaiter2: (member GetResult: unit -> 'U2)> + (left: ^TaskLike1, right: ^TaskLike2) + : struct ('U1 * 'U2) = + let awaitLeft () = + awaitTaskLike + (fun () -> (^TaskLike1: (member GetAwaiter: unit -> ^Awaiter1) left)) + (fun awaiter -> (^Awaiter1: (member GetResult: unit -> 'U1) awaiter)) + + let awaitRight () = + awaitTaskLike + (fun () -> (^TaskLike2: (member GetAwaiter: unit -> ^Awaiter2) right)) + (fun awaiter -> (^Awaiter2: (member GetResult: unit -> 'U2) awaiter)) + + struct (awaitLeft(), awaitRight()) + +open AsyncSeqAwaitableExtensions + +[] +module AsyncSeq = + let asyncSeq = AsyncSeqBuilder() diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableLowLevel.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableLowLevel.fs new file mode 100644 index 00000000000..6b9c700b52b --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableLowLevel.fs @@ -0,0 +1,96 @@ +module RuntimeAsyncEnumerableLowLevel + +open System +open System.Collections.Generic +open System.Diagnostics +open System.Runtime.CompilerServices +open System.Threading +open System.Threading.Tasks +open Microsoft.FSharp.Control +open Microsoft.FSharp.Core.CompilerServices + +type CounterEnumerator(count: int) = + let mutable current = -1 + + member private _.MoveNextCore() : ValueTask = + StateMachineHelpers.__runtimeAsyncReturnValueTask ( + AsyncHelpers.Await(Task.Delay(1)) + current <- current + 1 + current < count + ) + + interface IAsyncEnumerator with + member _.Current = current + member this.MoveNextAsync() = this.MoveNextCore() + member _.DisposeAsync() = ValueTask() + +type CounterEnumerable(count: int) = + interface IAsyncEnumerable with + member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = + CounterEnumerator(count) :> IAsyncEnumerator + +let objectExpressionEnumerable count : IAsyncEnumerable = + { new IAsyncEnumerable with + member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = + let mutable current = -1 + + { new IAsyncEnumerator with + member _.Current = current + + member _.MoveNextAsync() : ValueTask = + StateMachineHelpers.__runtimeAsyncReturnValueTask ( + AsyncHelpers.Await(Task.Delay(100)) + current <- current + 1 + current < count + ) + + member _.DisposeAsync() = ValueTask() + } + } + +let collect (enumerable: IAsyncEnumerable) : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + let enumerator = enumerable.GetAsyncEnumerator(CancellationToken.None) + let values = ResizeArray() + let mutable hasNext = AsyncHelpers.Await(enumerator.MoveNextAsync()) + + while hasNext do + values.Add enumerator.Current + hasNext <- AsyncHelpers.Await(enumerator.MoveNextAsync()) + + AsyncHelpers.Await(enumerator.DisposeAsync()) + Seq.toArray values + ) + +let collectWithTaskCe (enumerable: IAsyncEnumerable) = + task { + use enumerator = enumerable.GetAsyncEnumerator(CancellationToken.None) + let values = ResizeArray() + let stopwatch = Stopwatch.StartNew() + + while! enumerator.MoveNextAsync() do + values.Add enumerator.Current + + return Seq.toArray values, stopwatch.Elapsed + } + +[] +let main _ = + let expected = [| 0; 1; 2 |] + let classEnumerable = CounterEnumerable(3) :> IAsyncEnumerable + + let classValues = + collect classEnumerable |> fun task -> task.GetAwaiter().GetResult() + + let taskValues, elapsed = + collectWithTaskCe (objectExpressionEnumerable 3) + |> fun task -> task.GetAwaiter().GetResult() + + if + classValues = expected + && taskValues = expected + && elapsed >= TimeSpan.FromMilliseconds(300.) + then + 0 + else + 1 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs new file mode 100644 index 00000000000..5811bf138ac --- /dev/null +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs @@ -0,0 +1,264 @@ +module Tests + +open System +open System.Collections.Generic +open System.Threading +open System.Threading.Tasks +open RuntimeAsyncEnumerable +open RuntimeTaskBuilder +open RuntimeTaskBuilder.RuntimeTask +open AsyncSeqAwaitableExtensions + +let private assertEqual name expected actual = + if expected <> actual then + failwithf "%s failed. Expected %A, got %A." name expected actual + +let private assertTrue name condition = + if not condition then + failwithf "%s failed." name + +let private collect (source: IAsyncEnumerable<'T>) = + runtimeTask { + use enumerator = source.GetAsyncEnumerator(CancellationToken.None) + let values = ResizeArray<'T>() + + while! enumerator.MoveNextAsync() do + //printfn "Collected value: %A" enumerator.Current + values.Add enumerator.Current + + return Seq.toArray values + } + +type CustomAwaitable(value: int) = + member _.GetAwaiter() = Task.FromResult(value).GetAwaiter() + +type private TrackingDisposable(onDispose: unit -> unit) = + interface IDisposable with + member _.Dispose() = onDispose() + +type private TestAsyncSource(values: int[]) = + interface IAsyncEnumerable with + member _.GetAsyncEnumerator(_cancellationToken: CancellationToken) = + let mutable index = -1 + + { new IAsyncEnumerator with + member _.Current = + if index < 0 || index >= values.Length then + invalidOp "Current is not available." + + values[index] + + member _.MoveNextAsync() = + index <- index + 1 + ValueTask(index < values.Length) + + member _.DisposeAsync() = ValueTask() } + +let private basicSequence () = + asyncSeq { + do! Task.Delay(5) + yield "1" + do! Task.Delay(5) + yield "x" + do! Task.Delay(5) + yield "2" + } + +let private testBasicSequence () = + runtimeTask { + let! values = collect (basicSequence()) + assertEqual "basic sequence" [| "1"; "x"; "2" |] values + } + +let private testAwaitableKinds () = + runtimeTask { + let source = + asyncSeq { + let! taskValue = Task.FromResult 1 + let! valueTaskValue = ValueTask(2) + let! asyncValue = async { return 3 } + let! customValue = CustomAwaitable 4 + let! runtimeTaskValue = runtimeTask { return 5 } + yield taskValue + valueTaskValue + asyncValue + customValue + runtimeTaskValue + } + + let! values = collect source + assertEqual "awaitable kinds" [| 15 |] values + } + +let private testMergedAwaitables () = + runtimeTask { + let source = + asyncSeq { + do! Task.Delay(25) + let! taskValue = Task.FromResult 1 + let! valueTaskValue = ValueTask(2) + let! asyncValue = async { return 3 } + do! Task.Delay(25) + yield taskValue + valueTaskValue + asyncValue + } + + let! values = collect source + assertEqual "merged awaitables" [| 6 |] values + } + +let private testTryWith () = + runtimeTask { + let source = + asyncSeq { + try + yield 1 + do! Task.Delay(10) + raise (InvalidOperationException("expected")) + with + | :? InvalidOperationException -> yield 2 + } + + let! values = collect source + assertEqual "try/with" [| 1; 2 |] values + } + +let private testTryFinally () = + runtimeTask { + let mutable cleanedUp = false + let source = + asyncSeq { + try + yield 3 + finally + cleanedUp <- true + } + + let! values = collect source + assertEqual "try/finally values" [| 3 |] values + assertTrue "try/finally cleanup" cleanedUp + } + +let private testUsing () = + runtimeTask { + let mutable disposed = false + let source = + asyncSeq { + use resource = new TrackingDisposable(fun () -> disposed <- true) + yield 4 + } + + let! values = collect source + assertEqual "using values" [| 4 |] values + assertTrue "using disposal" disposed + } + +let private testWhile () = + runtimeTask { + let source = + asyncSeq { + let mutable value = 0 + + while value < 3 do + do! Task.Delay(10) + yield value + value <- value + 1 + } + + let! values = collect source + assertEqual "while loop" [| 0; 1; 2 |] values + } + +let private testYieldFrom () = + runtimeTask { + let source = + asyncSeq { + yield! [ 5; 6 ] + yield! (TestAsyncSource [| 7; 8 |] :> IAsyncEnumerable) + } + + let! values = collect source + assertEqual "yield!" [| 5; 6; 7; 8 |] values + } + +let private testForAsyncEnumerable () = + runtimeTask { + let source = + asyncSeq { + for value in (TestAsyncSource [| 9; 10 |] :> IAsyncEnumerable) do + yield value + 1 + } + + let! values = collect source + assertEqual "async for loop" [| 10; 11 |] values + } + +let private testPullDrivenEnumeration () = + runtimeTask { + let mutable sideEffects = 0 + let source = + asyncSeq { + sideEffects <- sideEffects + 1 + yield 1 + sideEffects <- sideEffects + 1 + yield 2 + } + + use enumerator = source.GetAsyncEnumerator(CancellationToken.None) + assertEqual "pull before first move" 0 sideEffects + let! firstMove = enumerator.MoveNextAsync() + assertTrue "pull first move" firstMove + assertEqual "pull first side effect" 1 sideEffects + assertEqual "pull first value" 1 enumerator.Current + let! secondMove = enumerator.MoveNextAsync() + assertTrue "pull second move" secondMove + assertEqual "pull second side effect" 2 sideEffects + assertEqual "pull second value" 2 enumerator.Current + let! completed = enumerator.MoveNextAsync() + assertTrue "pull completion" (not completed) + } + +let private testConcurrentMoveNext () = + runtimeTask { + let gate = TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously) + let source = + asyncSeq { + do! gate.Task + yield 1 + } + + use enumerator = source.GetAsyncEnumerator(CancellationToken.None) + let firstMove = enumerator.MoveNextAsync() + let rejected = + try + enumerator.MoveNextAsync() |> ignore + false + with + | :? InvalidOperationException -> true + + gate.SetResult(()) + assertTrue "concurrent MoveNext rejection" rejected + let! firstMoveResult = firstMove + assertTrue "concurrent MoveNext result" firstMoveResult + } + +let runTests () = + let tests : (string * Task) list = + [ "basic sequence", testBasicSequence () + "awaitable kinds", testAwaitableKinds () + "merged awaitables", testMergedAwaitables () + "try/with", testTryWith () + "try/finally", testTryFinally () + "using", testUsing () + "while", testWhile () + "yield!", testYieldFrom () + "async for loop", testForAsyncEnumerable () + "pull-driven enumeration", testPullDrivenEnumeration () + "concurrent MoveNext", testConcurrentMoveNext () ] + + runtimeTask { + for name, test in tests do + do! test + printfn "PASS: %s" name + + return 0 + } + +[] +let main _ = + runTests() |> _.Result diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs index 691f0cb7b40..bb6f407b1ee 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTaskBuilder.fs @@ -6,6 +6,8 @@ open System.Threading.Tasks open Microsoft.FSharp.Control open Microsoft.FSharp.Core.CompilerServices +type RuntimeTask<'T> = unit -> 'T + let inline bindAwaiter ([] getAwaiter: unit -> 'Awaiter) ([] getResult: 'Awaiter -> 'T) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 382eb9700d0..296e53e7d20 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -376,12 +376,32 @@ let ``runtime async direct intrinsic fixture executes`` () = |> compileExeAndRun |> shouldSucceed -[] -let ``runtime async low level async enumerable fixture executes`` () = - Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncEnumerable.fs") +[] +[] +[] +let ``runtime async low level async enumerable fixture executes`` (optimize: bool) = + Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncEnumerableLowLevel.fs") |> FsFromPath |> withLangVersionPreview |> withFSharpCoreShippedNet + |> withOptimization optimize + |> compileExeAndRun + |> shouldSucceed + +[] +[] +[] +let ``runtime async enumerable builder fixture executes`` (optimize: bool) = + FsFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTaskBuilder.fs")) + |> withAdditionalSourceFile ( + SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncEnumerable.fs")) + ) + |> withAdditionalSourceFile ( + SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncEnumerableTests.fs")) + ) + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> withOptimization optimize |> compileExeAndRun |> shouldSucceed From 5fd74747ff3d55ad8e9d8f2f494d93b74eca0864 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 1 Sep 2026 23:26:59 +0200 Subject: [PATCH 42/59] Fix runtime async lambda fragment fusion Force specialization of runtime async fragments wrapped in compiler-generated let bindings so unoptimized computation expressions keep suspension calls inside runtime async methods. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- docs/runtime-async.md | 3 ++- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 27 ++++++++++++------- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 8db8fe78a8e..e729ed31d42 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -152,7 +152,8 @@ method. After specialization, lambda arguments are substituted and their applications are beta-reduced before and after runtime-async reoptimization. This includes -debug-point-wrapped lambdas, curried applications, and multi-argument lambdas. +debug-point-wrapped lambdas, compiler-generated `let` wrappers, curried +applications, and multi-argument lambdas. That step is required for computation-expression shapes where `Bind` returns a closure containing `Await`, and later `Combine`/`Delay` calls apply that closure. Dead branches eliminated by optimization do not reach code generation and do diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index 20d4059b89f..c086cd5ce49 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -47,14 +47,19 @@ let ExprContainsRuntimeAsyncFragment (g: TcGlobals) (getLambdaBody: ValRef -> Ex exprContainsRuntimeAsyncFragment g getLambdaBody [] expr let ShouldForceRuntimeAsyncInline (g: TcGlobals) runtimeAsyncContext (getLambdaBody: ValRef -> Expr option) (vref: ValRef) inlineBody = - if runtimeAsyncContext && vref.InlineIfLambda && not vref.ShouldInline then + let containsRuntimeAsyncFragment = + match inlineBody with + | Some body -> ExprContainsRuntimeAsyncFragment g getLambdaBody body + | None -> hasRuntimeAsyncFragmentBody g getLambdaBody [] vref + + if containsRuntimeAsyncFragment then + true + elif runtimeAsyncContext && vref.InlineIfLambda && not vref.ShouldInline then true elif not (vref.ShouldInline || vref.IsLocalRef) then false else - match inlineBody with - | Some body -> ExprContainsRuntimeAsyncFragment g getLambdaBody body - | None -> hasRuntimeAsyncFragmentBody g getLambdaBody [] vref + hasRuntimeAsyncFragmentBody g getLambdaBody [] vref let ShouldForceRuntimeAsyncApplication (g: TcGlobals) @@ -78,6 +83,14 @@ let ShouldForceRuntimeAsyncApplication args) let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Expr -> bool) expr = + let rec isLambdaExpression expr = + match stripExpr expr with + | Expr.DebugPoint(_, innerExpr) + | Expr.Let(_, innerExpr, _, _) -> isLambdaExpression innerExpr + | Expr.Lambda _ + | Expr.TyLambda _ -> true + | _ -> false + let rec stripLambdaDebugPoints expr = match expr with | Expr.DebugPoint(_, innerExpr) -> @@ -165,11 +178,7 @@ let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Exp match stripExpr expr with | Expr.Let(TBind(boundVal, boundExpr, _), body, _, _) when boundVal.InlineIfLambda - || ((match stripExpr boundExpr with - | Expr.Lambda _ - | Expr.TyLambda _ -> true - | _ -> false) - && isRuntimeAsyncFragment boundExpr) + || (isLambdaExpression boundExpr && isRuntimeAsyncFragment boundExpr) -> Some(cont (inlineBinding boundVal boundExpr body)) | _ -> None) From 925558c563f702adb5492b8e69caae8257165f46 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 13:32:30 +0200 Subject: [PATCH 43/59] Fix no-opt runtime async recursive inlining Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 3 ++ .../RuntimeAsync/RuntimeAsyncEnumerable.fs | 52 ++++++++++++------- .../RuntimeAsyncEnumerableTests.fs | 17 +++++- 3 files changed, 53 insertions(+), 19 deletions(-) diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index c086cd5ce49..b5c7653c656 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -180,6 +180,9 @@ let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Exp boundVal.InlineIfLambda || (isLambdaExpression boundExpr && isRuntimeAsyncFragment boundExpr) -> + if not boundVal.InlineIfLambda then + boundVal.SetInlineIfLambda() + Some(cont (inlineBinding boundVal boundExpr body)) | _ -> None) PreInterceptBinding = None diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs index 76873bc92c2..c49addb7b00 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs @@ -12,7 +12,7 @@ open Microsoft.FSharp.Core.CompilerServices open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers open RuntimeTaskBuilder -[] +[] type AsyncSequenceEvent<'t> = | Item of 't | Completed @@ -32,11 +32,12 @@ type AsyncManualResetSignal<'t>() = member _.OnCompleted(continuation, state, token, flags) = source.OnCompleted(continuation, state, token, flags) -[] +[] type AsyncSequenceState<'T> = { MoveNextRequest: AsyncManualResetSignal ItemResponse: AsyncManualResetSignal> CancellationToken: CancellationToken + KickOff: bool } module AsyncSequenceState = @@ -47,6 +48,7 @@ module AsyncSequenceState = MoveNextRequest = AsyncManualResetSignal() ItemResponse = AsyncManualResetSignal>() CancellationToken = cancellationToken + KickOff = true } @@ -81,6 +83,18 @@ type AsyncSeqEnumerator<'T>(state: AsyncSequenceState<'T>) = member this.DisposeAsync() = ValueTask.CompletedTask +type AsyncEnumerable<'T>(runProducer: AsyncSequenceState<'T> -> Task) = + let getEnumerator ct = + let state = AsyncSequenceState.create ct + Task.Run<_>(fun () -> runProducer state) |> ignore + AsyncSeqEnumerator<'T>(state) + + member _.RunProducer(state: AsyncSequenceState<'T>) = runProducer state + + interface IAsyncEnumerable<'T> with + member _.GetAsyncEnumerator(cancellationToken: CancellationToken) = + getEnumerator cancellationToken + type AsyncSequenceBody<'T> = AsyncSequenceState<'T> -> unit type AsyncSeqBuilder() = @@ -88,21 +102,19 @@ type AsyncSeqBuilder() = fun state -> generator() state member inline _.Run([] code: AsyncSequenceBody<'T>) : IAsyncEnumerable<'T> = - let getEnumerator ct = - let state = AsyncSequenceState.create ct - - let runProducer () = - __runtimeAsyncReturnUnit( + let runProducer state = + __runtimeAsyncReturn( + // wait for kick off. + if state.KickOff then AsyncHelpers.Await(state.MoveNextRequest.WaitAsync()) state.MoveNextRequest.Reset() - code(state) - state.ItemResponse.SetResult(Completed) - ) - Task.Run<_>(runProducer) |> ignore - AsyncSeqEnumerator<'T>(state) - { new IAsyncEnumerable<'T> with - member _.GetAsyncEnumerator(cancellationToken: CancellationToken) = getEnumerator cancellationToken } + code state + + if state.KickOff then AsyncSequenceState.publishCompleted state + ) + + AsyncEnumerable(runProducer) member inline _.Zero() : AsyncSequenceBody<'T> = fun _ -> () @@ -225,12 +237,9 @@ type AsyncSeqBuilder() = let innerEnumerator = sequence.GetAsyncEnumerator(state.CancellationToken) try - let mutable hasNextItem = AsyncHelpers.Await(innerEnumerator.MoveNextAsync()) - - while hasNextItem do + while AsyncHelpers.Await(innerEnumerator.MoveNextAsync()) do let value = innerEnumerator.Current body value state - hasNextItem <- AsyncHelpers.Await(innerEnumerator.MoveNextAsync()) finally AsyncHelpers.Await(innerEnumerator.DisposeAsync()) @@ -260,6 +269,13 @@ type AsyncSeqBuilder() = finally AsyncHelpers.Await(innerEnumerator.DisposeAsync()) + member inline this.YieldFromFinal(sequence: IAsyncEnumerable<'T>) : AsyncSequenceBody<'T> = + match sequence with + | :? AsyncEnumerable<'T> as asyncSeq -> + fun state -> + AsyncHelpers.Await (asyncSeq.RunProducer { state with KickOff = false }) + | _ -> + this.YieldFrom sequence module AsyncSeqAwaitableExtensions = let inline awaitTaskLike diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs index 5811bf138ac..2e43b8cff98 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs @@ -237,6 +237,20 @@ let private testConcurrentMoveNext () = assertTrue "concurrent MoveNext result" firstMoveResult } +let testTailRecursion () = + runtimeTask { + let rec loop n = + asyncSeq { + if n > 0 then + if n % 10000 = 0 then + do! Task.Delay 1 // simulate some async work + yield n + yield! loop (n - 1) + } + let! values = collect (loop 100_000) + assertEqual "tail recursion" [| for i in 100_000 .. -1 .. 1 -> i |] values + } + let runTests () = let tests : (string * Task) list = [ "basic sequence", testBasicSequence () @@ -249,7 +263,8 @@ let runTests () = "yield!", testYieldFrom () "async for loop", testForAsyncEnumerable () "pull-driven enumeration", testPullDrivenEnumeration () - "concurrent MoveNext", testConcurrentMoveNext () ] + "concurrent MoveNext", testConcurrentMoveNext () + "tail recursion", testTailRecursion () ] runtimeTask { for name, test in tests do From 0584823b9df715d210ec62777d58e09e22b0e5af Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 16:20:19 +0200 Subject: [PATCH 44/59] Refactor runtime async boundary analysis --- docs/runtime-async.md | 16 +- .../Checking/Expressions/CheckExpressions.fs | 13 +- src/Compiler/CodeGen/IlxGen.fs | 22 +-- src/Compiler/Optimize/LowerLocalMutables.fs | 21 +-- src/Compiler/Optimize/Optimizer.fs | 43 +++--- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 139 ++++++++++++------ .../Optimize/RuntimeAsyncExceptionRewrite.fs | 21 +-- src/Compiler/TypedTree/RuntimeAsync.fs | 61 +++++--- 8 files changed, 210 insertions(+), 126 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index e729ed31d42..2d95e103f61 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -159,10 +159,22 @@ closure containing `Await`, and later `Combine`/`Delay` calls apply that closure Dead branches eliminated by optimization do not reach code generation and do not produce a suspension-outside-runtime-async diagnostic. +Runtime-async boundary recognition is centralized in +`TypedTree/RuntimeAsync.fs`. The `RuntimeAsyncBoundary` type distinguishes a +return marker from a suspension call, and consumers use the shared +recognizers rather than matching typed-tree shapes independently. + +The optimizer uses a context-local `RuntimeAsyncAnalyzer`. It memoizes +completed expression results by reference identity and inline-value results by +value stamp, with a visiting set for recursive inline-value graphs. The cache +is not global: optimizer environments can provide different inline bodies, and +optimization creates new expression trees. Context-dependent decisions such as +`runtimeAsyncContext` remain outside the cached facts. + ## Code generation -`IlxGen.fs` recognises the return-marker family in three placements -(`TryUnwrapRuntimeAsyncReturnExpr`, which strips `DebugPoint` wrappers): +`IlxGen.fs` recognises the return-marker family in three placements through the +shared runtime-async boundary contract, which strips `DebugPoint` wrappers: 1. **Method body** (`GenMethodForBinding`): the marker is unwrapped from the top of the method lambda body; the generated `ILMethodDef` gets diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 0e3ec544cf4..2a3d6510d54 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -8691,11 +8691,7 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl | DelayedApp (atomicFlag, isSugar, synLeftExprOpt, synArg, mExprAndArg) :: delayedList' -> let denv = env.DisplayEnv - let isRuntimeAsync = - match expr.Expr with - | Expr.Val(RuntimeAsyncReturn g, _, _) - | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, [ _ ], [], _) -> true - | _ -> false + let isRuntimeAsync = TryGetRuntimeAsyncReturnFunction g expr.Expr |> Option.isSome match isRuntimeAsync, UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with | true, _ -> @@ -8992,8 +8988,11 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let (|RuntimeAsyncApplication|_|) = function - | ApplicableExpr(expr=Expr.Val (RuntimeAsyncReturn g as vref, flags, m)) - | ApplicableExpr(expr=Expr.App (Expr.Val (RuntimeAsyncReturn g as vref, flags, m), _, [ _ ], [], _)) -> + | ApplicableExpr(expr=runtimeAsyncFunction) + when TryGetRuntimeAsyncReturnFunction g runtimeAsyncFunction |> Option.isSome -> + match TryGetRuntimeAsyncReturnFunction g runtimeAsyncFunction with + | None -> ValueNone + | Some(vref, flags, m) -> checkLanguageFeatureAndRecover g.langVersion LanguageFeature.RuntimeAsync m let _, carrierTy = stripFunTy g exprTy diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index d3bd2d39f5f..1ecd45dc1c8 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3315,7 +3315,7 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = // application of local type functions with type parameters = measure types and body = local value - inline the body GenExpr cenv cgbuf eenv v sequel - | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, _, [ _ ], _) -> GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel + | Expr.App _ when TryGetRuntimeAsyncReturn g expr |> Option.isSome -> GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel | Expr.App(f, fty, tyargs, curriedArgs, m) -> GenApp cenv cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel @@ -7199,8 +7199,10 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr strip cloinfo.ilCloLambdas - let isRuntimeAsyncUnit = IsRuntimeAsyncReturnUnitExpr g body - let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body + let isRuntimeAsync, isRuntimeAsyncUnit, body = + match TryGetRuntimeAsyncReturn g body with + | Some info -> true, List.isEmpty info.TypeArgs, info.Body + | None -> false, false, body let eenvinner = { eenvinner with @@ -7262,8 +7264,10 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e let ilCloTypeRef = cloinfo.cloSpec.TypeRef - let isRuntimeAsyncUnit = IsRuntimeAsyncReturnUnitExpr g body - let isRuntimeAsync, body = TryUnwrapRuntimeAsyncReturnExpr g body + let isRuntimeAsync, isRuntimeAsyncUnit, body = + match TryGetRuntimeAsyncReturn g body with + | Some info -> true, List.isEmpty info.TypeArgs, info.Body + | None -> false, false, body let eenvinner = { eenvinner with @@ -9932,10 +9936,10 @@ and GenMethodForBinding | h :: t -> [ h ], t, true | _ -> [], methLambdaVars, false - let isRuntimeAsyncUnit = IsRuntimeAsyncReturnUnitExpr g methLambdaBody - - let isRuntimeAsync, methLambdaBody = - TryUnwrapRuntimeAsyncReturnExpr g methLambdaBody + let isRuntimeAsync, isRuntimeAsyncUnit, methLambdaBody = + match TryGetRuntimeAsyncReturn g methLambdaBody with + | Some info -> true, List.isEmpty info.TypeArgs, info.Body + | None -> false, false, methLambdaBody let nonUnitNonSelfMethodVars, body = BindUnitVars cenv.g (nonSelfMethodVars, paramInfos, methLambdaBody) diff --git a/src/Compiler/Optimize/LowerLocalMutables.fs b/src/Compiler/Optimize/LowerLocalMutables.fs index cb7ab2807b2..f5916480380 100644 --- a/src/Compiler/Optimize/LowerLocalMutables.fs +++ b/src/Compiler/Optimize/LowerLocalMutables.fs @@ -102,21 +102,17 @@ let DecideExpr cenv exprF noInterceptF z expr = let z = (z, iimpls) ||> List.fold CheckInterfaceImpl z - // A __runtimeAsyncReturn application that does not end up at the top of a method or - // closure body is re-homed into a compiler-synthesized closure during code generation - // (GenRuntimeAsyncReturnAsStartedTask). Treat the argument as a lambda body so that its - // free mutable locals escape and are promoted to reference cells shared with the - // enclosing scope. When the application already is a lambda body this recomputes the - // same escapes, which is harmless. - | Expr.App (Expr.Val (RuntimeAsyncReturn g, _, _), _, _, [ body ], _) -> - let z = Zset.union z (DecideEscapes [] body) - exprF z body - | Expr.Op (c, tyargs, args, _m) -> DecideExprOp exprF noInterceptF z expr (c, tyargs, args) - | _ -> - noInterceptF z expr + | _ -> + match TryGetRuntimeAsyncReturn g expr with + | Some info -> + let z = Zset.union z (DecideEscapes [] info.Body) + exprF z info.Body + | None -> + noInterceptF z expr + /// Find all the mutable locals that escape a binding let DecideBinding cenv z (TBind(v, expr, _m) as bind) = @@ -207,4 +203,3 @@ let TransformImplFile g amap implFile = RewriteQuotations = true StackGuard = StackGuard("AutoboxRewriteStackGuardDepth") } - diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index 40075378f10..7ec7a28691e 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2584,10 +2584,10 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.Op (op, tyargs, args, m) -> OptimizeExprOp cenv env (op, tyargs, args, m) - | Expr.App (f, fty, tyargs, argsl, m) -> - match expr with - | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), fty, _, [ body ], _) -> - let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } body + | Expr.App (f, fty, tyargs, argsl, m) -> + match TryGetRuntimeAsyncReturn g expr with + | Some info -> + let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } info.Body let reportedStamps = HashSet() for v in GetRuntimeAsyncNonPreservableUses g bodyR do @@ -2599,20 +2599,23 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = { bodyInfo with HasEffect = true Info = UnknownValue } - | DelegateInvokeExpr g (delInvokeRef, delInvokeTy, tyargs, delExpr, delInvokeArg, m) -> - OptimizeFSharpDelegateInvoke cenv env (delInvokeRef, delExpr, delInvokeTy, tyargs, delInvokeArg, m) - | _ -> - let attempt = - if IsDebugPipeRightExpr cenv expr then - Some (OptimizeDebugPipeRights cenv env expr) - else None - match attempt with - | Some res -> res | None -> - // eliminate uses of query - match TryDetectQueryQuoteAndRun cenv expr with - | Some newExpr -> OptimizeExpr cenv env newExpr - | None -> OptimizeApplication cenv env (f, fty, tyargs, argsl, m) + match expr with + | DelegateInvokeExpr g (delInvokeRef, delInvokeTy, tyargs, delExpr, delInvokeArg, m) -> + OptimizeFSharpDelegateInvoke cenv env (delInvokeRef, delExpr, delInvokeTy, tyargs, delInvokeArg, m) + | _ -> + let attempt = + if IsDebugPipeRightExpr cenv expr then + Some(OptimizeDebugPipeRights cenv env expr) + else + None + + match attempt with + | Some res -> res + | None -> + match TryDetectQueryQuoteAndRun cenv expr with + | Some newExpr -> OptimizeExpr cenv env newExpr + | None -> OptimizeApplication cenv env (f, fty, tyargs, argsl, m) | Expr.Lambda (_lambdaId, _, _, argvs, _body, m, bodyTy) -> let valReprInfo = ValReprInfo ([], [argvs |> List.map (fun _ -> ValReprInfo.unnamedTopArg1)], ValReprInfo.unnamedRetVal) @@ -3689,7 +3692,8 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | CurriedLambdaValue (_, _, _, body, _) -> Some body | _ -> None - let containsRuntimeAsyncFragment = ExprContainsRuntimeAsyncFragment g getRuntimeAsyncLambdaBody + let runtimeAsyncAnalyzer = RuntimeAsyncAnalyzer(g, getRuntimeAsyncLambdaBody) + let containsRuntimeAsyncFragment = runtimeAsyncAnalyzer.ContainsFragment let reoptimizeRuntimeAsync reduced = let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced @@ -3705,9 +3709,8 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg match stripExpr valExpr with | Expr.Val(vref, _, _) -> ShouldForceRuntimeAsyncApplication - g + runtimeAsyncAnalyzer env.runtimeAsyncContext - getRuntimeAsyncLambdaBody vref inlineBody args diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index b5c7653c656..61cd814512c 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -6,6 +6,8 @@ open Internal.Utilities.Collections open Internal.Utilities.Library open Internal.Utilities.Library.Extras +open System.Collections.Generic + open FSharp.Compiler open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.TcGlobals @@ -17,40 +19,92 @@ open FSharp.Compiler.TypeRelations open FSharp.Compiler.RuntimeAsync -let rec private hasRuntimeAsyncFragmentBody (g: TcGlobals) (getLambdaBody: ValRef -> Expr option) visiting (vref: ValRef) = - if List.exists ((=) vref.Stamp) visiting then - false - else - match getLambdaBody vref with - | Some body -> exprContainsRuntimeAsyncFragment g getLambdaBody (vref.Stamp :: visiting) body - | None -> false - -and private exprContainsRuntimeAsyncFragment (g: TcGlobals) (getLambdaBody: ValRef -> Expr option) visiting expr = - let folder = - { ExprFolder0 with - exprIntercept = - fun _ noInterceptF acc expr -> - if acc then - true - else - match stripExpr expr with - | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, _, _, _) -> true - | _ when IsRuntimeAsyncSuspensionExpr g expr -> true - | Expr.Val(vref, _, _) when vref.ShouldInline || vref.IsLocalRef -> - hasRuntimeAsyncFragmentBody g getLambdaBody visiting vref - | _ -> noInterceptF acc expr - } +type RuntimeAsyncAnalyzer(g: TcGlobals, getLambdaBody: ValRef -> Expr option) = + let expressionCache = Dictionary(HashIdentity.Reference) + let suspensionCache = Dictionary(HashIdentity.Reference) + let valueCache = Dictionary() + let visitingValues = HashSet() + + let rec containsValue (vref: ValRef) = + match valueCache.TryGetValue vref.Stamp with + | true, result -> result, true + | _ when visitingValues.Contains vref.Stamp -> false, false + | _ -> + visitingValues.Add vref.Stamp |> ignore + + let result, complete = + match getLambdaBody vref with + | Some body -> containsExpression body + | None -> false, true + + visitingValues.Remove vref.Stamp |> ignore + + if complete then + valueCache[vref.Stamp] <- result + + result, complete + + and containsExpression expr = + match expressionCache.TryGetValue expr with + | true, result -> result, true + | _ -> + let mutable complete = true + + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc then + true + else + match TryGetRuntimeAsyncBoundary g expr with + | Some _ -> true + | None -> + match stripExpr expr with + | Expr.Val(vref, _, _) when vref.ShouldInline || vref.IsLocalRef -> + let result, valueComplete = containsValue vref + + if not valueComplete then + complete <- false + + result + | _ -> noInterceptF acc expr + } - FoldExpr folder false expr + let result = FoldExpr folder false expr + + if complete then + expressionCache[expr] <- result + + result, complete + + member _.ContainsFragment expr = containsExpression expr |> fst + + member _.ContainsSuspension expr = + match suspensionCache.TryGetValue expr with + | true, result -> result + | _ -> + let folder = + { ExprFolder0 with + exprIntercept = + fun _ noInterceptF acc expr -> + if acc then + true + else + match TryGetRuntimeAsyncBoundary g expr with + | Some(RuntimeAsyncBoundary.Suspension _) -> true + | _ -> noInterceptF acc expr + } -let ExprContainsRuntimeAsyncFragment (g: TcGlobals) (getLambdaBody: ValRef -> Expr option) expr = - exprContainsRuntimeAsyncFragment g getLambdaBody [] expr + let result = FoldExpr folder false expr + suspensionCache[expr] <- result + result -let ShouldForceRuntimeAsyncInline (g: TcGlobals) runtimeAsyncContext (getLambdaBody: ValRef -> Expr option) (vref: ValRef) inlineBody = +let ShouldForceRuntimeAsyncInline (analyzer: RuntimeAsyncAnalyzer) runtimeAsyncContext (vref: ValRef) inlineBody = let containsRuntimeAsyncFragment = match inlineBody with - | Some body -> ExprContainsRuntimeAsyncFragment g getLambdaBody body - | None -> hasRuntimeAsyncFragmentBody g getLambdaBody [] vref + | Some body -> analyzer.ContainsFragment body + | None -> analyzer.ContainsFragment(exprForValRef vref.Range vref) if containsRuntimeAsyncFragment then true @@ -59,19 +113,12 @@ let ShouldForceRuntimeAsyncInline (g: TcGlobals) runtimeAsyncContext (getLambdaB elif not (vref.ShouldInline || vref.IsLocalRef) then false else - hasRuntimeAsyncFragmentBody g getLambdaBody [] vref - -let ShouldForceRuntimeAsyncApplication - (g: TcGlobals) - runtimeAsyncContext - (getLambdaBody: ValRef -> Expr option) - (vref: ValRef) - inlineBody - args - = - ShouldForceRuntimeAsyncInline g runtimeAsyncContext getLambdaBody vref inlineBody + analyzer.ContainsFragment(exprForValRef vref.Range vref) + +let ShouldForceRuntimeAsyncApplication (analyzer: RuntimeAsyncAnalyzer) runtimeAsyncContext (vref: ValRef) inlineBody args = + ShouldForceRuntimeAsyncInline analyzer runtimeAsyncContext vref inlineBody || ((vref.ShouldInline || vref.InlineIfLambda) - && List.exists (ExprContainsRuntimeAsyncFragment g getLambdaBody) args) + && List.exists analyzer.ContainsFragment args) || (runtimeAsyncContext && vref.ShouldInline && List.exists @@ -244,7 +291,17 @@ let private TryGetRuntimeAsyncNonPreservableAlias (g: TcGlobals) expr = | _ -> None let private analyzeRuntimeAsyncExpr (g: TcGlobals) expr = + let cache = Dictionary(HashIdentity.Reference) + let rec analyzeExpr expr = + match cache.TryGetValue expr with + | true, summary -> summary + | _ -> + let summary = analyzeExprCore expr + cache[expr] <- summary + summary + + and analyzeExprCore expr = match stripExpr expr with | Expr.Const _ | Expr.Val _ diff --git a/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs index 2a467d1ab84..8065b13fff1 100644 --- a/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs +++ b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs @@ -5,6 +5,7 @@ module internal FSharp.Compiler.RuntimeAsyncExceptionRewrite open FSharp.Compiler open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.RuntimeAsync +open FSharp.Compiler.RuntimeAsyncAnalysis open FSharp.Compiler.Syntax open FSharp.Compiler.TcGlobals open FSharp.Compiler.TypedTree @@ -28,20 +29,18 @@ let private RuntimeAsyncFilterCondition m resultTy filter thenExpr elseExpr = let decisionTree = TDSwitch(filter, [ matchCase ], Some defaultCase, m) matchBuilder.Close(decisionTree, m, resultTy) -let private IsRuntimeAsyncExceptionHandler (g: TcGlobals) expr = +let private IsRuntimeAsyncExceptionHandler (analyzer: RuntimeAsyncAnalyzer) expr = match stripExpr expr with - | TryFinallyExpr(_, _, _, _, compensation, _) -> ExprContainsRuntimeAsyncSuspension g compensation - | TryWithExpr(_, _, _, _, _, filter, _, handler, _) -> - ExprContainsRuntimeAsyncSuspension g filter - || ExprContainsRuntimeAsyncSuspension g handler + | TryFinallyExpr(_, _, _, _, compensation, _) -> analyzer.ContainsSuspension compensation + | TryWithExpr(_, _, _, _, _, filter, _, handler, _) -> analyzer.ContainsSuspension filter || analyzer.ContainsSuspension handler | _ -> false -let private ExprContainsRuntimeAsyncExceptionHandler (g: TcGlobals) expr = +let private ExprContainsRuntimeAsyncExceptionHandler (analyzer: RuntimeAsyncAnalyzer) expr = let folder = { ExprFolder0 with exprIntercept = fun _ noInterceptF acc expr -> - if acc || IsRuntimeAsyncExceptionHandler g expr then + if acc || IsRuntimeAsyncExceptionHandler analyzer expr then true else noInterceptF acc expr @@ -50,6 +49,8 @@ let private ExprContainsRuntimeAsyncExceptionHandler (g: TcGlobals) expr = FoldExpr folder false expr let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = + let analyzer = RuntimeAsyncAnalyzer(g, fun _ -> None) + let rewriteCapturedException m resultTy body buildResult = let choiceTy = RuntimeAsyncChoiceTy g resultTy let resultVal, _ = mkCompGenLocal m "__runtimeAsyncResult" choiceTy @@ -85,7 +86,7 @@ let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = let postTransform expr = match expr with - | TryFinallyExpr(_, _, resultTy, body, compensation, m) when IsRuntimeAsyncExceptionHandler g expr -> + | TryFinallyExpr(_, _, resultTy, body, compensation, m) when IsRuntimeAsyncExceptionHandler analyzer expr -> Some( rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionValue -> let result = @@ -99,7 +100,7 @@ let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = mkCompGenSequential m compensation result) ) - | TryWithExpr(_, _, resultTy, body, filterVal, filter, handlerVal, handler, m) when IsRuntimeAsyncExceptionHandler g expr -> + | TryWithExpr(_, _, resultTy, body, filterVal, filter, handlerVal, handler, m) when IsRuntimeAsyncExceptionHandler analyzer expr -> Some( rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionExpr -> let filter = @@ -117,7 +118,7 @@ let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = ) | _ -> None - if ExprContainsRuntimeAsyncExceptionHandler g expr then + if ExprContainsRuntimeAsyncExceptionHandler analyzer expr then RewriteExpr { PreIntercept = None diff --git a/src/Compiler/TypedTree/RuntimeAsync.fs b/src/Compiler/TypedTree/RuntimeAsync.fs index 702efb737d7..87abe6a036f 100644 --- a/src/Compiler/TypedTree/RuntimeAsync.fs +++ b/src/Compiler/TypedTree/RuntimeAsync.fs @@ -8,25 +8,42 @@ open FSharp.Compiler.TcGlobals open FSharp.Compiler.TypedTree open FSharp.Compiler.TypedTreeOps +type RuntimeAsyncReturnInfo = + { + Value: ValRef + Flags: ValUseFlag + Body: Expr + TypeArgs: TType list + } + +type RuntimeAsyncBoundary = + | ReturnMarker of RuntimeAsyncReturnInfo + | Suspension of ILMethodRef + let (|RuntimeAsyncReturn|_|) (g: TcGlobals) (vref: ValRef) = valRefEq g vref g.cgh__runtimeAsyncReturn_vref || valRefEq g vref g.cgh__runtimeAsyncReturnValueTask_vref || valRefEq g vref g.cgh__runtimeAsyncReturnUnit_vref || valRefEq g vref g.cgh__runtimeAsyncReturnValueTaskUnit_vref -let IsRuntimeAsyncReturnUnitExpr (g: TcGlobals) expr = - match stripExpr expr with - | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, [], [ _ ], _) -> true - | _ -> false - -let rec TryUnwrapRuntimeAsyncReturnExpr (g: TcGlobals) expr = +let rec TryGetRuntimeAsyncReturn (g: TcGlobals) expr = match expr with - | Expr.DebugPoint(_, innerExpr) -> - match TryUnwrapRuntimeAsyncReturnExpr g innerExpr with - | true, body -> true, body - | false, _ -> false, expr - | Expr.App(Expr.Val(RuntimeAsyncReturn g, _, _), _, _, [ body ], _) -> true, body - | _ -> false, expr + | Expr.DebugPoint(_, innerExpr) -> TryGetRuntimeAsyncReturn g innerExpr + | Expr.App(Expr.Val(RuntimeAsyncReturn g as value, flags, _), _, typeArgs, [ body ], _) -> + Some + { + Value = value + Flags = flags + Body = body + TypeArgs = typeArgs + } + | _ -> None + +let TryGetRuntimeAsyncReturnFunction (g: TcGlobals) expr = + match stripExpr expr with + | Expr.Val(RuntimeAsyncReturn g as value, flags, m) -> Some(value, flags, m) + | Expr.App(Expr.Val(RuntimeAsyncReturn g as value, flags, m), _, [ _ ], [], _) -> Some(value, flags, m) + | _ -> None let IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = let (TILObjectReprData(coreLibScope, _, _)) = g.system_Object_tcref.ILTyconInfo @@ -45,15 +62,11 @@ let IsRuntimeAsyncSuspensionExpr (g: TcGlobals) expr = | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) -> IsRuntimeAsyncSuspensionMethod g ilMethodRef | _ -> false -let ExprContainsRuntimeAsyncSuspension (g: TcGlobals) expr = - let folder = - { ExprFolder0 with - exprIntercept = - fun _ noInterceptF acc expr -> - if acc || IsRuntimeAsyncSuspensionExpr g expr then - true - else - noInterceptF acc expr - } - - FoldExpr folder false expr +let TryGetRuntimeAsyncBoundary (g: TcGlobals) expr = + match TryGetRuntimeAsyncReturn g expr with + | Some info -> Some(RuntimeAsyncBoundary.ReturnMarker info) + | None -> + match stripExpr expr with + | Expr.Op(TOp.ILCall(_, _, _, _, _, _, _, ilMethodRef, _, _, _), _, _, _) when IsRuntimeAsyncSuspensionMethod g ilMethodRef -> + Some(RuntimeAsyncBoundary.Suspension ilMethodRef) + | _ -> None From 93066e7884801b6a4b6432fc90c57cc3a72ebfa1 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 16:34:38 +0200 Subject: [PATCH 45/59] Add runtime async module signatures --- src/Compiler/FSharp.Compiler.Service.fsproj | 3 ++ .../Optimize/RuntimeAsyncAnalysis.fsi | 27 ++++++++++++++++++ .../Optimize/RuntimeAsyncExceptionRewrite.fsi | 8 ++++++ src/Compiler/TypedTree/RuntimeAsync.fsi | 28 +++++++++++++++++++ 4 files changed, 66 insertions(+) create mode 100644 src/Compiler/Optimize/RuntimeAsyncAnalysis.fsi create mode 100644 src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fsi create mode 100644 src/Compiler/TypedTree/RuntimeAsync.fsi diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index c304bf8d262..5f32f94a182 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -377,6 +377,7 @@ + @@ -450,7 +451,9 @@ + + diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fsi b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fsi new file mode 100644 index 00000000000..5c23047ad0c --- /dev/null +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fsi @@ -0,0 +1,27 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.RuntimeAsyncAnalysis + +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree + +type RuntimeAsyncAnalyzer = + new: g: TcGlobals * getLambdaBody: (ValRef -> Expr option) -> RuntimeAsyncAnalyzer + + member ContainsFragment: expr: Expr -> bool + member ContainsSuspension: expr: Expr -> bool + +val ShouldForceRuntimeAsyncInline: + analyzer: RuntimeAsyncAnalyzer -> runtimeAsyncContext: bool -> vref: ValRef -> inlineBody: Expr option -> bool + +val ShouldForceRuntimeAsyncApplication: + analyzer: RuntimeAsyncAnalyzer -> + runtimeAsyncContext: bool -> + vref: ValRef -> + inlineBody: Expr option -> + args: Expr list -> + bool + +val InlineRuntimeAsyncLambdaArgument: g: TcGlobals -> isRuntimeAsyncFragment: (Expr -> bool) -> expr: Expr -> Expr + +val GetRuntimeAsyncNonPreservableUses: g: TcGlobals -> expr: Expr -> Val list diff --git a/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fsi b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fsi new file mode 100644 index 00000000000..7f4607630d4 --- /dev/null +++ b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fsi @@ -0,0 +1,8 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.RuntimeAsyncExceptionRewrite + +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree + +val RewriteRuntimeAsyncExceptionHandlers: g: TcGlobals -> expr: Expr -> Expr diff --git a/src/Compiler/TypedTree/RuntimeAsync.fsi b/src/Compiler/TypedTree/RuntimeAsync.fsi new file mode 100644 index 00000000000..ab5411a46df --- /dev/null +++ b/src/Compiler/TypedTree/RuntimeAsync.fsi @@ -0,0 +1,28 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.RuntimeAsync + +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.Text +open FSharp.Compiler.TypedTree + +type RuntimeAsyncReturnInfo = + { Value: ValRef + Flags: ValUseFlag + Body: Expr + TypeArgs: TType list } + +type RuntimeAsyncBoundary = + | ReturnMarker of RuntimeAsyncReturnInfo + | Suspension of ILMethodRef + +val TryGetRuntimeAsyncReturn: g: TcGlobals -> expr: Expr -> RuntimeAsyncReturnInfo option + +val TryGetRuntimeAsyncReturnFunction: g: TcGlobals -> expr: Expr -> (ValRef * ValUseFlag * range) option + +val IsRuntimeAsyncSuspensionMethod: g: TcGlobals -> ilMethRef: ILMethodRef -> bool + +val IsRuntimeAsyncSuspensionExpr: g: TcGlobals -> expr: Expr -> bool + +val TryGetRuntimeAsyncBoundary: g: TcGlobals -> expr: Expr -> RuntimeAsyncBoundary option From bf4fdf9c9831775bf29015176812387abc810749 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 17:26:25 +0200 Subject: [PATCH 46/59] reenable more ported tests --- .../Language/RuntimeAsync/RuntimeTasks.fs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs index f785e743108..7b25f940a3a 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeTasks.fs @@ -386,10 +386,6 @@ let testDelay () = require (x = 0) "task already ran" t.Wait() -// KNOWN DIVERGENCE: moved to the known-failing section; the current runtime -// build does not run a runtime-async body synchronously up to its first real -// suspension, so "first part didn't run yet" fails. - let testNonBlocking () = let allowContinue = new SemaphoreSlim(0) let continueToFinish = new ManualResetEventSlim(false) @@ -741,7 +737,7 @@ let testForLoopSadPathComplex () = require caught "didn't catch exception" require disposed "never disposed A" -let knownFailing_testExceptionAttachedToTaskWithoutAwait () = +let testExceptionAttachedToTaskWithoutAwait () = for i in 1..5 do let mutable ranA = false let mutable ranB = false @@ -776,7 +772,7 @@ let knownFailing_testExceptionAttachedToTaskWithoutAwait () = require catcher.Result "didn't catch" require caught "didn't catch" -let knownFailing_testExceptionAttachedToTaskWithAwait () = +let testExceptionAttachedToTaskWithAwait () = for i in 1..5 do let mutable ranA = false let mutable ranB = false @@ -837,7 +833,7 @@ let testFixedStackWhileLoop () = t.Wait() require (t.Result = BIG) "didn't get to big number" -let knownFailing_testFixedStackForLoop () = // needs investigation: code after a suspending for loop is not run +let testFixedStackForLoop () = // needs investigation: code after a suspending for loop is not run for i in 1..100 do let mutable ran = false @@ -1512,7 +1508,7 @@ let testCustomAwaitable () = require (t3.Result = 42) "custom awaitable merge sources" -let knownFailing_testTaskUsesSyncContext () = // task completes without the body observably running when a SynchronizationContext is installed +let testTaskUsesSyncContext () = // task completes without the body observably running when a SynchronizationContext is installed for i in 1..5 do let mutable ran = false let mutable posted = false @@ -1591,6 +1587,7 @@ let main _ = testForLoopSadPath () testForLoopSadPathComplex () testFixedStackWhileLoop () + testFixedStackForLoop () testTypeInference () testNoStackOverflowWithImmediateResult () testNoStackOverflowWithYieldResult () @@ -1615,4 +1612,7 @@ let main _ = testUsingSadPath () testExceptionThrownInFinally () test2ndExceptionThrownInFinally () - 0 + testTaskUsesSyncContext () + testExceptionAttachedToTaskWithoutAwait () + testExceptionAttachedToTaskWithAwait () + 0 \ No newline at end of file From ef91fb3ae4bfbdb7b317ed2683e368c0d987c314 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 17:40:41 +0200 Subject: [PATCH 47/59] reduce diff --- src/Compiler/Optimize/Optimizer.fs | 97 ++++++++++++++---------------- 1 file changed, 46 insertions(+), 51 deletions(-) diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index 7ec7a28691e..a66018af1c4 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -2540,6 +2540,8 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = let env = { env with disableMethodSplitting = env.disableMethodSplitting || isStateMachineE } + let runtimeAsyncReturn = TryGetRuntimeAsyncReturn g expr + match expr with // treat the common linear cases to avoid stack overflows, using an explicit continuation | LinearOpExpr _ @@ -2584,38 +2586,37 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.Op (op, tyargs, args, m) -> OptimizeExprOp cenv env (op, tyargs, args, m) - | Expr.App (f, fty, tyargs, argsl, m) -> - match TryGetRuntimeAsyncReturn g expr with - | Some info -> - let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } info.Body - let reportedStamps = HashSet() - - for v in GetRuntimeAsyncNonPreservableUses g bodyR do - if reportedStamps.Add v.Stamp then - errorR(Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension(RichText.mkText v.DisplayName), v.Range)) - - let bodyR = RewriteRuntimeAsyncExceptionHandlers g bodyR - Expr.App(f, fty, tyargs, [ bodyR ], m), - { bodyInfo with - HasEffect = true - Info = UnknownValue } - | None -> - match expr with - | DelegateInvokeExpr g (delInvokeRef, delInvokeTy, tyargs, delExpr, delInvokeArg, m) -> - OptimizeFSharpDelegateInvoke cenv env (delInvokeRef, delExpr, delInvokeTy, tyargs, delInvokeArg, m) - | _ -> - let attempt = - if IsDebugPipeRightExpr cenv expr then - Some(OptimizeDebugPipeRights cenv env expr) - else - None + | Expr.App (f, fty, tyargs, _, m) when runtimeAsyncReturn.IsSome -> + let info = runtimeAsyncReturn.Value + let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } info.Body + let reportedStamps = HashSet() + + for v in GetRuntimeAsyncNonPreservableUses g bodyR do + if reportedStamps.Add v.Stamp then + errorR(Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension(RichText.mkText v.DisplayName), v.Range)) - match attempt with - | Some res -> res - | None -> - match TryDetectQueryQuoteAndRun cenv expr with - | Some newExpr -> OptimizeExpr cenv env newExpr - | None -> OptimizeApplication cenv env (f, fty, tyargs, argsl, m) + let bodyR = RewriteRuntimeAsyncExceptionHandlers g bodyR + Expr.App(f, fty, tyargs, [ bodyR ], m), + { bodyInfo with + HasEffect = true + Info = UnknownValue } + + | Expr.App (f, fty, tyargs, argsl, m) -> + match expr with + | DelegateInvokeExpr g (delInvokeRef, delInvokeTy, tyargs, delExpr, delInvokeArg, m) -> + OptimizeFSharpDelegateInvoke cenv env (delInvokeRef, delExpr, delInvokeTy, tyargs, delInvokeArg, m) + | _ -> + let attempt = + if IsDebugPipeRightExpr cenv expr then + Some (OptimizeDebugPipeRights cenv env expr) + else None + match attempt with + | Some res -> res + | None -> + // eliminate uses of query + match TryDetectQueryQuoteAndRun cenv expr with + | Some newExpr -> OptimizeExpr cenv env newExpr + | None -> OptimizeApplication cenv env (f, fty, tyargs, argsl, m) | Expr.Lambda (_lambdaId, _, _, argvs, _body, m, bodyTy) -> let valReprInfo = ValReprInfo ([], [argvs |> List.map (fun _ -> ValReprInfo.unnamedTopArg1)], ValReprInfo.unnamedRetVal) @@ -3272,6 +3273,7 @@ and OptimizeTraitCall cenv env (traitInfo, args, m) = match ConstraintSolver.CodegenWitnessExprForTraitConstraint cenv.TcVal g cenv.amap m traitInfoForResolution args with | OkResult (_, Some expr) -> OptimizeExpr cenv env expr + // Resolution fails when optimizing generic code, ignore the failure | _ -> match resolveWithRecordedSolution () with @@ -3752,6 +3754,13 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg let argsR = args |> List.map (OptimizeExpr cenv argEnv >> fst) let info = { TotalSize = 1; FunctionSize = 1; HasEffect = true; MightMakeCriticalTailcall = false; Info = UnknownValue } + let reduceRuntimeAsyncApplication specLambdaR specLambdaTy = + let reduced = MakeApplicationAndBetaReduce g (specLambdaR, specLambdaTy, [], argsR, m) + let reduced = + match reduced with + | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) + | _ -> reduced + Some(reoptimizeRuntimeAsync reduced, info) if canCallDirectly then Some(mkApps g ((exprForValRef m vref, vref.Type), [tyargs], argsR, m), info) @@ -3759,12 +3768,10 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg let origFinfo = GetInfoForVal cenv env m vref let lambdaInfo = - match stripValue finfo.Info with - | CurriedLambdaValue _ as info -> Some info - | _ -> - match stripValue origFinfo.ValExprInfo with - | CurriedLambdaValue _ as info -> Some info - | _ -> None + match stripValue finfo.Info, stripValue origFinfo.ValExprInfo with + | (CurriedLambdaValue _ as info), _ + | _, (CurriedLambdaValue _ as info) -> Some info + | _ -> None match lambdaInfo with | Some(CurriedLambdaValue(origLambdaId, _, _, origLambda, origLambdaTy)) -> @@ -3848,13 +3855,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg || capturedVals |> List.exists (fun v -> v.IsMutable) if not (List.isEmpty capturedVals) && cannotLiftCapturedVals then - let reduced = MakeApplicationAndBetaReduce g (specLambdaR, specLambdaTy, [], argsR, m) - let reduced = - match reduced with - | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) - | _ -> reduced - let reduced = reoptimizeRuntimeAsync reduced - Some(reduced, info) + reduceRuntimeAsyncApplication specLambdaR specLambdaTy else let debugValName = $"<{vref.LogicalName}>__debug" @@ -3883,13 +3884,7 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg None else if mustInlineRuntimeAsync then - let reduced = MakeApplicationAndBetaReduce g (specLambdaR, specLambdaTy, [], argsR, m) - let reduced = - match reduced with - | Expr.Let(bind, body, _, _) -> fst (TryEliminateLet cenv env bind body m) - | _ -> reduced - let reduced = reoptimizeRuntimeAsync reduced - Some(reduced, info) + reduceRuntimeAsyncApplication specLambdaR specLambdaTy else // Static method path (no witnesses needed): abstract over free typars so IlxGen emits // a method with flattened arguments rather than a closure that wraps args in Tuple<>. From 2ce231a0a3b7a70d64ffb574b4089943e6b6adb8 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 20:10:32 +0200 Subject: [PATCH 48/59] refactor --- .../Checking/Expressions/CheckExpressions.fs | 18 +++++++----------- src/Compiler/TypedTree/RuntimeAsync.fs | 8 ++++---- src/Compiler/TypedTree/RuntimeAsync.fsi | 2 +- 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index 4cdd7aad10f..7088d4c9401 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -8693,12 +8693,12 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl | DelayedApp (atomicFlag, isSugar, synLeftExprOpt, synArg, mExprAndArg) :: delayedList' -> let denv = env.DisplayEnv - let isRuntimeAsync = TryGetRuntimeAsyncReturnFunction g expr.Expr |> Option.isSome + match expr.Expr with + | RuntimeAsyncReturnFunction g _ -> () + | _ -> - match isRuntimeAsync, UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with - | true, _ -> - () - | false, ValueSome (_, resultTy) -> + match UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with + | ValueSome (_, resultTy) -> // We add tag parameter to the return type for "&x" and 'NativePtr.toByRef' // See RFC FS-1053.md @@ -8711,7 +8711,7 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl propagate isAddrOf delayedList' mExprAndArg resultTy - | false, _ -> + | _ -> let mArg = synArg.Range match synArg with // async { ... } @@ -8990,11 +8990,7 @@ and TcApplicationThen (cenv: cenv) (overallTy: OverallTy) env tpenv mExprAndArg let (|RuntimeAsyncApplication|_|) = function - | ApplicableExpr(expr=runtimeAsyncFunction) - when TryGetRuntimeAsyncReturnFunction g runtimeAsyncFunction |> Option.isSome -> - match TryGetRuntimeAsyncReturnFunction g runtimeAsyncFunction with - | None -> ValueNone - | Some(vref, flags, m) -> + | ApplicableExpr(expr = (RuntimeAsyncReturnFunction g (vref, flags, m))) -> checkLanguageFeatureAndRecover g.langVersion LanguageFeature.RuntimeAsync m let _, carrierTy = stripFunTy g exprTy diff --git a/src/Compiler/TypedTree/RuntimeAsync.fs b/src/Compiler/TypedTree/RuntimeAsync.fs index 87abe6a036f..0e6a53c0a40 100644 --- a/src/Compiler/TypedTree/RuntimeAsync.fs +++ b/src/Compiler/TypedTree/RuntimeAsync.fs @@ -39,11 +39,11 @@ let rec TryGetRuntimeAsyncReturn (g: TcGlobals) expr = } | _ -> None -let TryGetRuntimeAsyncReturnFunction (g: TcGlobals) expr = +let (|RuntimeAsyncReturnFunction|_|) (g: TcGlobals) expr = match stripExpr expr with - | Expr.Val(RuntimeAsyncReturn g as value, flags, m) -> Some(value, flags, m) - | Expr.App(Expr.Val(RuntimeAsyncReturn g as value, flags, m), _, [ _ ], [], _) -> Some(value, flags, m) - | _ -> None + | Expr.Val(RuntimeAsyncReturn g as value, flags, m) + | Expr.App(Expr.Val(RuntimeAsyncReturn g as value, flags, m), _, [ _ ], [], _) -> ValueSome(value, flags, m) + | _ -> ValueNone let IsRuntimeAsyncSuspensionMethod (g: TcGlobals) (ilMethRef: ILMethodRef) = let (TILObjectReprData(coreLibScope, _, _)) = g.system_Object_tcref.ILTyconInfo diff --git a/src/Compiler/TypedTree/RuntimeAsync.fsi b/src/Compiler/TypedTree/RuntimeAsync.fsi index ab5411a46df..7e15225d000 100644 --- a/src/Compiler/TypedTree/RuntimeAsync.fsi +++ b/src/Compiler/TypedTree/RuntimeAsync.fsi @@ -19,7 +19,7 @@ type RuntimeAsyncBoundary = val TryGetRuntimeAsyncReturn: g: TcGlobals -> expr: Expr -> RuntimeAsyncReturnInfo option -val TryGetRuntimeAsyncReturnFunction: g: TcGlobals -> expr: Expr -> (ValRef * ValUseFlag * range) option +val (|RuntimeAsyncReturnFunction|_|) : g: TcGlobals -> expr: Expr -> (ValRef * ValUseFlag * range) voption val IsRuntimeAsyncSuspensionMethod: g: TcGlobals -> ilMethRef: ILMethodRef -> bool From 65454ab4c2aa6c00deb3deeae5b51f28da67ecfd Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 20:32:37 +0200 Subject: [PATCH 49/59] format --- src/Compiler/TypedTree/RuntimeAsync.fsi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Compiler/TypedTree/RuntimeAsync.fsi b/src/Compiler/TypedTree/RuntimeAsync.fsi index 7e15225d000..580641aeb97 100644 --- a/src/Compiler/TypedTree/RuntimeAsync.fsi +++ b/src/Compiler/TypedTree/RuntimeAsync.fsi @@ -19,7 +19,7 @@ type RuntimeAsyncBoundary = val TryGetRuntimeAsyncReturn: g: TcGlobals -> expr: Expr -> RuntimeAsyncReturnInfo option -val (|RuntimeAsyncReturnFunction|_|) : g: TcGlobals -> expr: Expr -> (ValRef * ValUseFlag * range) voption +val (|RuntimeAsyncReturnFunction|_|): g: TcGlobals -> expr: Expr -> (ValRef * ValUseFlag * range) voption val IsRuntimeAsyncSuspensionMethod: g: TcGlobals -> ilMethRef: ILMethodRef -> bool From bc8e74c558a36a2f277aad92fbc385cb88fd3e2e Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 2 Sep 2026 20:50:21 +0200 Subject: [PATCH 50/59] update doc --- docs/runtime-async.md | 122 ++++++++++++++++++------------------------ 1 file changed, 53 insertions(+), 69 deletions(-) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 2d95e103f61..3fd00dba925 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -17,9 +17,9 @@ implemented, not an aspirational design. The .NET design is still evolving: how C# lowers `await` (including the exception-handling hoisting described below) The implementation targets functions, lambdas, and members returning -`System.Threading.Tasks.Task<'T>`, `Task`, `ValueTask<'T>`, or `ValueTask`. A -computation-expression builder exists in the component tests and works for a -subset of the surface, but is not part of FSharp.Core. +`System.Threading.Tasks.Task<'T>`, `Task`, `ValueTask<'T>`, or `ValueTask`. +Inline computation-expression builders can use the feature, but no such +builder is currently part of FSharp.Core. ## Runtime contract @@ -33,8 +33,8 @@ generic and non-generic `Task`, and generic and non-generic `ValueTask`. Suspension is explicit, via `System.Runtime.CompilerServices.AsyncHelpers`: * `Await` for `Task`, `ValueTask`, and configured awaitables -* `AwaitAwaiter` and `UnsafeAwaitAwaiter` for awaiters (used by the test - builder's SRTP `Bind`) +* `AwaitAwaiter` and `UnsafeAwaitAwaiter` for awaiters (used by SRTP + awaitable bindings) The compiler emits the adjacent IL sequence the runtime specification expects: @@ -48,18 +48,17 @@ Known runtime restrictions (currently **not** diagnosed by the F# compiler): * `tail.` and `localloc` are forbidden. * generated suspension points cannot occur inside exception-handling regions. Awaiting in a protected `try` body now works on the current runtime. Direct - intrinsic bodies rewrite suspending `catch`, filter, and `finally` - expressions so the suspension runs outside the EH region. + intrinsic bodies rewrite suspending `try/with` handlers and filters, and + `try/finally` compensations, so the suspension runs outside the EH region. C# avoids this by rewriting EH-region awaits at lowering time (see the Roslyn design doc): `try B finally { await x }` becomes `try B catch-all { pend e }`, then `await x` outside the region, then - rethrow the pending exception. The test `RuntimeTaskBuilder.Using` - prototypes this pattern in F# source: it captures the body result/exception - in a `Choice`, runs `DisposeAsync` (possibly suspending) *outside* the - `try`, then restores a pending exception. This makes `use` on an - `IAsyncDisposable` work under runtime async (`testUsingAsyncDisposableSync` - executes). + rethrow the pending exception. The compiler applies the same transformation + to a suspending compensation: it captures the body result or exception, + runs `DisposeAsync` (possibly suspending) *outside* the `try`, then restores + the pending exception. This makes `use` on an `IAsyncDisposable` work under + runtime async. Byref, byref-like, and pinned locals that are used after a suspension are rejected with diagnostic FS3917. @@ -225,59 +224,39 @@ probe of the *reference* assemblies; it does not prove the *executing* host JIT supports runtime-async. Compiling against new reference assemblies and running on an older runtime is not a supported configuration. -## Test infrastructure - -Tests live in `tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync*`: - -* The component test project sets `runtime-async=on` - (the .NET runtime opt-in), as does the project template in - `FSharp.Test.Utilities` used by `compileExeAndRun`. -* Type-check tests assert the preview gate (3350) and the unsupported-runtime - gate (3351, on non-.NET-Core targets). -* IL tests verify direct `AsyncHelpers.Await` calls appear without - intervening delegates. -* Execution tests (`RuntimeAsyncBasic.fs`, `RuntimeTasks.fs` with the shared - `RuntimeTaskBuilder.fs`) run with `compileExeAndRun`, so they compile with - the compiler under test and execute on the host runtime. -* Inline-fragment tests cover single- and multi-argument lambdas, returned - closures composed through `Bind`/`Combine`/`Delay`, and suspension in a - branch that is eliminated before code generation. -* `RuntimeTasksAsyncDisposalException.fs` documents the known - EH-region-suspension crash: it is compiled but not executed. - -### Test builder - -`RuntimeTaskBuilder.fs` is a quasi-synchronous builder aiming for feature -parity with FSharp.Core's `task` builder: `Delay` is the identity on -`unit -> 'T`, so all combinators are plain inline functions over delayed -code; only `Run` introduces `__runtimeAsyncReturn` and returns `Task<'T>`. -`Bind` lowers directly to `AsyncHelpers.Await` with SRTP fallbacks -(`AwaitAwaiter`) for arbitrary task-likes, as do `ReturnFrom` and -`MergeSources`. `MergeSources` awaits its sources sequentially, matching the -task builder — concurrency comes from the sources being hot tasks. -`Async<'T>` binds via `Async.StartImmediateAsTask`, matching `task {}`'s -current-thread semantics. - -`RuntimeTasks.fs` ports the TaskBuilder test suite -(`tests/FSharp.Core.UnitTests/.../Tasks.fs`) test-for-test with -`task {` replaced by `runtimeTask {`. Tests that hit the known runtime-async -restrictions or divergences are kept in the file with `knownFailing_` / -`knownDivergent_` prefixes, compiled but not run: - -* suspension in `try/finally`, or in `try/with` in non-tail position - (forbidden by the runtime contract; crashes with `0xC0000409` or loses the - finally); -* `use`/`use!` whose disposal awaits an `IAsyncDisposable` (the `Using` - compensation suspends in a `finally`); -* tests requiring synchronous (hot) start of the body before the first - suspension — on the current runtime build the body is not observably run - before the returned `Task` is awaited; -* `SynchronizationContext` capture: with a sync context installed, the task - completes without the body observably running. - -Two `task {}` inference behaviors are not matched by the overload set: -element-type propagation through `Bind` without an annotation, and unannotated -`return! failwith ...` (both need explicit annotations in the port). +## Computation-expression usage + +The feature is usable from an inline computation-expression builder. A +task-like builder can keep `Delay` and its other combinators synchronous and +inline; `Run` introduces the return marker: + +```fsharp +type RuntimeTaskBuilder() = + member inline _.Delay([] generator: unit -> 'T) = generator + member inline _.Run([] code: unit -> 'T) = + __runtimeAsyncReturn (code ()) + member inline _.Bind(task: Task<'T>, [] continuation: 'T -> 'U) = + continuation (AsyncHelpers.Await task) +``` + +`Bind`, `ReturnFrom`, and `MergeSources` can use `Await` for known +`Task`/`ValueTask` types and SRTP awaiter operations for arbitrary task-like +values. `MergeSources` awaits its already-started sources sequentially. +`Async<'T>` can be adapted with `Async.StartImmediateAsTask`. + +An async-sequence builder can use the same pattern to produce +`IAsyncEnumerable<'T>`. Its `Run` creates a producer that is started when +`GetAsyncEnumerator` is called. A `ManualResetValueTaskSourceCore` handshake +makes enumeration pull-driven: `yield` publishes one item and waits for the +next `MoveNextAsync` request. `yield!` and `for` can consume synchronous or +asynchronous enumerables, and nested async enumerables receive the caller's +cancellation token. A single active `MoveNextAsync` is enforced. A builder may +also hand off directly between compatible producers for `YieldFromFinal`, +avoiding a second enumeration handshake. + +These builders are examples rather than FSharp.Core APIs. Applications can +define their own inline builders over the same intrinsics, subject to the +runtime-async restrictions and inline-fragment rules described above. ### Unsupported inline-fragment positions @@ -290,9 +269,14 @@ this diagnostic. ## Not yet implemented -* Diagnostics for suspension in exception-handling regions, `tail.`, and - `localloc`. -* Any FSharp.Core builder (the test builder is test-only). +* Complete diagnostics for runtime restrictions. The optimizer rewrites + suspending `try/with` handlers and filters, and `try/finally` compensations, + so they execute outside exception-handling regions. There is no general + diagnostic for runtime-contract violations in other generated or imported + shapes, and `localloc` has no dedicated diagnostic. Runtime-async methods + suppress `tail.` emission rather than reporting it. +* A builder in FSharp.Core; builders using the feature are currently + application/library code. * Compile-time enforcement that the marker was actually consumed before code generation (a missed marker throws only when its FSharp.Core stub is reached at run time, or produces invalid IL as described above). From 6f58b8fe2211371233af96c760437d46e8ef5a2d Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Thu, 3 Sep 2026 07:15:50 +0200 Subject: [PATCH 51/59] cleanup --- .../FSharp.Compiler.ComponentTests.fsproj | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj index ba0d6f502ae..c176f32c56b 100644 --- a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj +++ b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj @@ -17,7 +17,6 @@ $(DefineConstants);DEBUG true - runtime-async=on true From 52deaff98799838a68f61551f9debfab2ae321c9 Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Thu, 3 Sep 2026 12:30:07 +0200 Subject: [PATCH 52/59] improve debug stepping --- docs/runtime-async.md | 25 +++++++ src/Compiler/Optimize/Optimizer.fs | 6 ++ .../Language/RuntimeAsyncTests.fs | 36 +++++++++ tests/FSharp.Test.Utilities/Compiler.fs | 75 +++++++++++++++++++ 4 files changed, 142 insertions(+) diff --git a/docs/runtime-async.md b/docs/runtime-async.md index 3fd00dba925..bd78b765d86 100644 --- a/docs/runtime-async.md +++ b/docs/runtime-async.md @@ -155,6 +155,15 @@ debug-point-wrapped lambdas, compiler-generated `let` wrappers, curried applications, and multi-argument lambdas. That step is required for computation-expression shapes where `Bind` returns a closure containing `Await`, and later `Combine`/`Delay` calls apply that closure. + +When runtime-async specialization is forced in a debug build, the builder +combinator is copied with its definition-site debug ranges remarked before +arguments are substituted. User continuation arguments keep their own ranges, +so `let!`, `do!`, `yield`, and other +computation-expression statements remain associated with the source that +authored them without exposing the implementation ranges of `Run`, `Bind`, +`Combine`, or `Yield`. + Dead branches eliminated by optimization do not reach code generation and do not produce a suspension-outside-runtime-async diagnostic. @@ -201,6 +210,22 @@ catch-all case (3), so compilation stays correct — the cost is an extra nested runtime-async helper method rather than marking the enclosing method directly. +## Debug stepping and call stacks + +The compiler emits ordinary Portable PDB sequence points for runtime-async +methods. It does not emit `StateMachineMethod` or async state-machine stepping +records because runtime-async methods have no compiler-generated `MoveNext` +method. Forced inlining therefore preserves user computation-expression +sequence points in the generated runtime-async method while remapping the +inlined builder implementation ranges. + +Suspension, continuation mapping, and reconstruction of logical async call +stacks are owned by the runtime and debugger through the `Async` method +implementation flag and the runtime-async debug information contract. Missing +logical frames after a continuation cannot be repaired by inventing F# state +machine metadata; such cases must be validated against the target runtime and +tracked with the runtime/debugger implementation. + Case (3) re-homes the marker argument into a compiler-synthesized closure during code generation, *after* `LowerLocalMutables` has run. Without special handling, mutable locals used both in that body and in the enclosing scope diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index a66018af1c4..b7a5928451a 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -3827,6 +3827,12 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg specLambda specLambdaR + let specLambdaR = + if mustInlineRuntimeAsync then + remarkExpr m specLambdaR + else + specLambdaR + // Abstract the specialized lambda over its free typars so IlxGen emits a static // method with flattened arguments. The alternative closure form (valReprInfo = None) // wraps args in a reference Tuple<>, which cannot hold byrefs and fails to load at diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 296e53e7d20..4f860b25850 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -405,6 +405,42 @@ let ``runtime async enumerable builder fixture executes`` (optimize: bool) = |> compileExeAndRun |> shouldSucceed +[] +let ``runtime async enumerable CE debug points stay at call sites`` () = + let source = + """module RuntimeAsyncEnumerableDebug +open System.Threading.Tasks +open RuntimeAsyncEnumerable + +let first () = + asyncSeq { + do! Task.Delay 1 + yield 1 + } + +let second () = + asyncSeq { + do! Task.Delay 1 + yield 2 + } +""" + + FsFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTaskBuilder.fs")) + |> withAdditionalSourceFile ( + SourceFromPath (Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeAsyncEnumerable.fs")) + ) + |> withAdditionalSourceFile (FsSourceWithFileName "RuntimeAsyncEnumerableDebug.fs" source) + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> withPortablePdb + |> withNoOptimize + |> compile + |> shouldSucceed + |> verifyPdb [ + VerifyRuntimeAsyncMethodSequencePointsInSource("RuntimeAsyncEnumerableDebug.fs", 6, 8) + VerifyRuntimeAsyncMethodSequencePointsInSource("RuntimeAsyncEnumerableDebug.fs", 12, 14) + ] + [] let ``runtime async suspension in exception region executes`` () = Path.Combine(__SOURCE_DIRECTORY__, "RuntimeAsync", "RuntimeTasksAsyncDisposalException.fs") diff --git a/tests/FSharp.Test.Utilities/Compiler.fs b/tests/FSharp.Test.Utilities/Compiler.fs index 2d7b7e077cb..1adc7bf814e 100644 --- a/tests/FSharp.Test.Utilities/Compiler.fs +++ b/tests/FSharp.Test.Utilities/Compiler.fs @@ -1511,6 +1511,7 @@ $ code --diff {outFile} {expectedFile} | VerifyDocuments of string list | VerifySequencePointsInSameMethod of lines: Line list | VerifyNoDebuggerHiddenOnMethodWithLine of line: Line + | VerifyRuntimeAsyncMethodSequencePointsInSource of sourceFileName: string * startLine: int * endLine: int | Dummy of unit let private verifyPdbFormat (reader: MetadataReader) compilationType = @@ -1609,6 +1610,73 @@ $ code --diff {outFile} {expectedFile} if actualPoints.IsEmpty then failwith (sprintf "Method '%s' has no non-hidden sequence points" methodName) + let private verifyRuntimeAsyncMethodSequencePointsInSource + (assemblyPath: string) + (pdbReader: MetadataReader) + (sourceFileName: string) + (startLine: int) + (endLine: int) + = + use peStream = File.OpenRead(assemblyPath) + use peReader = new PEReader(peStream) + let assemblyReader = peReader.GetMetadataReader() + let asyncBit = 0x2000 + + let methods = + getMethodDebugInfos assemblyReader pdbReader + |> List.choose (fun (typeName, methodName, methodHandle, debugInfo) -> + let method = assemblyReader.GetMethodDefinition methodHandle + let isRuntimeAsync = (int method.ImplAttributes &&& asyncBit) <> 0 + + let points = + debugInfo.GetSequencePoints() + |> Seq.filter (fun point -> not point.IsHidden) + |> Seq.toList + + let hasSourcePoint = + points + |> List.exists (fun point -> + let document = pdbReader.GetDocument point.Document + let documentName = pdbReader.GetString document.Name + String.Equals(Path.GetFileName(documentName), sourceFileName, StringComparison.OrdinalIgnoreCase) + && point.StartLine >= startLine + && point.EndLine <= endLine) + + if isRuntimeAsync && hasSourcePoint then + Some(typeName, methodName, points) + else + None) + + if methods.Length <> 1 then + let names = methods |> List.map (fun (typeName, methodName, _) -> $"{typeName}.{methodName}") + failwith $"Expected exactly one runtime-async method with a point in {sourceFileName}:{startLine}-{endLine}, found {methods.Length}: {names}" + + let typeName, methodName, points = methods.Head + + let invalidPoints = + points + |> List.filter (fun point -> + let document = pdbReader.GetDocument point.Document + let documentName = pdbReader.GetString document.Name + + not ( + String.Equals(Path.GetFileName(documentName), sourceFileName, StringComparison.OrdinalIgnoreCase) + && point.StartLine >= startLine + && point.EndLine <= endLine + )) + + if not invalidPoints.IsEmpty then + let actual = + invalidPoints + |> List.map (fun point -> + let document = pdbReader.GetDocument point.Document + let documentName = pdbReader.GetString document.Name + $"{Path.GetFileName(documentName)}:{point.StartLine},{point.StartColumn}-{point.EndLine},{point.EndColumn}") + |> String.concat "; " + + failwith + $"Runtime-async method {typeName}.{methodName} has sequence points outside {sourceFileName}:{startLine}-{endLine}: {actual}" + let private verifySequencePoints (reader: MetadataReader) expectedSequencePoints = let sequencePoints = [ for sp in reader.MethodDebugInformation do @@ -1779,6 +1847,13 @@ $ code --diff {outFile} {expectedFile} verifySequencePointsInSameMethod (optOutputPath |> Option.defaultValue "") reader lines | VerifyNoDebuggerHiddenOnMethodWithLine line -> verifyNoDebuggerHiddenOnMethodWithLine (optOutputPath |> Option.defaultValue "") reader line + | VerifyRuntimeAsyncMethodSequencePointsInSource(sourceFileName, startLine, endLine) -> + verifyRuntimeAsyncMethodSequencePointsInSource + (optOutputPath |> Option.defaultValue "") + reader + sourceFileName + startLine + endLine | _ -> failwith $"Unknown verification option: {option.ToString()}" module private Il = From 97bfa0ed3ba8a7dc838f017c8d157e0eb34af261 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 8 Sep 2026 07:26:00 +0200 Subject: [PATCH 53/59] icrease pool size brcause for debug runs --- src/Compiler/SyntaxTree/LexFilter.fs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Compiler/SyntaxTree/LexFilter.fs b/src/Compiler/SyntaxTree/LexFilter.fs index 290f8b0ff45..9fbf83ba817 100644 --- a/src/Compiler/SyntaxTree/LexFilter.fs +++ b/src/Compiler/SyntaxTree/LexFilter.fs @@ -477,7 +477,7 @@ type TokenTupPool() = /// When parsing the compiler's source files, the pool didn't come close to reaching this limit. /// Therefore, this seems like a reasonable limit to handle 99% of cases. [] - let maxSize = 100 + let maxSize = 200 let mutable currentPoolSize = 0 let stack = Stack(10) From 24e3f3f4443990f7c48c0e06dd780976775fce2e Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 8 Sep 2026 07:29:24 +0200 Subject: [PATCH 54/59] add failing code to test fixture --- .../RuntimeAsync/RuntimeAsyncEnumerable.fs | 4 +-- .../RuntimeAsyncEnumerableTests.fs | 29 +++++++++++++++++++ 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs index c49addb7b00..d93261f52e7 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerable.fs @@ -173,7 +173,7 @@ type AsyncSeqBuilder() = fun state -> continuation values state member inline _.Combine( - first: AsyncSequenceBody<'T>, + [] first: AsyncSequenceBody<'T>, [] second: AsyncSequenceBody<'T> ) : AsyncSequenceBody<'T> = fun state -> @@ -214,7 +214,7 @@ type AsyncSeqBuilder() = | _ -> () member inline _.While( - guard: unit -> bool, + [] guard: unit -> bool, [] body: AsyncSequenceBody<'T> ) : AsyncSequenceBody<'T> = fun state -> diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs index 2e43b8cff98..532257c81b9 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsync/RuntimeAsyncEnumerableTests.fs @@ -9,6 +9,35 @@ open RuntimeTaskBuilder open RuntimeTaskBuilder.RuntimeTask open AsyncSeqAwaitableExtensions +// Test that the runtime-async computation is not split by the Optimizer +let except (itemsToExclude: IAsyncEnumerable<_>) (source: IAsyncEnumerable<_>) = + + asyncSeq { + use e = source.GetAsyncEnumerator CancellationToken.None + let! hasFirst = e.MoveNextAsync() + + if hasFirst then + // only create hashset by the time we actually start iterating; + // taskSeq enumerates sequentially, so a plain HashSet suffices — no locking needed. + let hashSet = HashSet<_>(HashIdentity.Structural) + + use excl = itemsToExclude.GetAsyncEnumerator CancellationToken.None + + while! excl.MoveNextAsync() do + hashSet.Add excl.Current |> ignore + + // if true, it was added, and therefore unique, so we return it + // if false, it existed, and therefore a duplicate, and we skip + if hashSet.Add e.Current then + yield e.Current + + while! e.MoveNextAsync() do + let current = e.Current + + if hashSet.Add current then + yield current + } + let private assertEqual name expected actual = if expected <> actual then failwithf "%s failed. Expected %A, got %A." name expected actual From c0d02996f12cb2ec218ebb2849a1da002ac21cb0 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Tue, 8 Sep 2026 07:35:06 +0200 Subject: [PATCH 55/59] disalow runtime async fragments in ComputeSplitToMethodCondition --- src/Compiler/Optimize/Optimizer.fs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index eafec6b0b94..46195facde5 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -4459,6 +4459,9 @@ and ComputeSplitToMethodCondition flag threshold cenv env (e: Expr, einfo) = // NOTE: The method splitting optimization is completely disabled if we are not taking tailcalls. cenv.emitTailcalls && not env.disableMethodSplitting && + // Never split a runtime-async body: the split-off method would not be a runtime-async + // method, so its Await calls would be rejected by IlxGen (FS3916). + not (env.runtimeAsyncContext && RuntimeAsyncAnalyzer(g, fun _ -> None).ContainsSuspension e) && einfo.FunctionSize >= threshold && // We can only split an expression out as a method if certain conditions are met. From dac7883491cf616157524e01368c7bbce2c9504a Mon Sep 17 00:00:00 2001 From: majocha <1760221+majocha@users.noreply.github.com> Date: Wed, 9 Sep 2026 13:37:58 +0200 Subject: [PATCH 56/59] update surface --- .../FSharp.Core.SurfaceArea.netcore.release.bsl | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl index 92e494cb328..9b950b191b1 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.release.bsl @@ -620,9 +620,12 @@ Microsoft.FSharp.Control.AsyncActivation`1[T]: Void OnExceptionRaised() Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Empty Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] Ignore[T](Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] ParallelDoLimit(Int32, System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] SequentialDo(System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit]]) Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.Unit] get_Empty() Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Control.FSharpAsync`1[TResult]], Microsoft.FSharp.Control.FSharpAsync`1[T]) Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], Microsoft.FSharp.Control.FSharpAsync`1[T]) +Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T[]] ParallelLimit[T](Int32, System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Control.FSharpAsync`1[T]]) Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], Microsoft.FSharp.Control.FSharpAsync`1[T]) Microsoft.FSharp.Control.AsyncModule: Microsoft.FSharp.Control.FSharpAsync`1[T] Result[T](T) Microsoft.FSharp.Control.AsyncPrimitives: Microsoft.FSharp.Control.AsyncReturn Bind[T,TResult](Microsoft.FSharp.Control.AsyncActivation`1[T], Microsoft.FSharp.Control.FSharpAsync`1[TResult], Microsoft.FSharp.Core.FSharpFunc`2[TResult,Microsoft.FSharp.Control.FSharpAsync`1[T]]) @@ -824,12 +827,17 @@ Microsoft.FSharp.Control.TaskBuilderModule: Microsoft.FSharp.Control.TaskBuilder Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Empty Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] Ignore[T](System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] ParallelDoLimit(Int32, System.Threading.CancellationToken, System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit]]]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] SequentialDo(System.Threading.CancellationToken, System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit]]]) Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[Microsoft.FSharp.Core.Unit] get_Empty() Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Bind[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Threading.Tasks.Task`1[TResult]], System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[TResult] Map[T,TResult](Microsoft.FSharp.Core.FSharpFunc`2[T,TResult], System.Threading.Tasks.Task`1[T]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T[]] ParallelLimit[T](Int32, System.Threading.CancellationToken, System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]]) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T[]] Sequential[T](System.Threading.CancellationToken, System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,System.Threading.Tasks.Task`1[T]]]) Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] CatchWith[T](Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,T], System.Threading.Tasks.Task`1[T]) Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] OfValueTask[T](System.Threading.Tasks.ValueTask`1[T]) Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] Result[T](T) +Microsoft.FSharp.Control.TaskModule: System.Threading.Tasks.Task`1[T] StartAsyncImmediate[T](System.Threading.CancellationToken, Microsoft.FSharp.Control.FSharpAsync`1[T]) Microsoft.FSharp.Control.TaskStateMachineData`1[T]: System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[T] MethodBuilder Microsoft.FSharp.Control.TaskStateMachineData`1[T]: T Result Microsoft.FSharp.Control.ValueTaskModule: System.Threading.Tasks.ValueTask`1[Microsoft.FSharp.Core.FSharpResult`2[T,System.Exception]] Catch[T](System.Threading.Tasks.ValueTask`1[T]) From 6fa01aa485148045e879b092f6f271251b9e48e6 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 11 Sep 2026 08:05:45 +0200 Subject: [PATCH 57/59] review: add failing test cases --- .../Language/RuntimeAsyncEdgeCaseTests.fs | 24 ++ .../Language/RuntimeAsyncTests.fs | 218 ++++++++++++++++++ 2 files changed, 242 insertions(+) diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs index a6830b03820..bfa7da929ac 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncEdgeCaseTests.fs @@ -43,6 +43,17 @@ let private compileDirect body = |> withLangVersionPreview |> compile +let private assertSingleDiagnostic errorNumber (result: CompilationResult) = + let diagnostics = + result.Output.Diagnostics + |> List.filter (fun diagnostic -> + match diagnostic.Error with + | Error number -> number = errorNumber + | _ -> false) + + Assert.Equal(1, List.length diagnostics) + result + // ---- CE-builder sources (compiled against RuntimeTaskBuilder.fs, the hypothetical library) ------- // ref-struct-across-suspension written through the CE builder: the `do!` desugars to a continuation @@ -434,6 +445,19 @@ let ``non-preservable value not used after suspension is allowed`` () = "let f (x: byref) : Task = StateMachineHelpers.__runtimeAsyncReturn (AsyncHelpers.Await(Task.Delay(1)); 1)" |> shouldSucceed +[] +let ``runtime async reports a byref local after suspension once`` () = + FSharp( + directIntrinsicSource + "let f (a: int[]) : Task = StateMachineHelpers.__runtimeAsyncReturn (let p = &a.[0] in AsyncHelpers.Await(Task.Delay(1)); p)" + ) + |> withOptions [ "--extraoptimizationloops:1" ] + |> withFSharpCoreShippedNet + |> withLangVersionPreview + |> compile + |> shouldFail + |> assertSingleDiagnostic 3917 + [] // The CE builder rejects a ref-struct local captured by its continuation lambda (FS0406). let ``ref struct across a suspension is rejected through the CE builder`` () = diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 4f860b25850..28e49e72ccc 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -322,6 +322,223 @@ let main _ = |> compileExeAndRun |> shouldSucceed +[] +[] +[] +let ``runtime async preserves reraise after a suspending handler`` (optimize: bool) = + FSharp """ +module RuntimeAsyncReraiseTest + +open System +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +let f () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + try + failwith "boom" + 0 + with _ -> + AsyncHelpers.Await(Task.Delay 1) + reraise ()) + +[] +let main _ = + f().GetAwaiter().GetResult() +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> withOptimization optimize + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async rejects stackalloc across suspension`` () = + FSharp """ +module RuntimeAsyncStackallocTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices +open Microsoft.FSharp.NativeInterop + +let f () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + let p = NativePtr.stackalloc 1 + NativePtr.write p 42 + AsyncHelpers.Await(Task.Delay 1) + NativePtr.read p) +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compile + |> shouldFail + +[] +let ``runtime async rejects stackalloc without suspension`` () = + FSharp """ +module RuntimeAsyncStackallocWithoutSuspensionTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices +open Microsoft.FSharp.NativeInterop + +let f () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + let p = NativePtr.stackalloc 1 + NativePtr.write p 42 + NativePtr.read p) +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compile + |> shouldFail + +[] +let ``runtime async rejects a byref captured by an inlined closure`` () = + FSharp """ +module RuntimeAsyncByrefClosureTest + +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +[] +let f (x: byref) : Task = + let y = x + StateMachineHelpers.__runtimeAsyncReturn (x + y) +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compile + |> shouldFail + |> withErrorCode 406 + +[] +[] +[] +let ``runtime async does not duplicate effectful InlineIfLambda arguments`` (optimize: bool) = + FSharp """ +module RuntimeAsyncInlineIfLambdaEffectsTest + +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +let mutable calls = 0 + +let effect () = + calls <- calls + 1 + fun () -> 1 + +let inline plainTwice ([] f) = f () + f () +let inline twice ([] f) = StateMachineHelpers.__runtimeAsyncReturn (f () + f ()) +let inline unused ([] f) = StateMachineHelpers.__runtimeAsyncReturn 20 + +[] +let main _ = + let plainResult = plainTwice (effect ()) + let plainCalls = calls + calls <- 0 + let twiceResult = (twice (effect ())).GetAwaiter().GetResult() + let twiceCalls = calls + calls <- 0 + let unusedResult = (unused (effect ())).GetAwaiter().GetResult() + let unusedCalls = calls + + if plainResult = 2 && plainCalls = 1 + && twiceResult = 2 && twiceCalls = 1 + && unusedResult = 20 && unusedCalls = 1 then + 0 + else + 1 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> withOptimization optimize + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async pipe syntax is gated by the language version`` () = + FSharp """ +module RuntimeAsyncPipeGateTest + +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let f (x: int) : Task = + x |> StateMachineHelpers.__runtimeAsyncReturn +""" + |> withLangVersion90 + |> withFSharpCoreShippedNet + |> compile + |> shouldFail + |> withErrorCode 3350 + +[] +[] +[] +let ``runtime async preserves evaluation order for curried inline applications`` (optimize: bool) = + FSharp """ +module RuntimeAsyncCurriedApplicationTest + +open System.Threading.Tasks +open Microsoft.FSharp.Core.CompilerServices + +let events = ResizeArray() + +let step name value = + events.Add name + value + +let inline apply f x y = f x y + +let f () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + apply + (fun x -> + events.Add "body" + fun y -> x + y) + (step "arg1" 1) + (step "arg2" 2)) + +[] +let main _ = + let result = f().GetAwaiter().GetResult() + + if result = 3 && (events |> Seq.toList) = [ "arg1"; "arg2"; "body" ] then + 0 + else + 1 +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> withOptimization optimize + |> compileExeAndRun + |> shouldSucceed + +[] +let ``runtime async rejects synchronized methods`` () = + FSharp """ +module RuntimeAsyncSynchronizedTest + +open System +open System.Threading.Tasks +open System.Runtime.CompilerServices +open Microsoft.FSharp.Core.CompilerServices + +[] +let f () : Task = + StateMachineHelpers.__runtimeAsyncReturn ( + AsyncHelpers.Await(Task.Delay(1).ContinueWith(fun _ -> 1))) +""" + |> withLangVersionPreview + |> withFSharpCoreShippedNet + |> compile + |> shouldFail + [] let ``runtime async combines awaited chunks without delegates`` () = FSharp runtimeAsyncRawSource @@ -355,6 +572,7 @@ let ``runtime task builder fixture executes through runtime async`` (optimize: b |> withFSharpCoreShippedNet |> withOptimization optimize |> compileExeAndRun + |> shouldSucceed [] let ``runtime task AsyncLocal values propagate through runtime async`` () = From 004f393ec93ef60633c524ca45e8aca8032f6ff7 Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 11 Sep 2026 08:05:56 +0200 Subject: [PATCH 58/59] update debug surface area --- .../FSharp.Core.SurfaceArea.netcore.debug.bsl | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl index 9c43a6bc4d8..697f65eef45 100644 --- a/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl +++ b/tests/FSharp.Core.UnitTests/FSharp.Core.SurfaceArea.netcore.debug.bsl @@ -1001,7 +1001,10 @@ Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData]: Void Invoke(Microsoft.FSharp.Core.CompilerServices.ResumableStateMachine`1[TData] ByRef, System.Runtime.CompilerServices.IAsyncStateMachine) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Boolean __useResumableCode[T]() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Microsoft.FSharp.Core.FSharpOption`1[System.Int32] __resumableEntry() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task __runtimeAsyncReturnUnit() Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.Task`1[T] __runtimeAsyncReturn[T](T) +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.ValueTask __runtimeAsyncReturnValueTaskUnit() +Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: System.Threading.Tasks.ValueTask`1[T] __runtimeAsyncReturnValueTask[T](T) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: T __resumeAt[T](Int32) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: TResult __stateMachine[TData,TResult](Microsoft.FSharp.Core.CompilerServices.MoveNextMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.SetStateMachineMethodImpl`1[TData], Microsoft.FSharp.Core.CompilerServices.AfterCode`2[TData,TResult]) Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers: Void __debugPoint(System.String) From 0f4e60239b0c7ec534088c0444d8990cffba7c2c Mon Sep 17 00:00:00 2001 From: Jakub Majocha <1760221+majocha@users.noreply.github.com> Date: Fri, 11 Sep 2026 10:09:22 +0200 Subject: [PATCH 59/59] address review --- .../Checking/Expressions/CheckExpressions.fs | 8 ++++- src/Compiler/CodeGen/IlxGen.fs | 35 +++++++++++++++++++ src/Compiler/FSComp.txt | 4 ++- src/Compiler/Optimize/Optimizer.fs | 34 ++++++++++-------- src/Compiler/Optimize/RuntimeAsyncAnalysis.fs | 28 ++++++++++++--- .../Optimize/RuntimeAsyncExceptionRewrite.fs | 26 +++++++++++++- src/Compiler/xlf/FSComp.txt.cs.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.de.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.es.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.fr.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.it.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.ja.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.ko.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.pl.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.pt-BR.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.ru.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.tr.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.zh-Hans.xlf | 10 ++++++ src/Compiler/xlf/FSComp.txt.zh-Hant.xlf | 10 ++++++ .../Language/RuntimeAsyncTests.fs | 20 ++++++++--- 20 files changed, 259 insertions(+), 26 deletions(-) diff --git a/src/Compiler/Checking/Expressions/CheckExpressions.fs b/src/Compiler/Checking/Expressions/CheckExpressions.fs index d37199d9916..b9e1ed1995e 100644 --- a/src/Compiler/Checking/Expressions/CheckExpressions.fs +++ b/src/Compiler/Checking/Expressions/CheckExpressions.fs @@ -8690,7 +8690,13 @@ and Propagate (cenv: cenv) (overallTy: OverallTy) (env: TcEnv) tpenv (expr: Appl let denv = env.DisplayEnv match expr.Expr with - | RuntimeAsyncReturnFunction g _ -> () + | RuntimeAsyncReturnFunction g _ -> + checkLanguageFeatureAndRecover g.langVersion LanguageFeature.RuntimeAsync mExpr + | OpPipeRight g (_, _, fExpr, _) + | OpPipeRight2 g (_, _, _, fExpr, _) + | OpPipeRight3 g (_, _, _, _, fExpr, _) + when TryGetRuntimeAsyncReturn g fExpr |> Option.isSome -> + checkLanguageFeatureAndRecover g.langVersion LanguageFeature.RuntimeAsync mExpr | _ -> match UnifyFunctionTypeUndoIfFailed cenv denv mExpr exprTy with diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs index fe101f2932f..d7bb6555e20 100644 --- a/src/Compiler/CodeGen/IlxGen.fs +++ b/src/Compiler/CodeGen/IlxGen.fs @@ -3428,6 +3428,16 @@ and GenExprAux (cenv: cenv) (cgbuf: CodeGenBuffer) eenv expr (sequel: sequel) = // changes, the marker expression would reach GenExprAux again and recurse without bound. and GenRuntimeAsyncReturnAsStartedTask cenv cgbuf eenv expr sequel = let m = expr.Range + + let nonPreservableFreeVal = + (freeInExpr CollectLocals expr).FreeLocals + |> Zset.elements + |> List.tryFind (fun v -> v.IsPinning || isByrefTy cenv.g v.Type || isByrefLikeTy cenv.g m v.Type) + + match nonPreservableFreeVal with + | Some v -> errorR (Error(FSComp.SR.chkByrefUsedInInvalidWay (richTextOfValName cenv.g v), v.Range)) + | None -> () + let unitVal, _ = mkLocal m "unit" cenv.g.unit_ty let lambdaExpr = mkLambda m unitVal (expr, tyOfExpr cenv.g expr) let lambdaTy = tyOfExpr cenv.g lambdaExpr @@ -5522,6 +5532,14 @@ and GenWhileLoop cenv cgbuf eenv (spWhile, condExpr, bodyExpr, m) sequel = and GenAsmCode cenv cgbuf eenv (il, tyargs, args, returnTys, m) sequel = let g = cenv.g + + if + eenv.inRuntimeAsyncMethod + && not eenv.inInlineMethod + && List.contains I_localloc il + then + errorR (Error(FSComp.SR.ilRuntimeAsyncStackAllocation (), m)) + let ilTyArgs = GenTypesPermitVoid cenv m eenv.tyenv tyargs let ilReturnTys = GenTypesPermitVoid cenv m eenv.tyenv returnTys @@ -7173,6 +7191,11 @@ and GenGenericArgs cenv m (tyenv: TypeReprEnv) tps = |> DropErasedTypars |> List.map (fun tp -> GenType cenv m tyenv (mkTyparTy tp)) +and CheckRuntimeAsyncFreeVars g m (cloinfo: IlxClosureInfo) = + for fv in cloinfo.cloFreeVars do + if fv.IsPinning || isByrefTy g fv.Type || isByrefLikeTy g m fv.Type then + errorR (Error(FSComp.SR.chkByrefUsedInInvalidWay (richTextOfValName g fv), fv.Range)) + /// Generate a local type function contract class and implementation and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr m = let g = cenv.g @@ -7205,6 +7228,9 @@ and GenClosureAsLocalTypeFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars expr | Some info -> true, List.isEmpty info.TypeArgs, info.Body | None -> false, false, body + if isRuntimeAsync then + CheckRuntimeAsyncFreeVars g m cloinfo + let eenvinner = { eenvinner with inRuntimeAsyncMethod = isRuntimeAsync @@ -7270,6 +7296,9 @@ and GenClosureAsFirstClassFunction cenv (cgbuf: CodeGenBuffer) eenv thisVars m e | Some info -> true, List.isEmpty info.TypeArgs, info.Body | None -> false, false, body + if isRuntimeAsync then + CheckRuntimeAsyncFreeVars g m cloinfo + let eenvinner = { eenvinner with inRuntimeAsyncMethod = isRuntimeAsync @@ -9942,6 +9971,9 @@ and GenMethodForBinding | Some info -> true, List.isEmpty info.TypeArgs, info.Body | None -> false, false, methLambdaBody + if isRuntimeAsync then + checkLanguageFeatureError g.langVersion LanguageFeature.RuntimeAsync m + let nonUnitNonSelfMethodVars, body = BindUnitVars cenv.g (nonSelfMethodVars, paramInfos, methLambdaBody) @@ -10091,6 +10123,9 @@ and GenMethodForBinding let hasPreserveSigImplFlag, hasSynchronizedImplFlag, hasNoInliningFlag, hasAggressiveInliningImplFlag, attrs = ComputeMethodImplAttribs cenv v attrs + if isRuntimeAsync && hasSynchronizedImplFlag then + error (Error(FSComp.SR.ilRuntimeAsyncSynchronizedMethod (), m)) + let securityAttributes, attrs = attrs |> List.partition (fun a -> IsSecurityAttribute g cenv.amap cenv.casApplied a m) diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt index 1014ed43dd1..285925d7ff3 100644 --- a/src/Compiler/FSComp.txt +++ b/src/Compiler/FSComp.txt @@ -1819,4 +1819,6 @@ featureRecordSpreads,"record type and expression spreads" 3914,tcExtendedLayoutStructMustHaveInstanceField,"A struct with the 'ExtendedLayoutAttribute' must have at least one instance field" 3915,tcTupleTypeExtensionTooManyElements,"Tuple type extensions are supported only for tuples of up to 7 elements, but this tuple type has %d elements. Extensions of larger tuples are not supported." 3916,ilRuntimeAsyncSuspensionOutsideRuntimeAsync,"Runtime async suspension method '%s' may only be called from a runtime async method." -3917,ilRuntimeAsyncLocalUsedAfterSuspension,"A byref, byref-like, or pinned local '%s' cannot be used after a runtime async suspension." \ No newline at end of file +3917,ilRuntimeAsyncLocalUsedAfterSuspension,"A byref, byref-like, or pinned local '%s' cannot be used after a runtime async suspension." +3918,ilRuntimeAsyncStackAllocation,"Stack allocation is not permitted in a runtime async method." +3919,ilRuntimeAsyncSynchronizedMethod,"A runtime async method cannot use MethodImplOptions.Synchronized." \ No newline at end of file diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs index 46195facde5..6cf5ce209c2 100644 --- a/src/Compiler/Optimize/Optimizer.fs +++ b/src/Compiler/Optimize/Optimizer.fs @@ -506,6 +506,9 @@ type IncrementalOptimizationEnv = /// Indicates that the expression being optimized is the body of a runtime-async marker. runtimeAsyncContext: bool + /// Runtime async diagnostics must only be reported once across optimization passes. + runtimeAsyncReportedRanges: HashSet + } static member Empty = @@ -521,7 +524,8 @@ type IncrementalOptimizationEnv = referencedCcus = [] earlierImplFileSignatures = [] debugInlineCallSite = None - runtimeAsyncContext = false } + runtimeAsyncContext = false + runtimeAsyncReportedRanges = HashSet() } override x.ToString() = "" @@ -2589,10 +2593,8 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr = | Expr.App (f, fty, tyargs, _, m) when runtimeAsyncReturn.IsSome -> let info = runtimeAsyncReturn.Value let bodyR, bodyInfo = OptimizeExpr cenv { env with runtimeAsyncContext = true } info.Body - let reportedStamps = HashSet() - for v in GetRuntimeAsyncNonPreservableUses g bodyR do - if reportedStamps.Add v.Stamp then + if env.runtimeAsyncReportedRanges.Add v.Range then errorR(Error(FSComp.SR.ilRuntimeAsyncLocalUsedAfterSuspension(RichText.mkText v.DisplayName), v.Range)) let bodyR = RewriteRuntimeAsyncExceptionHandlers g bodyR @@ -3694,8 +3696,17 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg | CurriedLambdaValue (_, _, _, body, _) -> Some body | _ -> None - let runtimeAsyncAnalyzer = RuntimeAsyncAnalyzer(g, getRuntimeAsyncLambdaBody) - let containsRuntimeAsyncFragment = runtimeAsyncAnalyzer.ContainsFragment + let runtimeAsyncAnalyzer = + if g.langVersion.SupportsFeature LanguageFeature.RuntimeAsync then + Some(RuntimeAsyncAnalyzer(g, getRuntimeAsyncLambdaBody)) + else + None + + let containsRuntimeAsyncFragment expr = + match runtimeAsyncAnalyzer with + | Some analyzer -> analyzer.ContainsFragment expr + | None -> false + let reoptimizeRuntimeAsync reduced = let reduced = InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced @@ -3708,14 +3719,9 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg InlineRuntimeAsyncLambdaArgument g containsRuntimeAsyncFragment reduced let mustInlineRuntimeAsync = - match stripExpr valExpr with - | Expr.Val(vref, _, _) -> - ShouldForceRuntimeAsyncApplication - runtimeAsyncAnalyzer - env.runtimeAsyncContext - vref - inlineBody - args + match runtimeAsyncAnalyzer, stripExpr valExpr with + | Some analyzer, Expr.Val(vref, _, _) -> + ShouldForceRuntimeAsyncApplication analyzer env.runtimeAsyncContext vref inlineBody args | _ -> false match cenv.settings.alwaysInline, stripExpr valExpr with diff --git a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs index 61cd814512c..dbd61e2f0f4 100644 --- a/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs +++ b/src/Compiler/Optimize/RuntimeAsyncAnalysis.fs @@ -129,11 +129,22 @@ let ShouldForceRuntimeAsyncApplication (analyzer: RuntimeAsyncAnalyzer) runtimeA | _ -> false) args) +let rec private IsRuntimeAsyncEffectFree expr = + match stripExpr expr with + | Expr.Const _ + | Expr.Lambda _ + | Expr.TyLambda _ -> true + | Expr.Val(vref, _, _) -> not vref.IsMutable && not vref.IsTypeFunction + | Expr.App(funcExpr, _, _, [], _) -> IsRuntimeAsyncEffectFree funcExpr + | Expr.Op(TOp.Tuple _, _, args, _) + | Expr.Op(TOp.AnonRecd _, _, args, _) -> List.forall IsRuntimeAsyncEffectFree args + | _ -> false + let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Expr -> bool) expr = let rec isLambdaExpression expr = match stripExpr expr with - | Expr.DebugPoint(_, innerExpr) - | Expr.Let(_, innerExpr, _, _) -> isLambdaExpression innerExpr + | Expr.DebugPoint(_, innerExpr) -> isLambdaExpression innerExpr + | Expr.Let(TBind(_, rhs, _), innerExpr, _, _) -> IsRuntimeAsyncEffectFree rhs && isLambdaExpression innerExpr | Expr.Lambda _ | Expr.TyLambda _ -> true | _ -> false @@ -173,7 +184,11 @@ let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Exp match f with | Expr.Let(bind, body, mLet, _) -> apply body (tyOfExpr g body) tyargs args m |> Option.map (mkLetBind mLet bind) - | Expr.Lambda(_, _, _, valParams, _, _, _) when valParams.Length = 1 && not rest.IsEmpty -> + | Expr.Lambda(_, _, _, valParams, body, _, _) when + valParams.Length = 1 + && not rest.IsEmpty + && (IsRuntimeAsyncEffectFree body || List.forall IsRuntimeAsyncEffectFree rest) + -> let reduced = MakeApplicationAndBetaReduce g (f, fty, [ tyargs ], [ firstArg ], m) match reduced with @@ -224,7 +239,12 @@ let InlineRuntimeAsyncLambdaArgument (g: TcGlobals) (isRuntimeAsyncFragment: Exp Some(fun cont expr -> match stripExpr expr with | Expr.Let(TBind(boundVal, boundExpr, _), body, _, _) when - boundVal.InlineIfLambda + (boundVal.InlineIfLambda + && (isLambdaExpression boundExpr + || isRuntimeAsyncFragment boundExpr + || match stripExpr boundExpr with + | Expr.App(_, _, _, args, _) -> List.isEmpty args + | _ -> true)) || (isLambdaExpression boundExpr && isRuntimeAsyncFragment boundExpr) -> if not boundVal.InlineIfLambda then diff --git a/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs index 8065b13fff1..03d16a8d230 100644 --- a/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs +++ b/src/Compiler/Optimize/RuntimeAsyncExceptionRewrite.fs @@ -29,6 +29,23 @@ let private RuntimeAsyncFilterCondition m resultTy filter thenExpr elseExpr = let decisionTree = TDSwitch(filter, [ matchCase ], Some defaultCase, m) matchBuilder.Close(decisionTree, m, resultTy) +let private RewriteRuntimeAsyncReraise g resultTy handlerVal handler = + RewriteExpr + { + PreIntercept = + Some(fun _ expr -> + match stripExpr expr with + | Expr.Op(TOp.Reraise, _, _, m) -> Some(mkThrow m resultTy (exprForVal m handlerVal)) + | Expr.App(Expr.Val(vref, _, m), _, _, _, _) when valRefEq g vref g.reraise_vref -> + Some(mkThrow m resultTy (exprForVal m handlerVal)) + | _ -> None) + PreInterceptBinding = None + PostTransform = (fun _ -> None) + RewriteQuotations = false + StackGuard = StackGuard("RewriteRuntimeAsyncReraise") + } + handler + let private IsRuntimeAsyncExceptionHandler (analyzer: RuntimeAsyncAnalyzer) expr = match stripExpr expr with | TryFinallyExpr(_, _, _, _, compensation, _) -> analyzer.ContainsSuspension compensation @@ -103,6 +120,8 @@ let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = | TryWithExpr(_, _, resultTy, body, filterVal, filter, handlerVal, handler, m) when IsRuntimeAsyncExceptionHandler analyzer expr -> Some( rewriteCapturedException m resultTy body (fun bodySucceeded bodyValue exceptionExpr -> + let handler = RewriteRuntimeAsyncReraise g resultTy handlerVal handler + let filter = mkCompGenLet m @@ -112,7 +131,12 @@ let RewriteRuntimeAsyncExceptionHandlers (g: TcGlobals) expr = m handlerVal exceptionExpr - (RuntimeAsyncFilterCondition m resultTy filter handler (RuntimeAsyncReraise m resultTy exceptionExpr))) + (RuntimeAsyncFilterCondition + m + resultTy + filter + handler + (RuntimeAsyncReraise m resultTy (exprForVal m handlerVal)))) mkCond DebugPointAtBinding.NoneAtInvisible m resultTy bodySucceeded bodyValue filter) ) diff --git a/src/Compiler/xlf/FSComp.txt.cs.xlf b/src/Compiler/xlf/FSComp.txt.cs.xlf index 37fea10b7a7..1646fb9660b 100644 --- a/src/Compiler/xlf/FSComp.txt.cs.xlf +++ b/src/Compiler/xlf/FSComp.txt.cs.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Neznámý bod ladění {0}. Dostupné body ladění jsou {1}. diff --git a/src/Compiler/xlf/FSComp.txt.de.xlf b/src/Compiler/xlf/FSComp.txt.de.xlf index 1ecac727d9d..41868e5cd35 100644 --- a/src/Compiler/xlf/FSComp.txt.de.xlf +++ b/src/Compiler/xlf/FSComp.txt.de.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Unbekannter Debugpunkt „{0}“. Die verfügbaren Debugpunkte sind „{1}“. diff --git a/src/Compiler/xlf/FSComp.txt.es.xlf b/src/Compiler/xlf/FSComp.txt.es.xlf index 724231734d7..23a91e3b64b 100644 --- a/src/Compiler/xlf/FSComp.txt.es.xlf +++ b/src/Compiler/xlf/FSComp.txt.es.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Punto de depuración desconocido \"{0}\". Los puntos de depuración disponibles son \"{1}\". diff --git a/src/Compiler/xlf/FSComp.txt.fr.xlf b/src/Compiler/xlf/FSComp.txt.fr.xlf index 1b79392a5e5..c9c07a36b7e 100644 --- a/src/Compiler/xlf/FSComp.txt.fr.xlf +++ b/src/Compiler/xlf/FSComp.txt.fr.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Point de débogage inconnu « {0} ». Les points de débogage disponibles sont «{1}». diff --git a/src/Compiler/xlf/FSComp.txt.it.xlf b/src/Compiler/xlf/FSComp.txt.it.xlf index cead6240870..2e25e910f6a 100644 --- a/src/Compiler/xlf/FSComp.txt.it.xlf +++ b/src/Compiler/xlf/FSComp.txt.it.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Punto di debug '{0}' sconosciuto. I punti di debug disponibili sono '{1}'. diff --git a/src/Compiler/xlf/FSComp.txt.ja.xlf b/src/Compiler/xlf/FSComp.txt.ja.xlf index 0e9411638c7..e392c077fe7 100644 --- a/src/Compiler/xlf/FSComp.txt.ja.xlf +++ b/src/Compiler/xlf/FSComp.txt.ja.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. 不明なデバッグ ポイントの `{0}`。使用可能なデバッグ ポイントは `{1}` です。 diff --git a/src/Compiler/xlf/FSComp.txt.ko.xlf b/src/Compiler/xlf/FSComp.txt.ko.xlf index d6ca2eec24f..32695bf4ef6 100644 --- a/src/Compiler/xlf/FSComp.txt.ko.xlf +++ b/src/Compiler/xlf/FSComp.txt.ko.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. 알 수 없는 디버그 지점 '{0}'. 사용 가능한 디버그 지점은 '{1}'입니다. diff --git a/src/Compiler/xlf/FSComp.txt.pl.xlf b/src/Compiler/xlf/FSComp.txt.pl.xlf index 548832135cc..5ded000a4fa 100644 --- a/src/Compiler/xlf/FSComp.txt.pl.xlf +++ b/src/Compiler/xlf/FSComp.txt.pl.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Nieznany punkt debugowania „{0}”. Dostępnymi punktami debugowania są „{1}”. diff --git a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf index 22586bc0fdb..824b97a3d52 100644 --- a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf +++ b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Ponto de depuração desconhecido '{0}'. Os pontos de depuração disponíveis são '{1}'. diff --git a/src/Compiler/xlf/FSComp.txt.ru.xlf b/src/Compiler/xlf/FSComp.txt.ru.xlf index 398de8809a9..9a40a0e1693 100644 --- a/src/Compiler/xlf/FSComp.txt.ru.xlf +++ b/src/Compiler/xlf/FSComp.txt.ru.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Неизвестная точка отладки \"{0}\". Доступные точки отладки: \"{1}\". diff --git a/src/Compiler/xlf/FSComp.txt.tr.xlf b/src/Compiler/xlf/FSComp.txt.tr.xlf index c4bd14b2434..830c0da9227 100644 --- a/src/Compiler/xlf/FSComp.txt.tr.xlf +++ b/src/Compiler/xlf/FSComp.txt.tr.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. Bilinmeyen hata ayıklama noktası '{0}'. Kullanılabilir hata ayıklama noktaları '{1}'. diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf index d71bb88e2b6..9976bdb9a55 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. 调试点“{0}”未知。可用的调试点为“{1}”。 diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf index fce80b41781..c28b7e5fd85 100644 --- a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf +++ b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf @@ -692,11 +692,21 @@ A byref, byref-like, or pinned local '{0}' cannot be used after a runtime async suspension. + + Stack allocation is not permitted in a runtime async method. + Stack allocation is not permitted in a runtime async method. + + Runtime async suspension method '{0}' may only be called from a runtime async method. Runtime async suspension method '{0}' may only be called from a runtime async method. + + A runtime async method cannot use MethodImplOptions.Synchronized. + A runtime async method cannot use MethodImplOptions.Synchronized. + + Unknown debug point '{0}'. The available debug points are '{1}'. 未知的偵錯點 '{0}'。可用的偵錯點為 '{1}'。 diff --git a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs index 28e49e72ccc..312669a922e 100644 --- a/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs +++ b/tests/FSharp.Compiler.ComponentTests/Language/RuntimeAsyncTests.fs @@ -345,7 +345,12 @@ let f () : Task = [] let main _ = - f().GetAwaiter().GetResult() + try + f().GetAwaiter().GetResult() |> ignore + 1 + with + | e when e.Message = "boom" -> 0 + | _ -> 1 """ |> withLangVersionPreview |> withFSharpCoreShippedNet @@ -374,6 +379,7 @@ let f () : Task = |> withFSharpCoreShippedNet |> compile |> shouldFail + |> withErrorCode 3918 [] let ``runtime async rejects stackalloc without suspension`` () = @@ -395,6 +401,7 @@ let f () : Task = |> withFSharpCoreShippedNet |> compile |> shouldFail + |> withErrorCode 3918 [] let ``runtime async rejects a byref captured by an inlined closure`` () = @@ -424,7 +431,7 @@ module RuntimeAsyncInlineIfLambdaEffectsTest open System.Threading.Tasks open System.Runtime.CompilerServices -open Microsoft.FSharp.Core.CompilerServices +open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers let mutable calls = 0 @@ -432,9 +439,11 @@ let effect () = calls <- calls + 1 fun () -> 1 -let inline plainTwice ([] f) = f () + f () -let inline twice ([] f) = StateMachineHelpers.__runtimeAsyncReturn (f () + f ()) -let inline unused ([] f) = StateMachineHelpers.__runtimeAsyncReturn 20 +let inline plainTwice ([] f: unit -> int) = f () + f () +let inline twice ([] f: unit -> int) = + __runtimeAsyncReturn (f () + f ()) +let inline unused ([] f: unit -> int) = + __runtimeAsyncReturn 20 [] let main _ = @@ -538,6 +547,7 @@ let f () : Task = |> withFSharpCoreShippedNet |> compile |> shouldFail + |> withErrorCode 3919 [] let ``runtime async combines awaited chunks without delegates`` () =