TheAngryByrd/IcedTasks

IcedTasks is an F\# library that provides a suite of computation expression builders for managing asynchronous workflows, including task, valueTask, and cancellable variants. It enables developers to execute parallel async operations and interoperate seamlessly with modern .NET types while avoiding legacy exception wrapping. The system includes comprehensive benchmarks, extensive documentation, and example projects to demonstrate usage in ASP.NET Core and database contexts.

New example projects have been added to demonstrate library usage. The DatabaseDemo example provides a complete ASP.NET Core application showing how to handle cancellation in database operations using Npgsql and Dapper, including a docker-compose file to run a PostgreSQL instance. The ILSpySamples project serves as a playground to inspect the generated IL code for task and cancellable-task workflows.

examples · high confidence

This change introduces a new F\# benchmark project (\benchmarks/FSharpBenchmarks\) that provides performance comparisons for asynchronous patterns in F\# against C\# equivalents. The suite includes benchmarks for synchronous and asynchronous completion, file writing operations, and parallel async execution using various builders (standard \async\, \task\, \valueTask\, \cancellableTask\, and \FSharp.Control.Tasks.Affine\). It also adds a new \parallelAsync\ builder implementation for parallel async workflows, allowing users to measure the overhead and performance of parallel async bindings compared to sequential ones.

benchmarks/FSharpBenchmarks · high confidence

The library introduces a new \parallelAsync\ computation expression builder (with variants \parallelAsyncUsingStartChild\ and \parallelAsyncUsingStartImmediateAsTask\) that allows users to execute multiple async workflows concurrently using applicative syntax (\and!\). Additionally, the \AsyncEx\ module provides alternative implementations for awaiting Tasks, ValueTasks, and Awaitables that align with modern .NET exception semantics (avoiding \AggregateException\ wrapping) and adds a \TryFinallyAsync\ extension to F\# \Async\ types for robust compensation logic. These changes enhance performance and error handling when integrating F\# async workflows with C\#-style asynchronous types.

src/IcedTasks · high confidence

The documentation site has been significantly expanded with new explanation guides and how-to tutorials. The 'Explanations' section now includes detailed comparisons of all available computation expression builders (such as \task\, \valueTask\, \cancellableTask\, \asyncEx\, and \poolingValueTask\), covering their result shapes, hot/cold behavior, and support for features like \and!\, \IAsyncDisposable\, and \IAsyncEnumerable\. It also explains polyfill namespaces for shadowing standard F\# builders and the specific behavior of the \and!\ operator. The 'How-To-Guides' section adds practical examples for integrating \CancellableTask\ into console applications, ASP.NET Minimal APIs, Giraffe, and Falco, alongside guides on composing task values with helper functions, converting between async shapes, and using AsyncEx for .NET interop.

docsSrc · high confidence

The entire docsTool module has been removed from the repository. This deletion eliminates the previous documentation generation pipeline, including the CLI argument parsing, the F\# Literate-based doc generation logic, the Fable.React-based HTML templates, and the local web server used for live previewing. Users relying on this tool for generating API documentation or serving documentation sites will no longer have access to these capabilities within this component.

docsTool · high confidence

The project has upgraded its required .NET SDK to version 10.0.100-rc.1 (global.json) and restructured the build system to enforce tool restoration and F\# code formatting via Fantomas before every build (Directory.Build.targets). The solution now includes dedicated projects for C\# and F\# benchmarks, tests for .NET Standard 2.0 and 2.1, and example code, while removing the previous docsTool project. Additionally, the .editorconfig has been expanded with specific formatting rules for F\# (Fantomas), XML, and other file types, and a script (generate-sdk-references.fsx) has been added to generate runtime load scripts for the local development environment.

(repo-wide) · high confidence

The build process has been restructured to improve maintainability and documentation generation. The changelog logic has been extracted into a new \build/Changelog.fs\ module, which now handles version parsing, release note generation, and validation against Keep a Changelog standards. Documentation building has been migrated to FsDocs, with a new \build/FsDocs.fs\ module providing typed parameters for the build and watch commands. Additionally, the \paket.references\ file has been removed, indicating a shift away from Paket for build dependencies, and path resolution in \build.fs\ has been standardized using a \rootDirectory\ variable.

