feat: simple, low-allocation single-threaded observables

Author: jolexxa

.editorconfig

@@ -463,3 +463,5 @@ dotnet_diagnostic.IDE0010.severity = none
 dotnet_diagnostic.IDE0062.severity = warning
 # Don't make me use properties if I don't want to.
 dotnet_diagnostic.IDE0032.severity = none
+# Don't simplify new type names
+dotnet_diagnostic.IDE0090.severity = none

Chickensoft.Collections.Tests/src/BoxlessQueueTest.cs

@@ -6,51 +6,67 @@ namespace Chickensoft.Collections.Tests;
 using Xunit;
 
 public class BoxlessQueueTests {
-  public readonly record struct ValueA;
-  public readonly record struct ValueB;
+  public readonly record struct ValueA(int Id);
+  public readonly record struct ValueB(int Id);
+  public readonly record struct ValueC(int Id);
 
-  public class TestValueHandler : IBoxlessValueHandler {
-    public List<object> Values { get; } = [];
-    public void HandleValue<TValue>(in TValue value) where TValue : struct =>
-      Values.Add(value);
+  public readonly struct TestValueHandler : IBoxlessValueHandler {
+    public List<object> Values { get; }
+
+    public TestValueHandler() { Values = []; }
+
+    public readonly void HandleValue<TValue>(in TValue value)
+        where TValue : struct => Values.Add(value);
   }
 
   [Fact]
   public void Initializes() {
-    var handler = new TestValueHandler();
-    var queue = new BoxlessQueue(handler);
+    var queue = new BoxlessQueue();
 
-    queue.Handler.ShouldBe(handler);
+    queue.ShouldBeOfType<BoxlessQueue>();
   }
 
   [Fact]
   public void EnqueueAndHandleValues() {
     var handler = new TestValueHandler();
-    var queue = new BoxlessQueue(handler);
+    var queue = new BoxlessQueue();
 
     var valueA = new ValueA();
     var valueA2 = new ValueA();
     var valueB = new ValueB();
 
+    queue.Count.ShouldBe(0);
+
     queue.Enqueue(valueA);
+
+    queue.Count.ShouldBe(1);
+
     queue.Enqueue(valueA2);
     queue.Enqueue(valueB);
 
+    queue.Count.ShouldBe(3);
+
     queue.HasValues.ShouldBeTrue();
 
-    queue.Dequeue();
-    queue.Dequeue();
-    queue.Dequeue();
+    queue.Dequeue(in handler);
+
+    queue.Count.ShouldBe(2);
+
+    queue.Dequeue(in handler);
+
+    queue.Count.ShouldBe(1);
+
+    queue.Dequeue(in handler);
 
     queue.HasValues.ShouldBeFalse();
-    queue.Dequeue();
+    queue.Dequeue(in handler);
     handler.Values.ShouldBe(new object[] { valueA, valueA2, valueB });
   }
 
   [Fact]
   public void ClearQueue() {
     var handler = new TestValueHandler();
-    var queue = new BoxlessQueue(handler);
+    var queue = new BoxlessQueue();
 
     queue.Enqueue(new ValueA());
     queue.Enqueue(new ValueB());
@@ -59,4 +75,86 @@ public void ClearQueue() {
 
     queue.HasValues.ShouldBeFalse();
   }
+
+  [Fact]
+  public void Peeks() {
+    var handler = new TestValueHandler();
+    var queue = new BoxlessQueue();
+
+    var valueA = new ValueA();
+    var valueB = new ValueB();
+    var valueC = new ValueC();
+
+    var valueD = new ValueA(1);
+    var valueE = new ValueB(2);
+    var valueF = new ValueC(3);
+
+    queue.Enqueue(valueA);
+    queue.Enqueue(valueB);
+    queue.Enqueue(valueC);
+    queue.Enqueue(valueD);
+    queue.Enqueue(valueE);
+    queue.Enqueue(valueF);
+
+    queue.Peek(in handler).ShouldBeTrue();
+    handler.Values.ShouldBe([valueA]);
+    handler.Values.Clear();
+
+    queue.Discard();
+
+    queue.Peek(in handler).ShouldBeTrue();
+    handler.Values.ShouldBe([valueB]);
+    handler.Values.Clear();
+
+    queue.Discard();
+
+    queue.Peek(in handler).ShouldBeTrue();
+    handler.Values.ShouldBe([valueC]);
+    handler.Values.Clear();
+
+    queue.Discard();
+
+    queue.Peek(in handler).ShouldBeTrue();
+    handler.Values.ShouldBe([valueD]);
+    handler.Values.Clear();
+
+    queue.Discard();
+
+    queue.Peek(in handler).ShouldBeTrue();
+    handler.Values.ShouldBe([valueE]);
+    handler.Values.Clear();
+
+    queue.Discard();
+
+    queue.Peek(in handler).ShouldBeTrue();
+    handler.Values.ShouldBe([valueF]);
+    handler.Values.Clear();
+
+    queue.Discard();
+
+    queue.Peek(in handler).ShouldBeFalse();
+    handler.Values.ShouldBeEmpty();
+
+    queue.Count.ShouldBe(0);
+
+    queue.Clear();
+
+    queue.Count.ShouldBe(0);
+  }
+
+  [Fact]
+  public void CannotDiscardOutOfRange() {
+    var queue = new BoxlessQueue();
+
+    queue.Enqueue(new ValueA());
+    queue.Enqueue(new ValueB());
+
+    queue.Discard(-1);
+
+    queue.Count.ShouldBe(2);
+
+    queue.Discard(3);
+
+    queue.Count.ShouldBe(0);
+  }
 }

Chickensoft.Collections.Tests/src/MapTest.cs

@@ -6,6 +6,8 @@ namespace Chickensoft.Collections.Tests;
 using Shouldly;
 using Xunit;
 
+#pragma warning disable CS0618 // obsolete
+
 public class MapTest {
   [Fact]
   public void Initializes()
@@ -290,3 +292,5 @@ public void KvpConstructor() {
     map.Values.ShouldBe([3, 2, 1]);
   }
 }
+
+#pragma warning restore CS0618