From 47a33153360dfc4a26803aa0c7772de52fbb0813 Mon Sep 17 00:00:00 2001
From: Viktor Stojanovic <viktor2006stojanovic@gmail.com>
Date: Thu, 13 Aug 2026 15:39:15 +0200
Subject: [PATCH 1/2] Add LongSpan<T> ref struct for memory regions

Introduced LongSpan<T> to represent contiguous memory, supporting both managed and unmanaged sources. Added field for length, constructors, Length and IsEmpty properties, indexer with bounds checking, and XML documentation.
---
 src/LongSpan.cs | 82 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 81 insertions(+), 1 deletion(-)

diff --git a/src/LongSpan.cs b/src/LongSpan.cs
index f9a6259..0941118 100644
--- a/src/LongSpan.cs
+++ b/src/LongSpan.cs
@@ -1,11 +1,91 @@
 // Copyright (c) 2026 Viktor Stojanović. All rights reserved.
 // Licensed under the MIT License. See LICENSE.txt in the project root for license information.
 
+using System;
+using System.Runtime.CompilerServices;
+
 namespace SharpAllocators;
 
+/// <summary>
+/// <see cref="LongSpan{T}"/> represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
+/// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe.
+/// </summary>
 public readonly ref struct LongSpan<T>
 {
+    /// <summary>A byref or a native ptr.</summary>
     private readonly ref T _reference;
-    public readonly long Length { get; }
+
+    /// <summary>The number of elements this Span contains.</summary>
+    private readonly long _length;
+
+    /// <summary>
+    /// The number of items in the span.
+    /// </summary>
+    public readonly long Length => _length;
+
+    /// <summary>
+    /// Gets a value indicating whether this <see cref="LongSpan{T}"/> is empty.
+    /// </summary>
+    /// <value><see langword="true"/> if this span is empty; otherwise, <see langword="false"/>.</value>
     public readonly bool IsEmpty => Length is 0;
+
+    /// <summary>Creates a new <see cref="LongSpan{T}"/> of length 1 around the specified reference.</summary>
+    /// <param name="reference">A reference to data.</param>
+    public LongSpan(ref T reference)
+    {
+        _reference = ref reference;
+        _length = 1;
+    }
+
+    /// <summary>
+    /// Creates a new span over the target unmanaged buffer.  Clearly this
+    /// is quite dangerous, because we are creating arbitrarily typed T's
+    /// out of a void*-typed block of memory.  And the length is not checked.
+    /// But if this creation is correct, then all subsequent uses are correct.
+    /// </summary>
+    /// <param name="pointer">An unmanaged pointer to memory.</param>
+    /// <param name="length">The number of <typeparamref name="T"/> elements the memory contains.</param>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <typeparamref name="T"/> is reference type or contains pointers and hence cannot be stored in unmanaged memory.
+    /// </exception>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown when the specified <paramref name="length"/> is negative.
+    /// </exception>
+    public unsafe LongSpan(void* pointer, long length)
+    {
+        if (length < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(length), "Length cannot negative");
+        }
+
+        if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
+        {
+            throw new ArgumentException("Generic type parameter T cannot be a refrence type or contain refrences", nameof(T));
+        }
+
+        _reference = ref *(T*)pointer;
+        _length = length;
+    }
+
+    /// <summary>
+    /// Returns a reference to specified element of the Span.
+    /// </summary>
+    /// <param name="index">The zero-based index.</param>
+    /// <returns></returns>
+    /// <exception cref="IndexOutOfRangeException">
+    /// Thrown when index less than 0 or index greater than or equal to Length
+    /// </exception>
+    public ref T this[int index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            if ((uint)index >= (uint)_length)
+            {
+                throw new IndexOutOfRangeException("Index cannot be less then zero or greater then or equal to length");
+            }
+
+            return ref Unsafe.Add(ref _reference, (nint)(uint)index);
+        }
+    }
 }

From 6b723e6fb3e1756a459c22737f04d827c15511a4 Mon Sep 17 00:00:00 2001
From: Viktor Stojanovic <viktor2006stojanovic@gmail.com>
Date: Thu, 13 Aug 2026 16:46:36 +0200
Subject: [PATCH 2/2] Change LongSpan<T> indexer to use long index

The indexer now accepts a long index instead of int. Bounds checking uses ulong, and Unsafe.Add uses (nint)index. Added a comment about possible undefined behavior on 32-bit systems.
---
 src/LongSpan.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/LongSpan.cs b/src/LongSpan.cs
index 0941118..906e0e2 100644
--- a/src/LongSpan.cs
+++ b/src/LongSpan.cs
@@ -75,17 +75,17 @@ public unsafe LongSpan(void* pointer, long length)
     /// <exception cref="IndexOutOfRangeException">
     /// Thrown when index less than 0 or index greater than or equal to Length
     /// </exception>
-    public ref T this[int index]
+    public ref T this[long index]
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         get
         {
-            if ((uint)index >= (uint)_length)
+            if ((ulong)index >= (ulong)_length)
             {
                 throw new IndexOutOfRangeException("Index cannot be less then zero or greater then or equal to length");
             }
 
-            return ref Unsafe.Add(ref _reference, (nint)(uint)index);
+            return ref Unsafe.Add(ref _reference, (nint)index); // right now this can cause UB on 32 bit systems
         }
     }
 }