build · high confidence

The development container configuration has been significantly updated to support .NET 10, with .NET 9 and 8 also available as additional versions. The setup now leverages official devcontainer features for common utilities, GitHub CLI, and Starship shell, replacing the previous manual Debian-based Dockerfile with a more modular approach. This change simplifies the environment setup, improves shell integration with Zsh and Starship, and ensures the container is ready for modern .NET development workflows out of the box.

.devcontainer · high confidence

New BenchmarkDotNet result files (Markdown, CSV, and HTML) have been added for the AsyncBenchmarks and AsyncCompletionBenchmarks suites. These reports provide updated performance metrics, including execution time, memory allocation, and garbage generation, comparing various async builders (such as CSharpTasks, Ply, ColdTask, and CancellableValueTask) across different binding scenarios on .NET 7.

benchmarks/FSharpBenchmarks/BenchmarkDotNet.Artifacts · high confidence

Added new test suites in tests/IcedTasks.Tests for the AsyncEx, CancellableTask, CancellableValueTask, CancellablePoolingValueTask, ColdTask, ParallelAsync, PoolingValueTask, and PoolingValueTaskDynamic builders. These tests verify core builder operations (Return, ReturnFrom, Bind) across various task-like types (Task, ValueTask, Async, ColdTask) and ensure correct behavior for cancellation and pooling scenarios. Additionally, updated the Expect module with helper functions for testing asynchronous exceptions and cancellation requests across these different task types.

tests/IcedTasks.Tests · high confidence

The project has switched from Paket to MSBuild Central Package Management, introducing Directory.Packages.props to define versions for FSharp.Core (6.0.4), Expecto (10.2.3), BenchmarkDotNet (0.13.9), and various Fake build tools (6.1.3). This change removes the legacy paket.dependencies and paket.lock files and updates the test and benchmark projects to target .NET 8, 9, and 10.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 58 → 57 (-0.5)
• Rubric changed (rubric-2026.09.13 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 75 → 75 (-0.0)
• Architecture 89 → 93 (+3.8)
• Maturity 56 → 55 (-1.4)
• Readiness 47 → 47 (+0.0)
• Security 80 → 76 (-3.8)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (8–9 lines × 4) (src/IcedTasks/CancellableTask.fs)
• Similar to the ManyWriteFileAsync pair, these two methods are distinguished only by the suffix 'Task' vs 'ValueTask'. This naming style relies on the suffix to convey the return type, which can be confusing and inconsistent with standard .NET naming conventions where the method name typically describes the action, not the return type, unless the return type is the primary differentiator for the caller.
• The concept of writing files is represented by two methods with nearly identical names, distinguished only by a suffix. One method uses the suffix '_ValueTask' to indicate the return type, while the other does not specify the return type in the name, despite both likely being async operations. This creates ambiguity about whether the suffix is a necessary disambiguator or if the base name should be more descriptive of the specific operation variant.
• The naming of these methods is highly inconsistent and verbose. Some methods include 'Builder' in the name (e.g., 'TaskBuilder'), while others include 'Bind' (e.g., 'BindValueTask'). The combination of 'Async'/'Sync' and 'Task'/'ValueTask' is repeated in various ways, making it difficult to discern the actual behavior. For example, 'CSharp_TenBindsAsync_TaskBuilder' vs 'CSharp_TenBindsSync_TaskBuilder_BindValueTask' suggests a relationship, but the naming does not clearly explain the difference.

• Documentation: no project overview (README.md)
• Duplicated block (28–29 lines × 2) (src/IcedTasks/CancellableTaskBuilderBase.fs)
• Duplicated block (8 lines × 4) (src/IcedTasks/CancellableTask.fs)
• Duplicated block (9 lines × 2) (src/IcedTasks/CancellableTask.fs)
• End-of-life runtime: .NET net9.0

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• build

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

TheAngryByrd/IcedTasks was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.