Update Range struct to support 'with' keyword for property initialization and increment version to 0.0.2

Author: Mykyta Zotov

src/Intervals.NET/Intervals.NET.csproj

@@ -6,35 +6,10 @@
         <Nullable>enable</Nullable>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <PackageId>Intervals.NET</PackageId>
-        <Version>0.0.1</Version>
+        <Version>0.0.2</Version>
         <Authors>blaze6950</Authors>
         <Description>Production-ready .NET library for type-safe mathematical intervals and ranges. Zero-allocation struct-based design with comprehensive set operations (intersection, union, contains, overlaps), explicit infinity support, span-based parsing, and custom interpolated string handler. Generic over IComparable&lt;T&gt; with 100% test coverage. Built for correctness and performance.</Description>
-        <PackageReleaseNotes>🎉 Initial Release (v0.0.1):
-
-✨ Core Features:
-- Type-safe range operations with all boundary types: [a,b], (a,b), [a,b), (a,b]
-- Rich API: Overlaps, Contains, Intersect, Union, Except, IsAdjacent, IsBefore, IsAfter
-- Explicit infinity support with RangeValue&lt;T&gt; (no nullable confusion)
-- Zero-allocation struct-based design (all operations stack-allocated)
-
-⚡ Performance:
-- 3.6× faster parsing with interpolated string handler
-- 1.7× faster containment checks vs naive implementations
-- Zero heap allocations for all set operations
-- Span-based parsing with ReadOnlySpan&lt;char&gt;
-
-🎯 Developer Experience:
-- Generic over any IComparable&lt;T&gt; (int, double, DateTime, custom types)
-- Comprehensive extension methods for fluent API
-- Culture-aware parsing with IFormatProvider support
-- Infinity symbol support (∞, -∞) in string parsing
-- Full XML documentation and IntelliSense
-
-🛡️ Quality:
-- 100% test coverage
-- Fail-fast validation with comprehensive edge case handling
-- Production-ready correctness over raw speed
-- .NET 8.0 target with modern C# features</PackageReleaseNotes>
+        <PackageReleaseNotes>Range record was updated by making all properties as init in order to allow the creation of new Range struct using the with keyword</PackageReleaseNotes>
         <PackageTags>range;interval;math;mathematics;intervals;ranges;span;performance;zero-allocation;generic;comparable;infinity;parsing;set-operations;intersection;union;datetime;numeric</PackageTags>
         <RepositoryUrl>https://github.com/blaze6950/Intervals.NET</RepositoryUrl>
         <PackageProjectUrl>https://github.com/blaze6950/Intervals.NET</PackageProjectUrl>

src/Intervals.NET/Range.cs

@@ -69,25 +69,25 @@ internal Range(RangeValue<T> start, RangeValue<T> end, bool isStartInclusive, bo
     /// The start value of the range.
     /// Can be finite, negative infinity, or positive infinity.
     /// </summary>
-    public RangeValue<T> Start { get; }
+    public RangeValue<T> Start { get; init; }
 
     /// <summary>
     /// The end value of the range.
     /// Can be finite, negative infinity, or positive infinity.
     /// </summary>
-    public RangeValue<T> End { get; }
+    public RangeValue<T> End { get; init; }
 
     /// <summary>
     /// Indicates whether the start value is inclusive.
     /// Meaning the range includes the start value: [start, ...
     /// </summary>
-    public bool IsStartInclusive { get; }
+    public bool IsStartInclusive { get; init; }
 
     /// <summary>
     /// Indicates whether the end value is inclusive.
     /// Meaning the range includes the end value: ..., end]
     /// </summary>
-    public bool IsEndInclusive { get; }
+    public bool IsEndInclusive { get; init; }
 
     /// <summary>
     /// Returns a string representation of the range.

tests/Intervals.NET.Tests/RangeStructTests.cs

@@ -697,6 +697,22 @@ public void RecordStruct_GetHashCode_DifferentRangesHaveDifferentHashCodes()
         Assert.NotEqual(hash1, hash2);
     }
 
+    [Fact]
+    public void RecordStruct_CreateNewWith_NewNotEqualToSource()
+    {
+        // Arrange
+        var range1 = new Range<int>(new RangeValue<int>(10), new RangeValue<int>(20), true, false);
+
+        // Act
+        var range2 = range1 with { Start = 11 };
+
+        // Assert
+        Assert.NotEqual(range1.Start, range2.Start);
+        Assert.Equal(range1.End, range2.End);
+        Assert.Equal(range1.IsStartInclusive, range2.IsStartInclusive);
+        Assert.Equal(range1.IsEndInclusive, range2.IsEndInclusive);
+    }
+
     #endregion
 
     #region Edge Cases and Different Types