StephenCleary

public readonly record struct Queue<T>(int FrontCount, Stream<T> Front, int RearCount, Stream<T> Rear)
{
	// val empty = Queue (0, $Nil, 0, $Nil)
	public static Queue<T> Empty { get; } = new(0, Stream<T>.Empty, 0, Stream<T>.Empty);

	// fun isEmpty (lenf, _, _, _) = (lenf = 0)
	public bool IsEmpty => FrontCount == 0;

	// fun snoc ((lenf, f, lenr, r), x) = check (lenf, f, lenr+1, $Cons (x, r))
	public Queue<T> Snoc(T item) => (this with { RearCount = RearCount + 1, Rear = new(item, Rear) }).Check();

StephenCleary

using System.Threading.Channels;
using Nito.AsyncEx;

// All members must be safe to call while under lock.
public interface ICustomBounds<in T>
{
	bool IsEmpty { get; }
	bool IsFull { get; }
	void Add(T item);
	void Subtract(T item);

StephenCleary

Memory<T> API documentation and samples

This document describes the APIs of Memory<T>, IMemoryOwner<T>, and MemoryManager<T> and their relationships to each other.

See also the Memory<T> usage guidelines document for background information.

First, a brief summary of the basic types

• Memory<T> is the basic type that represents a contiguous buffer. This type is a struct, which means that developers cannot subclass it and override the implementation. The basic implementation of the type is aware of contigious memory buffers backed by T[] and System.String (in the case of ReadOnlyMemory<char>).

StephenCleary

using System.Threading;

/// <summary>
/// A <see cref="CancellationTokenSource"/> that resets itself to uncanceled after <see cref="Cancel"/> is called.
/// </summary>
public sealed class AutoResetCancellationTokenSource
{
	/// <summary>
	/// Cancels any tokens previously returned from <see cref="Token"/>, and resets this instance to an uncancelled state.
	/// </summary>

StephenCleary

using System;
using System.Threading;

/// <summary>
/// Interlocked helper methods.
/// </summary>
public static class InterlockedState
{
	/// <summary>
	/// Executes a state transition from one state to another.

StephenCleary

// Developed as part of https://github.com/StephenCleary/StructuredConcurrency but wasn't necessary for that project.

/// <summary>
/// Similar to <see cref="Task.WhenAll{TResult}(Task{TResult}[])"/>, but allowing any number of tasks to be added, even after waiting has begun.
/// At least one task must be added, or else the <see cref="Task"/> will never complete.
/// </summary>
/// <typeparam name="TResult">The type of the result of the tasks.</typeparam>
public sealed class DynamicTaskWhenAll<TResult>
{
    private readonly TaskCompletionSource<IReadOnlyList<TResult>> _taskCompletionSource = new();

StephenCleary

This gist kept getting bigger and bigger, so I moved it to a proper repository, complete with a proper NuGet package.

StephenCleary

public sealed class TaskDictionary<TRequest, TResult>
    where TRequest : notnull
{
  public TaskDictionary(IEqualityComparer<TRequest>? comparer = null)
  {
    _dictionary = new(comparer);
  }

  public Task<TResult> GetOrAdd(TRequest request)
  {

StephenCleary

using System.Collections.Concurrent;
using System.Diagnostics;
using Nito.Disposables;

/// <summary>
/// A cache of uncanceled <see cref="CancellationTokenSource"/> instances.
/// </summary>
public sealed class CancellationTokenSourceCache
{
    private readonly ConcurrentBag<CancellationTokenSource> _sources = new();

StephenCleary

public abstract class AlignedMemoryManager : MemoryManager<byte>
{
    // Note: No finalizer; this will deliberately leak memory if never disposed.
    // https://gist.github.com/GrabYourPitchforks/8efb15abbd90bc5b128f64981766e834#implementation-notes-when-subclassing-memorymanagert
    private IntPtr _pointer;

    protected static unsafe IntPtr Allocate(nuint byteCount, nuint alignment) => (IntPtr)NativeMemory.AlignedAlloc(byteCount, alignment);

    public override unsafe Span<byte> GetSpan() => new((void*)_pointer, ByteCount);