diff --git a/.editorconfig b/.editorconfig
index 4cead120d..57d0ce66a 100755
--- a/.editorconfig
+++ b/.editorconfig
@@ -12,7 +12,7 @@ indent_style = space
 tab_width = 4
 
 # New line preferences
-end_of_line = crlf
+# end_of_line = crlf
 insert_final_newline = false
 
 #### .NET Coding Conventions ####
@@ -58,7 +58,7 @@ dotnet_style_prefer_is_null_check_over_reference_equality_method = true:error
 dotnet_style_readonly_field = true:error
 
 # Parameter preferences
-dotnet_code_quality_unused_parameters = all:error
+dotnet_code_quality_unused_parameters = all:warning
 
 #### C# Coding Conventions ####
 
@@ -68,14 +68,14 @@ csharp_style_var_for_built_in_types = true:error
 csharp_style_var_when_type_is_apparent = true:error
 
 # Expression-bodied members
-csharp_style_expression_bodied_accessors = true:error
-csharp_style_expression_bodied_constructors = true:error
-csharp_style_expression_bodied_indexers = true:error
-csharp_style_expression_bodied_lambdas = true:error
-csharp_style_expression_bodied_local_functions = true:error
-csharp_style_expression_bodied_methods = true:error
-csharp_style_expression_bodied_operators = true:error
-csharp_style_expression_bodied_properties = true:error
+csharp_style_expression_bodied_accessors =true:warning
+csharp_style_expression_bodied_constructors =true:warning
+csharp_style_expression_bodied_indexers =true:warning
+csharp_style_expression_bodied_lambdas =true:warning
+csharp_style_expression_bodied_local_functions =true:warning
+csharp_style_expression_bodied_methods =true:warning
+csharp_style_expression_bodied_operators =true:warning
+csharp_style_expression_bodied_properties =true:warning
 
 # Pattern matching preferences
 csharp_style_pattern_matching_over_as_with_null_check = true:error
@@ -101,7 +101,7 @@ csharp_style_pattern_local_over_anonymous_function = true:error
 csharp_style_prefer_index_operator = true:warning
 csharp_style_prefer_range_operator = true:warning
 csharp_style_throw_expression = true:error
-csharp_style_unused_value_assignment_preference = discard_variable:error
+csharp_style_unused_value_assignment_preference =discard_variable:warning
 csharp_style_unused_value_expression_statement_preference = discard_variable:error
 
 # 'using' directive preferences
diff --git a/.gitattributes b/.gitattributes
index 1ff0c4230..b72c2c601 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,7 +1,7 @@
 ###############################################################################
 # Set default behavior to automatically normalize line endings.
 ###############################################################################
-* text=auto
+* text eol=lf
 
 ###############################################################################
 # Set default behavior for command prompt diff.
diff --git a/.github/workflows/dotnetcore.yml b/.github/workflows/dotnetcore.yml
index a6013e986..74c171c6f 100644
--- a/.github/workflows/dotnetcore.yml
+++ b/.github/workflows/dotnetcore.yml
@@ -10,20 +10,21 @@ jobs:
     - name: Check out repository
       uses: actions/checkout@v2
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1.7.2
+      uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: '6.0.100-preview.2.21155.3'
+        dotnet-version: '6.0.x'
+        include-prerelease: true
     - name: Test source generator
-      run: dotnet test ./NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj 
+      run: dotnet test ./NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj 
     - name: Build solution
       run: dotnet build
     - name: Tests and coverage
-      run: dotnet test ./NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj -f:net6.0 -p:CollectCoverage=true -p:CoverletOutputFormat=lcov -p:CoverletOutput=TestResults/
+      run: dotnet test ./NetFabric.Hyperlinq.Core.UnitTests/NetFabric.Hyperlinq.Core.UnitTests.csproj -f:net6.0 -p:CollectCoverage=true -p:CoverletOutputFormat=lcov -p:CoverletOutput=TestResults/
     - name: Publish coverage report to coveralls.io
       uses: coverallsapp/github-action@master
       with:
         github-token: ${{ secrets.GITHUB_TOKEN }}
-        path-to-lcov: ./NetFabric.Hyperlinq.UnitTests/TestResults/coverage.net6.0.info
+        path-to-lcov: ./NetFabric.Hyperlinq.Core.UnitTests/TestResults/coverage.net6.0.info
       
 
       
diff --git a/Icon.png b/Icon.png
index 278ddc671..baf66818c 100644
Binary files a/Icon.png and b/Icon.png differ
diff --git a/NetFabric.Hyperlinq.Benchmarks/NetFabric.Hyperlinq.Benchmarks.csproj b/NetFabric.Hyperlinq.Benchmarks/NetFabric.Hyperlinq.Benchmarks.csproj
index c34ffc150..88176afb2 100644
--- a/NetFabric.Hyperlinq.Benchmarks/NetFabric.Hyperlinq.Benchmarks.csproj
+++ b/NetFabric.Hyperlinq.Benchmarks/NetFabric.Hyperlinq.Benchmarks.csproj
@@ -3,18 +3,13 @@
     <OutputType>Exe</OutputType>
     <TargetFrameworks>net6.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <DebugSymbols>true</DebugSymbols>
+    <Configuration>Release</Configuration>
+    <DebugSymbols>false</DebugSymbols>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\NetFabric.Hyperlinq\NetFabric.Hyperlinq.csproj" />
-    <ProjectReference Include="..\NetFabric.Hyperlinq.UnitTests\NetFabric.Hyperlinq.UnitTests.csproj" />
+    <ProjectReference Include="..\NetFabric.Hyperlinq.Core.UnitTests\NetFabric.Hyperlinq.Core.UnitTests.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/Count.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/Count.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/Count.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/Count.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/Count.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/Count.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/CountAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/CountAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Count/CountAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Count/CountAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Sum.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/Sum.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/Sum.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/Sum.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/Sum.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/Sum.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/Sum.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/SumAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/SumAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/SumAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Aggregation/Sum/SumAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Dictionary.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Dictionary.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Dictionary.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Dictionary.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSet.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSet.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSet.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSet.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/List.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/List.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/List.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/List.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueue.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueue.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueue.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueue.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Queue.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Queue.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Queue.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Queue.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionary.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionary.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionary.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionary.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSet.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSet.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSet.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSet.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Stack.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Stack.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Stack.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/Stack.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArray.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArray.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArray.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArray.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionary.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionary.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionary.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionary.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSet.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSet.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSet.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSet.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueue.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueue.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueue.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueue.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionary.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionary.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionary.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionary.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStack.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStack.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStack.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStack.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ArrayBuilder.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ArrayBuilder.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ArrayBuilder.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ArrayBuilder.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/LargeArrayBuilder.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/LargeArrayBuilder.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/LargeArrayBuilder.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/LargeArrayBuilder.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArray.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToList.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToList.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToListAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToListAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Conversion/ToList/ToListAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Conversion/ToList/ToListAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/ElementAt.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/ElementAt.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAt.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAt.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/First/First.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/First/First.ReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/First/First.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/First/First.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/First/First.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/First/First.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/First/First.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/First/First.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/First/First.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/First/FirstAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/First/FirstAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/First/FirstAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/First/FirstAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/Single/Single.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/Single/Single.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Element/Single/SingleAsync.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Element/Single/SingleAsync.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Element/Single/SingleAsync.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Element/Single/SingleAsync.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/Where/Where.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/Where/Where.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereAt/WhereAt.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereAt/WhereAt.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Filtering/WhereSelect/WhereSelect.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Filtering/WhereSelect/WhereSelect.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Empty.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Empty.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Empty.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Empty.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Range.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Range.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Range.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Range.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Repeat.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Repeat.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Repeat.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Repeat.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Return.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Return.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/AsyncValueEnumerable/Return.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/AsyncValueEnumerable/Return.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/Range.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/Range.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/Range.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/Range.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/Repeat.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/Repeat.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/Repeat.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/Repeat.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/Return.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/Return.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/Return.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/Return.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Empty.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Empty.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Empty.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Empty.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Range.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Range.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Range.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Range.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Repeat.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Repeat.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Repeat.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Repeat.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Return.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Return.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Generation/ValueEnumerable/Return.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Generation/ValueEnumerable/Return.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/GlobalSuppressions.cs b/NetFabric.Hyperlinq.Core.UnitTests/GlobalSuppressions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/GlobalSuppressions.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/GlobalSuppressions.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj b/NetFabric.Hyperlinq.Core.UnitTests/NetFabric.Hyperlinq.Core.UnitTests.csproj
similarity index 53%
rename from NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj
rename to NetFabric.Hyperlinq.Core.UnitTests/NetFabric.Hyperlinq.Core.UnitTests.csproj
index 6e60efb64..d7c4ddcb2 100644
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj
+++ b/NetFabric.Hyperlinq.Core.UnitTests/NetFabric.Hyperlinq.Core.UnitTests.csproj
@@ -1,34 +1,36 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-
+    <TargetFrameworks>net48;netcoreapp2.1;netcoreapp3.1;net6.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
-
+  
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.10.0" />
+    <PackageReference Include="coverlet.msbuild" Version="3.0.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
     <PackageReference Include="NetFabric.Assertive" Version="3.0.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    <PackageReference Include="NetFabric.Hyperlinq.Analyzer" Version="2.0.3">
       <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.0.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="System.Collections.Immutable" Version="5.0.0" />
+    <PackageReference Include="System.Interactive" Version="5.0.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\NetFabric.Hyperlinq.SourceGenerator\NetFabric.Hyperlinq.SourceGenerator.csproj" />
+    <ProjectReference Include="..\NetFabric.Hyperlinq.Core\NetFabric.Hyperlinq.Core.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Update="TestData\**">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Compile>
+    <DotNetCliToolReference Include="dotnet-reportgenerator-cli" Version="4.3.8" />
   </ItemGroup>
 
 </Project>
diff --git a/NetFabric.Hyperlinq.UnitTests/Option/Option.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Option/Option.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Option/Option.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Option/Option.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Option/TestData.Option.cs b/NetFabric.Hyperlinq.Core.UnitTests/Option/TestData.Option.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Option/TestData.Option.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Option/TestData.Option.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Skip.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Skip.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Skip/Skip.ValueReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/SkipTake.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/SkipTake.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/SkipTake.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/SkipTake.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Take.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Take.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.ValueReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.ValueReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Partitioning/Take/Take.ValueReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Partitioning/Take/Take.ValueReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ValueReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ValueReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/Select/Select.ValueReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/Select/Select.ValueReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyList.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyList.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectAt/SelectAt.ValueReadOnlyList.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectVector.TestData.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectVector.TestData.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectVector.TestData.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectVector.TestData.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Projection/SelectVector/SelectVector.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectVector/SelectVector.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Projection/SelectVector/SelectVector.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Projection/SelectVector/SelectVector.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/All/All.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/All/All.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Any/Any.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Any/Any.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.ValueReadOnlyCollection.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.ValueReadOnlyCollection.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.ValueReadOnlyCollection.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/Contains/Contains.ValueReadOnlyCollection.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ArraySegment.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ArraySegment.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ArraySegment.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.AsyncValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.AsyncValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.AsyncValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.AsyncValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ReadOnlyMemory.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ReadOnlyMemory.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ReadOnlyMemory.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ReadOnlyMemory.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ReadOnlySpan.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ReadOnlySpan.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ReadOnlySpan.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ReadOnlySpan.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ValueEnumerable.Tests.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ValueEnumerable.Tests.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Set/Distinct/Distinct.ValueEnumerable.Tests.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/TestData.Empty.cs b/NetFabric.Hyperlinq.Core.UnitTests/TestData/TestData.Empty.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/TestData/TestData.Empty.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/TestData/TestData.Empty.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/TestData.Multiple.cs b/NetFabric.Hyperlinq.Core.UnitTests/TestData/TestData.Multiple.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/TestData/TestData.Multiple.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/TestData/TestData.Multiple.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/TestData.Single.cs b/NetFabric.Hyperlinq.Core.UnitTests/TestData/TestData.Single.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/TestData/TestData.Single.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/TestData/TestData.Single.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/DelegateExtensions.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/DelegateExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/DelegateExtensions.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/DelegateExtensions.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/SpanExtensions.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/SpanExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/SpanExtensions.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/SpanExtensions.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/TestComparer.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/TestComparer.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/TestComparer.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/TestComparer.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs
similarity index 77%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs
index 8579095be..027b9b9ad 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs
@@ -28,11 +28,7 @@ public AsyncEnumerator<T> GetAsyncEnumerator()
             IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationToken _) 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => new AsyncEnumerator<T>(source);
- 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public AsyncEnumerableExtensions.AsyncValueEnumerable<AsyncEnumerableWrapper<T>, AsyncEnumerator<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction, GetAsyncEnumeratorFunction> AsAsyncValueEnumerable()
-                => this.AsAsyncValueEnumerable<AsyncEnumerableWrapper<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction>();
-            
+             
             public readonly struct GetAsyncEnumeratorFunction
                 : IFunction<AsyncEnumerableWrapper<T>, CancellationToken, AsyncEnumerator<T>>
             {
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs
similarity index 78%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs
index cd44977d7..08841b05f 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs
@@ -31,10 +31,6 @@ AsyncEnumerator<T> IAsyncValueEnumerable<T, AsyncEnumerator<T>>.GetAsyncEnumerat
             IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationToken _) 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => new AsyncEnumerator<T>(source);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public AsyncValueEnumerableExtensions.AsyncValueEnumerable<AsyncValueEnumerableWrapper<T>, AsyncEnumerator<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction, GetAsyncEnumeratorFunction> AsAsyncValueEnumerable()
-                => AsyncValueEnumerableExtensions.AsAsyncValueEnumerable<AsyncValueEnumerableWrapper<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction>(this);
             
             public readonly struct GetAsyncEnumeratorFunction
                 : IFunction<AsyncValueEnumerableWrapper<T>, CancellationToken, AsyncEnumerator<T>>
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsCollection.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsCollection.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsCollection.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsCollection.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs
similarity index 81%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs
index 088e62d28..bb738371e 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs
@@ -31,10 +31,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator() 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public EnumerableExtensions.ValueEnumerable<EnumerableWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => this.AsValueEnumerable<EnumerableWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>();
             
             public readonly struct GetEnumeratorFunction
                 : IFunction<EnumerableWrapper<T>, Enumerator<T>>
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsFunctionIn.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsFunctionIn.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsFunctionIn.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsFunctionIn.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsList.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsList.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsList.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsList.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs
similarity index 55%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs
index 8d006b69c..bcb16a3ed 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs
@@ -24,16 +24,6 @@ public ReadOnlyCollectionWrapper(T[] source)
 
             public int Count 
                 => source.Length;
-
-            public new ReadOnlyCollectionExtensions.ValueEnumerable<ReadOnlyCollectionWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ReadOnlyCollectionExtensions.AsValueEnumerable<ReadOnlyCollectionWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-            
-            public new readonly struct GetEnumeratorFunction
-                : IFunction<ReadOnlyCollectionWrapper<T>, Enumerator<T>>
-            {
-                public Enumerator<T> Invoke(ReadOnlyCollectionWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }
         }  
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs
similarity index 81%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs
index c8218969f..1948c72dd 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs
@@ -24,9 +24,6 @@ internal ReadOnlyListWrapper(T[] source)
 
             public T this[int index] 
                 => source[index];
-
-            public new ReadOnlyListExtensions.ValueEnumerable<ReadOnlyListWrapper<T>, T> AsValueEnumerable()
-                => this.AsValueEnumerable<ReadOnlyListWrapper<T>, T>();
         }
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs
similarity index 69%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs
index d09834452..05cdb1dcd 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs
@@ -51,18 +51,6 @@ bool ICollection<T>.Remove(T item)
                 => throw new NotSupportedException();
             void ICollection<T>.Clear() 
                 => throw new NotSupportedException();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyCollectionExtensions.ValueEnumerable<ValueCollectionWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueReadOnlyCollectionExtensions.AsValueEnumerable<ValueCollectionWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-            
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueCollectionWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueCollectionWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }
         }
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs
similarity index 79%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs
index efa262bde..63dff6ba2 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs
@@ -32,10 +32,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator() 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.ValueEnumerable<ValueEnumerableWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueEnumerableExtensions.AsValueEnumerable<ValueEnumerableWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
             
             public readonly struct GetEnumeratorFunction
                 : IFunction<ValueEnumerableWrapper<T>, Enumerator<T>>
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs
similarity index 75%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs
index ef1f3889b..4033031c9 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs
@@ -68,18 +68,6 @@ void IList<T>.Insert(int index, T item)
                 => throw new NotSupportedException();
             void IList<T>.RemoveAt(int index) 
                 => throw new NotSupportedException();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.ValueEnumerable<ValueListWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueReadOnlyListExtensions.AsValueEnumerable<ValueListWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-            
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueListWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueListWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }        
         }
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs
similarity index 60%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs
index 26ff0ffbc..8128eead9 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs
@@ -35,18 +35,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator()
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ReadOnlyCollectionExtensions.ValueEnumerable<ValueReadOnlyCollectionWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ReadOnlyCollectionExtensions.AsValueEnumerable<ValueReadOnlyCollectionWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-            
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueReadOnlyCollectionWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueReadOnlyCollectionWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }
         }
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs
similarity index 62%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs
index 8882b862e..f4b6c386c 100644
--- a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs
@@ -38,18 +38,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator() 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.ValueEnumerable<ValueReadOnlyListWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueReadOnlyListExtensions.AsValueEnumerable<ValueReadOnlyListWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-            
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueReadOnlyListWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueReadOnlyListWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }        
         }
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsyncEnumerator.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsyncEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsyncEnumerator.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsyncEnumerator.cs
diff --git a/NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.Enumerator.cs b/NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.Enumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.Enumerator.cs
rename to NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.Enumerator.cs
diff --git a/NetFabric.Hyperlinq/Aggregation/Count/Count.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ReadOnlySpan.cs
similarity index 68%
rename from NetFabric.Hyperlinq/Aggregation/Count/Count.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ReadOnlySpan.cs
index 72c8dc7a5..f2470d7bf 100644
--- a/NetFabric.Hyperlinq/Aggregation/Count/Count.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ReadOnlySpan.cs
@@ -6,14 +6,14 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int Count<TSource>(this ReadOnlySpan<TSource> source)
+        public static int Count<TSource>(ReadOnlySpan<TSource> source)
             => source.Length;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
+        public static int Count<TSource>(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
             => source.Count(new FunctionWrapper<TSource, bool>(predicate));
 
-        static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
+        public static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
             where TPredicate: struct, IFunction<TSource, bool>
         {
             var counter = 0;
@@ -25,10 +25,10 @@ static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredic
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, int, bool> predicate)
+        public static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, int, bool> predicate)
             => source.CountAt(new FunctionWrapper<TSource, int, bool>(predicate));
 
-        static int CountAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
+        public static int CountAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
             where TPredicate: struct, IFunction<TSource, int, bool>
         {
             var counter = 0;
diff --git a/NetFabric.Hyperlinq/Aggregation/Count/Count.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueEnumerable.cs
similarity index 68%
rename from NetFabric.Hyperlinq/Aggregation/Count/Count.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueEnumerable.cs
index f7eef5479..4e033636d 100644
--- a/NetFabric.Hyperlinq/Aggregation/Count/Count.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueEnumerable.cs
@@ -20,12 +20,6 @@ public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable sour
             return counter;
         }
         
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-
         public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -40,12 +34,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnu
             }
             return counter;
         }
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.CountAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(new FunctionWrapper<TSource, int, bool>(predicate));
 
         public static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Aggregation/Count/Count.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueReadOnlyCollection.cs
similarity index 64%
rename from NetFabric.Hyperlinq/Aggregation/Count/Count.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueReadOnlyCollection.cs
index 0dd554836..6481d6078 100644
--- a/NetFabric.Hyperlinq/Aggregation/Count/Count.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueReadOnlyCollection.cs
@@ -6,17 +6,12 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ValueReadOnlyCollectionExtensions
     {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
             => source.Count;
         
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => Count<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(source, new FunctionWrapper<TSource, bool>(predicate));
-        
         public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -26,12 +21,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnu
                 {Count: 0} => 0,
                 _ => ValueEnumerableExtensions.Count<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate)
             };
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => CountAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(source, new FunctionWrapper<TSource, int, bool>(predicate));
         
         public static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueReadOnlyList.cs
new file mode 100644
index 000000000..11f843b7c
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueReadOnlyList.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Count<TEnumerable, TEnumerator, TSource>(source);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate: struct, IFunction<TSource, bool>
+            => ValueReadOnlyCollectionExtensions.Count<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate: struct, IFunction<TSource, int, bool>
+            => ValueReadOnlyCollectionExtensions.CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs
similarity index 73%
rename from NetFabric.Hyperlinq/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs
index 152bad6f5..efa84676e 100644
--- a/NetFabric.Hyperlinq/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs
@@ -29,12 +29,6 @@ public static async ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource>
             return counter;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            => source.CountAsync<TEnumerable, TEnumerator, TSource, AsyncFunctionWrapper<TSource, bool>>(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
         public static async ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default, CancellationToken cancellationToken = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -60,12 +54,6 @@ public static async ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource,
             return counter;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            => source.CountAtAsync<TEnumerable, TEnumerator, TSource, AsyncFunctionWrapper<TSource, int, bool>>(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
         public static async ValueTask<int> CountAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default, CancellationToken cancellationToken = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.Range.cs b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.Range.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Aggregation/Sum/Sum.Range.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.Range.cs
index 389af6bed..3ca8d9949 100644
--- a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.Range.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.Range.cs
@@ -10,9 +10,7 @@ public static partial class ValueEnumerable
         static int SumRange(int start, int count)
             => count * (start + start + count) / 2;
         
-        [GeneratorIgnore]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [SkipLocalsInit]
         static unsafe TResult SumRange<TResult, TVectorSelector, TSelector>(int start, int count, TVectorSelector vectorSelector, TSelector selector)
             where TVectorSelector : struct, IFunction<Vector<int>, Vector<TResult>>
             where TSelector : struct, IFunction<int, TResult>
diff --git a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ReadOnlySpan.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Aggregation/Sum/Sum.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ReadOnlySpan.cs
index 197420b85..d3e87fe90 100644
--- a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ReadOnlySpan.cs
@@ -6,7 +6,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorIgnore]
+
         static TSum Sum<TSource, TSum>(this ReadOnlySpan<TSource> source)
             where TSum : struct
         {
@@ -26,7 +26,7 @@ static TSum Sum<TSource, TSum>(this ReadOnlySpan<TSource> source)
             return Scalar.Add(sum0, sum1);
         }
         
-        [GeneratorIgnore]
+
         static TSum SumVector<TSource, TSum>(this ReadOnlySpan<TSource> source)
             where TSource : struct
             where TSum : struct
@@ -44,7 +44,7 @@ static TSum SumVector<TSource, TSum>(this ReadOnlySpan<TSource> source)
             return Scalar.Add(vectorSum.Sum(), Sum<TSource, TSum>(source.Slice(source.Length - count, count)));
         }
 
-        [GeneratorIgnore]
+
         static TSum Sum<TSource, TSum, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSum : struct
@@ -66,7 +66,7 @@ static TSum Sum<TSource, TSum, TPredicate>(this ReadOnlySpan<TSource> source, TP
             return Scalar.Add(sum0, sum1);
         }
 
-        [GeneratorIgnore]
+
         static TSum SumAt<TSource, TSum, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, int, bool>
             where TSum : struct
@@ -89,7 +89,7 @@ static TSum SumAt<TSource, TSum, TPredicate>(this ReadOnlySpan<TSource> source,
             return Scalar.Add(sum0, sum1);
         }
 
-        [GeneratorIgnore]
+
         static TSum Sum<TSource, TResult, TSum, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
             where TSum : struct
@@ -110,7 +110,7 @@ static TSum Sum<TSource, TResult, TSum, TSelector>(this ReadOnlySpan<TSource> so
             return Scalar.Add(sum0, sum1);
         }
         
-        [GeneratorIgnore]
+
         static TSum SumVector<TSource, TResult, TSum, TVectorSelector, TSelector>(this ReadOnlySpan<TSource> source, TVectorSelector vectorSelector, TSelector selector)
             where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
             where TSelector : struct, IFunction<TSource, TResult>
@@ -131,7 +131,7 @@ static TSum SumVector<TSource, TResult, TSum, TVectorSelector, TSelector>(this R
             return Scalar.Add(vectorSum.Sum(), Sum<TSource, TResult, TSum, TSelector>(source.Slice(source.Length - count, count), selector));
         }
 
-        [GeneratorIgnore]
+
         static TSum SumAt<TSource, TResult, TSum, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
             where TSum : struct
@@ -153,7 +153,7 @@ static TSum SumAt<TSource, TResult, TSum, TSelector>(this ReadOnlySpan<TSource>
             return Scalar.Add(sum0, sum1);
         }
         
-        [GeneratorIgnore]
+
         static TSum Sum<TSource, TResult, TSum, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TPredicate predicate, TSelector selector)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueEnumerable.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Aggregation/Sum/Sum.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueEnumerable.cs
index 1cc64d0c4..29ab70c16 100644
--- a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueEnumerable.cs
@@ -4,8 +4,8 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ValueEnumerableExtensions
     {
-        [GeneratorIgnore]
-        internal static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source)
+
+        public static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
             where TSum : struct
@@ -17,7 +17,7 @@ internal static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerab
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static TSum Sum<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -34,7 +34,7 @@ internal static TSum Sum<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(th
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static TSum SumAt<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -51,7 +51,7 @@ internal static TSum SumAt<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static TSum Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -68,7 +68,7 @@ internal static TSum Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TSele
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static TSum SumAt<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -85,7 +85,7 @@ internal static TSum SumAt<TEnumerable, TEnumerator, TSource, TResult, TSum, TSe
             return sum;
         }
         
-        [GeneratorIgnore]
+
         internal static TSum Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueReadOnlyCollection.cs
similarity index 93%
rename from NetFabric.Hyperlinq/Aggregation/Sum/Sum.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueReadOnlyCollection.cs
index be0c80100..18b1702ee 100644
--- a/NetFabric.Hyperlinq/Aggregation/Sum/Sum.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueReadOnlyCollection.cs
@@ -4,8 +4,8 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ValueReadOnlyCollectionExtensions
     {
-        [GeneratorIgnore]
-        internal static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source)
+
+        public static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
             where TSum : struct
@@ -15,7 +15,7 @@ internal static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerab
                 _ => ValueEnumerableExtensions.Sum<TEnumerable, TEnumerator, TSource, TSum>(source)
             };
         
-        [GeneratorIgnore]
+
         static TSum Sum<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -27,7 +27,7 @@ static TSum Sum<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnume
                 _ => ValueEnumerableExtensions.Sum<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(source, predicate)
             };
         
-        [GeneratorIgnore]
+
         static TSum SumAt<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -39,7 +39,7 @@ static TSum SumAt<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnu
                 _ => ValueEnumerableExtensions.SumAt<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(source, predicate)
             };
         
-        [GeneratorIgnore]
+
         internal static TSum Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -51,7 +51,7 @@ internal static TSum Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TSele
                 _ => ValueEnumerableExtensions.Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(source, selector)
             };
         
-        [GeneratorIgnore]
+
         internal static TSum SumAt<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -63,7 +63,7 @@ internal static TSum SumAt<TEnumerable, TEnumerator, TSource, TResult, TSum, TSe
                 _ => ValueEnumerableExtensions.SumAt<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(source, selector)
             };
         
-        [GeneratorIgnore]
+
         static TSum Sum<TEnumerable, TEnumerator, TSource, TResult, TSum, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueReadOnlyList.cs
new file mode 100644
index 000000000..3df49ac22
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Sum/Sum.ValueReadOnlyList.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static TSum Sum<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TSum : struct
+            => ValueReadOnlyCollectionExtensions.Sum<TEnumerable, TEnumerator, TSource, TSum>(source);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Aggregation/Sum/SumAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Aggregation/Sum/SumAsync.AsyncValueEnumerable.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Aggregation/Sum/SumAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Aggregation/Sum/SumAsync.AsyncValueEnumerable.cs
index 7727606b0..442427cd2 100644
--- a/NetFabric.Hyperlinq/Aggregation/Sum/SumAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Aggregation/Sum/SumAsync.AsyncValueEnumerable.cs
@@ -6,7 +6,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class AsyncValueEnumerableExtensions
     {
-        [GeneratorIgnore]
+
         public static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource, TSum>(this TEnumerable source, CancellationToken cancellationToken = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -26,7 +26,7 @@ public static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource,
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -51,7 +51,7 @@ internal static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static async ValueTask<TSum> SumAtAsync<TEnumerable, TEnumerator, TSource, TSum, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -76,7 +76,7 @@ internal static async ValueTask<TSum> SumAtAsync<TEnumerable, TEnumerator, TSour
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -100,7 +100,7 @@ internal static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource
             return sum;
         }
 
-        [GeneratorIgnore]
+
         internal static async ValueTask<TSum> SumAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSum, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -124,7 +124,7 @@ internal static async ValueTask<TSum> SumAtAsync<TEnumerable, TEnumerator, TSour
             return sum;
         }
         
-        [GeneratorIgnore]
+
         internal static async ValueTask<TSum> SumAsync<TEnumerable, TEnumerator, TSource, TResult, TSum, TPredicate, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsAsyncEnumerable/AsAsyncEnumerable.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.cs
index 09046a183..b0b7bffb5 100644
--- a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncValueEnumerable.cs
@@ -14,7 +14,6 @@ public static AsyncValueEnumerable<TEnumerator, TSource> AsAsyncValueEnumerable<
             where TEnumerator : struct, IAsyncEnumerator<TSource>
             => new(source);
 
-        [GeneratorBindings(source: "source", sourceImplements: "IAsyncValueEnumerable`2", enumerableType: "IAsyncValueEnumerable<TSource, TEnumerator>")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct AsyncValueEnumerable<TEnumerator, TSource>
             : IAsyncValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs
index ea9b2f9c8..f418e35d8 100644
--- a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs
@@ -11,14 +11,14 @@ namespace NetFabric.Hyperlinq
     public static partial class AsyncEnumerableExtensions
     {
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, CancellationToken, TEnumerator> getAsyncEnumerator)
             where TEnumerable : IAsyncEnumerable<TSource>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
             => AsAsyncValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>>(source, new FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>(getAsyncEnumerator));
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TSource, TGetAsyncEnumerator>(this TEnumerable source, TGetAsyncEnumerator getAsyncEnumerator = default)
             where TEnumerable : IAsyncEnumerable<TSource>
@@ -26,7 +26,7 @@ public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSourc
             where TGetAsyncEnumerator : struct, IFunction<TEnumerable, CancellationToken, TEnumerator>
             => new(source, getAsyncEnumerator, getAsyncEnumerator);
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator2>> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, CancellationToken, TEnumerator> getAsyncEnumerator, Func<TEnumerable, CancellationToken, TEnumerator2> getAsyncEnumerator2)
             where TEnumerable : IAsyncEnumerable<TSource>
@@ -34,7 +34,7 @@ public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSour
             where TEnumerator2 : struct
             => AsAsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>(getAsyncEnumerator), new FunctionWrapper<TEnumerable, CancellationToken, TEnumerator2>(getAsyncEnumerator2));
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2>(this TEnumerable source, TGetAsyncEnumerator getAsyncEnumerator = default, TGetAsyncEnumerator2 getAsyncEnumerator2 = default)
             where TEnumerable : IAsyncEnumerable<TSource>
@@ -54,8 +54,10 @@ public partial struct AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator
             where TGetAsyncEnumerator2 : struct, IFunction<TEnumerable, CancellationToken, TEnumerator2>
         {
             readonly TEnumerable source;
+#pragma warning disable IDE0044 // Add readonly modifier
             TGetAsyncEnumerator getAsyncEnumerator;
             TGetAsyncEnumerator2 getAsyncEnumerator2;
+#pragma warning restore IDE0044 // Add readonly modifier
 
             internal AsyncValueEnumerable(TEnumerable source, TGetAsyncEnumerator getAsyncEnumerator, TGetAsyncEnumerator2 getAsyncEnumerator2)
                 => (this.source, this.getAsyncEnumerator, this.getAsyncEnumerator2) = (source, getAsyncEnumerator, getAsyncEnumerator2);
diff --git a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.cs
index 7fc40740b..c54d790ba 100644
--- a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncValueEnumerable.cs
@@ -10,14 +10,14 @@ namespace NetFabric.Hyperlinq
     public static partial class AsyncValueEnumerableExtensions
     {
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, CancellationToken, TEnumerator> getAsyncEnumerator)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
             => AsAsyncValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>>(source, new FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>(getAsyncEnumerator));
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TSource, TGetAsyncEnumerator>(this TEnumerable source, TGetAsyncEnumerator getAsyncEnumerator = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -25,7 +25,7 @@ public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSourc
             where TGetAsyncEnumerator : struct, IFunction<TEnumerable, CancellationToken, TEnumerator>
             => new(source, getAsyncEnumerator, getAsyncEnumerator);
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator2>> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, CancellationToken, TEnumerator> getAsyncEnumerator, Func<TEnumerable, CancellationToken, TEnumerator2> getAsyncEnumerator2)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -33,7 +33,7 @@ public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSour
             where TEnumerator2 : struct
             => AsAsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>, FunctionWrapper<TEnumerable, CancellationToken, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, CancellationToken, TEnumerator>(getAsyncEnumerator), new FunctionWrapper<TEnumerable, CancellationToken, TEnumerator2>(getAsyncEnumerator2));
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2> AsAsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2>(this TEnumerable source, TGetAsyncEnumerator getAsyncEnumerator = default, TGetAsyncEnumerator2 getAsyncEnumerator2 = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -43,7 +43,6 @@ public static AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSour
             where TGetAsyncEnumerator2 : struct, IFunction<TEnumerable, CancellationToken, TEnumerator2>
             => new(source, getAsyncEnumerator, getAsyncEnumerator2);
 
-        [GeneratorBindings(source: "source", sourceImplements: "IAsyncValueEnumerable`2")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2>
             : IAsyncValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsyncValueEnumerator.cs b/NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsyncValueEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsyncValueEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsAsyncValueEnumerable/AsyncValueEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsEnumerable/AsEnumerable.ValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Array.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Array.cs
similarity index 93%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Array.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Array.cs
index b9cd3a2dc..318d761c2 100644
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Array.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Array.cs
@@ -6,7 +6,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ArraySegmentValueEnumerable<TSource> AsValueEnumerable<TSource>(this TSource[] source)
             => new(new ArraySegment<TSource>(source));
diff --git a/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs
new file mode 100644
index 000000000..c39e49457
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs
@@ -0,0 +1,240 @@
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ArrayExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ArraySegmentValueEnumerable<TSource> AsValueEnumerable<TSource>(this ArraySegment<TSource> source)
+            => new(source);
+
+        [StructLayout(LayoutKind.Auto)]
+        public readonly partial struct ArraySegmentValueEnumerable<TSource>
+            : IValueReadOnlyList<TSource, ArraySegmentValueEnumerable<TSource>.DisposableEnumerator>
+            , IList<TSource>
+        {
+            internal readonly ArraySegment<TSource> source;
+
+            internal ArraySegmentValueEnumerable(ArraySegment<TSource> source)
+                => this.source = source;
+
+            public int Count
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => source.Count;
+            }
+
+            public TSource this[int index]
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get
+                {
+                    ThrowIfArgument.OutOfRange(index, Count, nameof(index));
+                    return source.Array![source.Offset + index];
+                }
+            }
+
+            TSource IList<TSource>.this[int index]
+            {
+                get => this[index];
+
+                [ExcludeFromCodeCoverage]
+                // ReSharper disable once ValueParameterNotUsed
+                set => Throw.NotSupportedException();
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public SpanEnumerator<TSource> GetEnumerator()
+                => new(source);
+
+            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator()
+                => new(source);
+
+            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
+                // ReSharper disable once HeapView.BoxingAllocation
+                => new DisposableEnumerator(source);
+
+            IEnumerator IEnumerable.GetEnumerator()
+                // ReSharper disable once HeapView.BoxingAllocation
+                => new DisposableEnumerator(source);
+
+
+            bool ICollection<TSource>.IsReadOnly
+                => true;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void CopyTo(Span<TSource> span)
+                => source.AsReadOnlySpan().CopyTo(span);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void CopyTo(TSource[] array, int arrayIndex)
+                => ((ICollection<TSource>)source).CopyTo(array, arrayIndex);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool Contains(TSource item)
+                => ((ICollection<TSource>)source).Contains(item);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public int IndexOf(TSource item)
+                => ((IList<TSource>)source).IndexOf(item);
+
+            [ExcludeFromCodeCoverage]
+            void ICollection<TSource>.Add(TSource item)
+                => Throw.NotSupportedException();
+            [ExcludeFromCodeCoverage]
+            bool ICollection<TSource>.Remove(TSource item)
+                => Throw.NotSupportedException<bool>();
+            [ExcludeFromCodeCoverage]
+            void ICollection<TSource>.Clear()
+                => Throw.NotSupportedException();
+
+            [ExcludeFromCodeCoverage]
+            void IList<TSource>.Insert(int index, TSource item)
+                => Throw.NotSupportedException();
+
+            [ExcludeFromCodeCoverage]
+            void IList<TSource>.RemoveAt(int index)
+                => Throw.NotSupportedException();
+
+            [StructLayout(LayoutKind.Auto)]
+            public struct DisposableEnumerator
+                : IEnumerator<TSource>
+            {
+                readonly ArraySegment<TSource> source;
+                int index;
+
+                internal DisposableEnumerator(ArraySegment<TSource> source)
+                {
+                    this.source = source;
+                    index = -1;
+                }
+
+                public readonly TSource Current
+                {
+                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => source.Array![source.Offset + index];
+                }
+                readonly object? IEnumerator.Current
+                    // ReSharper disable once HeapView.PossibleBoxingAllocation
+                    => Current;
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public bool MoveNext()
+                    => ++index < source.Count;
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                [ExcludeFromCodeCoverage]
+                public void Reset()
+                    => index = -1;
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public readonly void Dispose() { }
+            }
+
+            #region Partitioning
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public ArraySegmentValueEnumerable<TSource> Skip(int count)
+            {
+                var (newOffset, newCount) = Utils.Skip(source.Count, count);
+                return new ArraySegmentValueEnumerable<TSource>(new ArraySegment<TSource>(source.Array!, source.Offset + newOffset, newCount));
+            }
+            
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public ArraySegmentValueEnumerable<TSource> Take(int count)
+                => new(new ArraySegment<TSource>(source.Array!, source.Offset, Utils.Take(source.Count, count)));
+
+            #endregion
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int Sum(this ArraySegmentValueEnumerable<int> source)
+            => source.source.AsReadOnlySpan().SumVector<int, int>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int Sum(this ArraySegmentValueEnumerable<int?> source)
+            => source.source.AsReadOnlySpan().Sum<int?, int>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static nint Sum(this ArraySegmentValueEnumerable<nint> source)
+            => source.source.AsReadOnlySpan().SumVector<nint, nint>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static nint Sum(this ArraySegmentValueEnumerable<nint?> source)
+            => source.source.AsReadOnlySpan().Sum<nint?, nint>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static nuint Sum(this ArraySegmentValueEnumerable<nuint> source)
+            => source.source.AsReadOnlySpan().SumVector<nuint, nuint>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static nuint Sum(this ArraySegmentValueEnumerable<nuint?> source)
+            => source.source.AsReadOnlySpan().Sum<nuint?, nuint>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static long Sum(this ArraySegmentValueEnumerable<long> source)
+            => source.source.AsReadOnlySpan().SumVector<long, long>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static long Sum(this ArraySegmentValueEnumerable<long?> source)
+            => source.source.AsReadOnlySpan().Sum<long?, long>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Sum(this ArraySegmentValueEnumerable<float> source)
+            => source.source.AsReadOnlySpan().SumVector<float, float>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Sum(this ArraySegmentValueEnumerable<float?> source)
+            => source.source.AsReadOnlySpan().Sum<float?, float>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double Sum(this ArraySegmentValueEnumerable<double> source)
+            => source.source.AsReadOnlySpan().SumVector<double, double>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double Sum(this ArraySegmentValueEnumerable<double?> source)
+            => source.source.AsReadOnlySpan().Sum<double?, double>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static decimal Sum(this ArraySegmentValueEnumerable<decimal> source)
+            => source.source.AsReadOnlySpan().Sum<decimal, decimal>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static decimal Sum(this ArraySegmentValueEnumerable<decimal?> source)
+            => source.source.AsReadOnlySpan().Sum<decimal?, decimal>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsVector<TSource>(this ArraySegmentValueEnumerable<TSource> source, TSource value)
+            where TSource : struct
+            => source.source.AsReadOnlySpan().ContainsVector(value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static SpanSelectVectorContext<TSource, TResult, FunctionWrapper<Vector<TSource>, Vector<TResult>>, FunctionWrapper<TSource, TResult>> SelectVector<TSource, TResult>(this ArraySegmentValueEnumerable<TSource> source, Func<Vector<TSource>, Vector<TResult>> vectorSelector, Func<TSource, TResult> selector)
+            where TSource : struct
+            where TResult : struct
+            => source.source.AsReadOnlySpan().SelectVector(vectorSelector, selector);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static SpanSelectVectorContext<TSource, TResult, TSelector, TSelector> SelectVector<TSource, TResult, TSelector>(this ArraySegmentValueEnumerable<TSource> source, TSelector selector = default)
+            where TSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>, IFunction<TSource, TResult>
+            where TSource : struct
+            where TResult : struct
+            => source.source.AsReadOnlySpan().SelectVector<TSource, TResult, TSelector, TSelector>(selector, selector);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static SpanSelectVectorContext<TSource, TResult, TVectorSelector, TSelector> SelectVector<TSource, TResult, TVectorSelector, TSelector>(this ArraySegmentValueEnumerable<TSource> source, TVectorSelector vectorSelector = default, TSelector selector = default)
+            where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
+            where TSelector : struct, IFunction<TSource, TResult>
+            where TSource : struct
+            where TResult : struct
+            => source.source.AsReadOnlySpan().SelectVector<TSource, TResult, TVectorSelector, TSelector>(vectorSelector, selector);
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArrayExtensions.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ImmutableArray.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArrayExtensions.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ImmutableArray.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/ListExtensions.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.List.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/ListExtensions.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.List.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Memory.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Memory.cs
similarity index 76%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Memory.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Memory.cs
index ce41542a3..7b25a3c4e 100644
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Memory.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Memory.cs
@@ -6,9 +6,8 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static MemoryValueEnumerable<TSource> AsValueEnumerable<TSource>(this Memory<TSource> source)
-            => ((ReadOnlyMemory<TSource>)source).AsValueEnumerable();
+            => source.AsReadOnlyMemory().AsValueEnumerable();
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.cs
similarity index 91%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.cs
index 621f02484..d58c7cf91 100644
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlyMemory.cs
@@ -11,12 +11,11 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static MemoryValueEnumerable<TSource> AsValueEnumerable<TSource>(this ReadOnlyMemory<TSource> source)
             => new(source);
 
-        [GeneratorBindings(source: "source.Span", sourceImplements: "ReadOnlySpan`1")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct MemoryValueEnumerable<TSource>
             : IValueReadOnlyList<TSource, MemoryValueEnumerable<TSource>.DisposableEnumerator>
@@ -236,28 +235,6 @@ public MemoryDistinctEnumerable<TSource> Distinct(IEqualityComparer<TSource>? co
             #endregion
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this MemoryValueEnumerable<TSource> source)
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this MemoryValueEnumerable<TSource> source, Func<TSource, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TPredicate>(this MemoryValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this MemoryValueEnumerable<TSource> source, Func<TSource, int, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TSource, TPredicate>(this MemoryValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum(this MemoryValueEnumerable<int> source)
             => source.source.Span.SumVector<int, int>();
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.cs
similarity index 54%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.cs
index 3d8b97c67..ac5a927cf 100644
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.ReadOnlySpan.cs
@@ -10,12 +10,10 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SpanValueEnumerable<TSource> AsValueEnumerable<TSource>(this ReadOnlySpan<TSource> source)
             => new(source);
 
-        [GeneratorBindings(source: "source", sourceImplements: "ReadOnlySpan`1")]
         [StructLayout(LayoutKind.Auto)]
         public readonly ref partial struct SpanValueEnumerable<TSource>
         {
@@ -24,6 +22,12 @@ public readonly ref partial struct SpanValueEnumerable<TSource>
             internal SpanValueEnumerable(ReadOnlySpan<TSource> source)
                 => this.source = source;
 
+            public ReadOnlySpan<TSource> Span
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => source;
+            }
+
             public int Count
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -39,48 +43,6 @@ public TSource this[int index]
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SpanEnumerator<TSource> GetEnumerator()
                 => new(source);
-
-            #region Aggregation
-
-            #endregion
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanValueEnumerable<TSource> AsEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanValueEnumerable<TSource> AsValueEnumerable()
-                => this;
-
-            #endregion
-
-            #region Element
-
-            #endregion
-            
-            #region Filtering
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanWhereEnumerable<TSource, FunctionWrapper<TSource, bool>> Where(Func<TSource, bool> predicate)
-                => source.Where(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanWhereEnumerable<TSource, TPredicate> Where<TPredicate>(TPredicate predicate = default)
-                where TPredicate : struct, IFunction<TSource, bool>
-                => source.Where(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanWhereAtEnumerable<TSource, FunctionWrapper<TSource, int, bool>> Where(Func<TSource, int, bool> predicate)
-                => source.Where(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanWhereAtEnumerable<TSource, TPredicate> WhereAt<TPredicate>(TPredicate predicate = default)
-                where TPredicate : struct, IFunction<TSource, int, bool>
-                => source.WhereAt(predicate);
-
-            #endregion
              
             #region Partitioning
 
@@ -97,53 +59,6 @@ public SpanValueEnumerable<TSource> Take(int count)
 
             #endregion
 
-            #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanSelectEnumerable<TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, TResult> selector)
-                => source.Select(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanSelectEnumerable<TSource, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, TResult>
-                => source.Select<TSource, TResult, TSelector>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanSelectAtEnumerable<TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TResult>(Func<TSource, int, TResult> selector)
-                => source.Select(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanSelectAtEnumerable<TSource, TResult, TSelector> SelectAt<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, int, TResult>
-                => source.SelectAt<TSource, TResult, TSelector>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult>(Func<TSource, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult>
-                => source.SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector> SelectMany<TSubEnumerable, TSubEnumerator, TResult, TSelector>(TSelector selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult>
-                where TSelector : struct, IFunction<TSource, TSubEnumerable>
-                => source.SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(selector);
-
-            #endregion
-
-            #region Quantifier
-
-            #endregion
-
-            #region Set
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanDistinctEnumerable<TSource> Distinct(IEqualityComparer<TSource>? comparer = default)
-                => source.Distinct(comparer);
-
-            #endregion
-
             public bool SequenceEqual(IEnumerable<TSource> other, IEqualityComparer<TSource>? comparer = null)
             {
                 comparer ??= EqualityComparer<TSource>.Default;
@@ -167,28 +82,6 @@ public bool SequenceEqual(IEnumerable<TSource> other, IEqualityComparer<TSource>
             }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this SpanValueEnumerable<TSource> source)
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this SpanValueEnumerable<TSource> source, Func<TSource, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TPredicate>(this SpanValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this SpanValueEnumerable<TSource> source, Func<TSource, int, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TSource, TPredicate>(this SpanValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum(this SpanValueEnumerable<int> source)
             => source.source.SumVector<int, int>();
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Span.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Span.cs
similarity index 77%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Span.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Span.cs
index 821f8da57..3384b4eac 100644
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.Span.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/AsValueEnumerable.Span.cs
@@ -6,9 +6,9 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SpanValueEnumerable<TSource> AsValueEnumerable<TSource>(this Span<TSource> source)
-            => ((ReadOnlySpan<TSource>)source).AsValueEnumerable();
+            => source.AsReadOnlySpan().AsValueEnumerable();
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/SpanEnumerator.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/SpanEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/SpanEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/SpanEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/ValueEnumerator.cs b/NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/ValueEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Conversion/AsValueEnumerable/ValueEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Conversion/AsValueEnumerable/ValueEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ReadOnlySpan.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ReadOnlySpan.cs
index c7343d194..844bf3341 100644
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ReadOnlySpan.cs
@@ -23,7 +23,6 @@ public static Lease<TSource> ToArray<TSource>(this ReadOnlySpan<TSource> source,
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         static TSource[] ToArray<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, bool>
         {
@@ -34,7 +33,6 @@ static TSource[] ToArray<TSource, TPredicate>(this ReadOnlySpan<TSource> source,
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         static Lease<TSource> ToArray<TSource, TPredicate>(this ReadOnlySpan<TSource> source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, bool>
         {
@@ -48,7 +46,6 @@ static Lease<TSource> ToArray<TSource, TPredicate>(this ReadOnlySpan<TSource> so
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         static TSource[] ToArrayAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, int, bool>
         {
@@ -59,7 +56,6 @@ static TSource[] ToArrayAt<TSource, TPredicate>(this ReadOnlySpan<TSource> sourc
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         static Lease<TSource> ToArrayAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, int, bool>
         {
@@ -73,7 +69,6 @@ static Lease<TSource> ToArrayAt<TSource, TPredicate>(this ReadOnlySpan<TSource>
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         static TResult[] ToArray<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
         {
@@ -85,7 +80,6 @@ static TResult[] ToArray<TSource, TResult, TSelector>(this ReadOnlySpan<TSource>
             return result;
         }
 
-        [GeneratorIgnore]
         static TResult[] ToArrayVector<TSource, TResult, TVectorSelector, TSelector>(this ReadOnlySpan<TSource> source, TVectorSelector vectorSelector, TSelector selector)
             where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
             where TSelector : struct, IFunction<TSource, TResult>
@@ -100,7 +94,6 @@ static TResult[] ToArrayVector<TSource, TResult, TVectorSelector, TSelector>(thi
             return result;
         }
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArrayVector<TSource, TResult, TVectorSelector, TSelector>(this ReadOnlySpan<TSource> source, ArrayPool<TResult> pool, bool clearOnDispose, TVectorSelector vectorSelector, TSelector selector)
             where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
             where TSelector : struct, IFunction<TSource, TResult>
@@ -115,7 +108,6 @@ static Lease<TResult> ToArrayVector<TSource, TResult, TVectorSelector, TSelector
             return result;
         }
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArray<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, ArrayPool<TResult> pool, bool clearOnDispose, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
         {
@@ -129,7 +121,6 @@ static Lease<TResult> ToArray<TSource, TResult, TSelector>(this ReadOnlySpan<TSo
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         static TResult[] ToArrayAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
         {
@@ -141,7 +132,6 @@ static TResult[] ToArrayAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSourc
             return result;
         }
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArrayAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, ArrayPool<TResult> pool, bool clearOnDispose, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
         {
@@ -156,7 +146,6 @@ static Lease<TResult> ToArrayAt<TSource, TResult, TSelector>(this ReadOnlySpan<T
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         static TResult[] ToArray<TSource, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TPredicate predicate, TSelector selector)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, TResult>
@@ -168,7 +157,6 @@ static TResult[] ToArray<TSource, TResult, TPredicate, TSelector>(this ReadOnlyS
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArray<TSource, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, ArrayPool<TResult> pool, bool clearOnDispose, TPredicate predicate, TSelector selector)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueEnumerable.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueEnumerable.cs
index 36108fba9..33ce977bc 100644
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueEnumerable.cs
@@ -49,7 +49,6 @@ public static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource>(this TEn
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         internal static TSource[] ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -59,7 +58,6 @@ internal static TSource[] ToArray<TEnumerable, TEnumerator, TSource, TPredicate>
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         internal static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -72,7 +70,6 @@ internal static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource, TPredi
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         internal static TSource[] ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -82,7 +79,6 @@ internal static TSource[] ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicat
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         internal static Lease<TSource> ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -95,7 +91,6 @@ internal static Lease<TSource> ToArrayAt<TEnumerable, TEnumerator, TSource, TPre
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -105,7 +100,6 @@ static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -117,7 +111,6 @@ static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelec
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         static TResult[] ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -127,7 +120,6 @@ static TResult[] ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -139,8 +131,6 @@ static Lease<TResult> ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSel
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-
-        [GeneratorIgnore]
         internal static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -151,7 +141,6 @@ internal static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TP
             return arrayBuilder.ToArray();
         }
 
-        [GeneratorIgnore]
         internal static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -162,4 +151,4 @@ internal static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResul
             return arrayBuilder.ToArray(pool, clearOnDispose);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueReadOnlyCollection.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueReadOnlyCollection.cs
index 1a46283c4..e0d85d4d8 100644
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueReadOnlyCollection.cs
@@ -42,7 +42,6 @@ public static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource>(this TEn
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         static TSource[] ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source,
             TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -52,7 +51,6 @@ static TSource[] ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(this TEn
                 ? Array.Empty<TSource>() 
                 : ValueEnumerableExtensions.ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-        [GeneratorIgnore]
         static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -63,7 +61,6 @@ static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(thi
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         static TSource[] ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -72,7 +69,7 @@ static TSource[] ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(this T
                 ? Array.Empty<TSource>() 
                 : ValueEnumerableExtensions.ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Lease<TSource> ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -84,7 +81,6 @@ static Lease<TSource> ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(t
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         internal static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -98,7 +94,6 @@ internal static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TS
             return result;
         }
 
-        [GeneratorIgnore]
         internal static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -115,7 +110,6 @@ internal static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResul
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-        [GeneratorIgnore]
         internal static TResult[] ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -129,7 +123,6 @@ internal static TResult[] ToArrayAt<TEnumerable, TEnumerator, TSource, TResult,
             return result;
         }
 
-        [GeneratorIgnore]
         internal static Lease<TResult> ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -145,7 +138,6 @@ internal static Lease<TResult> ToArrayAt<TEnumerable, TEnumerator, TSource, TRes
         
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
         static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -155,7 +147,6 @@ static TResult[] ToArray<TEnumerable, TEnumerator, TSource, TResult, TPredicate,
                 ? Array.Empty<TResult>()
                 : ValueEnumerableExtensions.ToArray<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(source, predicate, selector);
 
-        [GeneratorIgnore]
         static Lease<TResult> ToArray<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueReadOnlyList.cs
new file mode 100644
index 000000000..1ea33e6da
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArray.ValueReadOnlyList.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static TSource[] ToArray<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.ToArray<TEnumerable, TEnumerator, TSource>(source);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Lease<TSource> ToArray<TEnumerable, TEnumerator, TSource>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.ToArray<TEnumerable, TEnumerator, TSource>(source, pool, clearOnDispose);
+    }
+}
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.cs
index a062b1ec7..58bfebf82 100644
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.cs
@@ -23,7 +23,7 @@ public static async ValueTask<Lease<TSource>> ToArrayAsync<TEnumerable, TEnumera
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<TSource[]> ToArrayAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -31,7 +31,7 @@ static async ValueTask<TSource[]> ToArrayAsync<TEnumerable, TEnumerator, TSource
             where TPredicate : struct, IAsyncFunction<TSource, bool>
             => (await source.ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource, TPredicate>(ArrayPool<TSource>.Shared, false, cancellationToken, predicate).ConfigureAwait(false)).ToArray();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Lease<TSource>> ToArrayAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -41,7 +41,7 @@ static async ValueTask<Lease<TSource>> ToArrayAsync<TEnumerable, TEnumerator, TS
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<TSource[]> ToArrayAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -49,7 +49,7 @@ static async ValueTask<TSource[]> ToArrayAtAsync<TEnumerable, TEnumerator, TSour
             where TPredicate : struct, IAsyncFunction<TSource, int, bool>
             => (await source.ToArrayBuilderAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(ArrayPool<TSource>.Shared, false, cancellationToken, predicate).ConfigureAwait(false)).ToArray();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Lease<TSource>> ToArrayAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> pool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -59,7 +59,7 @@ static async ValueTask<Lease<TSource>> ToArrayAtAsync<TEnumerable, TEnumerator,
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<TResult[]> ToArrayAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -67,7 +67,7 @@ static async ValueTask<TResult[]> ToArrayAsync<TEnumerable, TEnumerator, TSource
             where TSelector : struct, IAsyncFunction<TSource, TResult>
             => (await source.ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(ArrayPool<TResult>.Shared, false, cancellationToken, selector).ConfigureAwait(false)).ToArray();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Lease<TResult>> ToArrayAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, CancellationToken cancellationToken, bool clearOnDispose, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -77,7 +77,7 @@ static async ValueTask<Lease<TResult>> ToArrayAsync<TEnumerable, TEnumerator, TS
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<TResult[]> ToArrayAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -85,7 +85,7 @@ static async ValueTask<TResult[]> ToArrayAtAsync<TEnumerable, TEnumerator, TSour
             where TSelector : struct, IAsyncFunction<TSource, int, TResult>
             => (await source.ToArrayBuilderAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(ArrayPool<TResult>.Shared, false, cancellationToken, selector).ConfigureAwait(false)).ToArray();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Lease<TResult>> ToArrayAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, CancellationToken cancellationToken, bool clearOnDispose, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -95,7 +95,7 @@ static async ValueTask<Lease<TResult>> ToArrayAtAsync<TEnumerable, TEnumerator,
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<TResult[]> ToArrayAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -104,7 +104,7 @@ static async ValueTask<TResult[]> ToArrayAsync<TEnumerable, TEnumerator, TSource
             where TSelector : struct, IAsyncFunction<TSource, TResult>
             => (await source.ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(ArrayPool<TResult>.Shared, false, cancellationToken, predicate, selector).ConfigureAwait(false)).ToArray();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Lease<TResult>> ToArrayAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, ArrayPool<TResult> pool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ReadOnlySpan.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ReadOnlySpan.cs
index 5631d82a0..a01acfc42 100644
--- a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ReadOnlySpan.cs
@@ -24,7 +24,7 @@ static Dictionary<TKey, TSource> ToDictionary<TSource, TKey, TKeySelector>(this
             return dictionary;
         }
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TSource> ToDictionary<TSource, TKey, TKeySelector, TPredicate>(this ReadOnlySpan<TSource> source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TKey : notnull
             where TKeySelector : struct, IFunction<TSource, TKey>
@@ -40,7 +40,7 @@ static Dictionary<TKey, TSource> ToDictionary<TSource, TKey, TKeySelector, TPred
             return dictionary;
         }
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TSource> ToDictionaryAt<TSource, TKey, TKeySelector, TPredicate>(this ReadOnlySpan<TSource> source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TKey : notnull
             where TKeySelector : struct, IFunction<TSource, TKey>
@@ -57,7 +57,7 @@ static Dictionary<TKey, TSource> ToDictionaryAt<TSource, TKey, TKeySelector, TPr
             return dictionary;
         }
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TResult> ToDictionary<TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate, TSelector selector)
             where TKey : notnull
             where TKeySelector : struct, IFunction<TResult, TKey>
@@ -98,7 +98,7 @@ static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement, TKeySele
             return dictionary;
         }
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TElement>
             ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(
                 this ReadOnlySpan<TSource> source, TKeySelector keySelector, TElementSelector elementSelector,
@@ -118,7 +118,7 @@ static Dictionary<TKey, TElement>
             return dictionary;
         }
         
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TElement>
             ToDictionaryAt<TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(
                 this ReadOnlySpan<TSource> source, TKeySelector keySelector, TElementSelector elementSelector,
@@ -140,7 +140,7 @@ static Dictionary<TKey, TElement>
             return dictionary;
         }
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate, TSelector selector)
             where TKey : notnull
             where TKeySelector : struct, IFunction<TResult, TKey>
diff --git a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueEnumerable.cs
similarity index 85%
rename from NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueEnumerable.cs
index 7bdd23b00..72e8f2c28 100644
--- a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueEnumerable.cs
@@ -8,13 +8,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey>(this TEnumerable source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TKey : notnull
-            => source.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, FunctionWrapper<TSource, TKey>>(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
         public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -31,7 +24,7 @@ public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, T
             return dictionary;
         }
 
-        [GeneratorIgnore]
+
         internal static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -51,7 +44,7 @@ internal static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator,
         }
 
         
-        [GeneratorIgnore]
+
         internal static Dictionary<TKey, TSource> ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -73,7 +66,7 @@ internal static Dictionary<TKey, TSource> ToDictionaryAt<TEnumerable, TEnumerato
             }
         }
 
-        [GeneratorIgnore]
+
         internal static Dictionary<TKey, TResult> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -98,13 +91,6 @@ internal static Dictionary<TKey, TResult> ToDictionary<TEnumerable, TEnumerator,
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement>(this TEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TKey : notnull
-            => source.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-
         public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -124,7 +110,7 @@ public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator,
             return dictionary;
         }
         
-        [GeneratorIgnore]
+
         internal static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -144,7 +130,7 @@ internal static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator
             return dictionary;
         }
         
-        [GeneratorIgnore]
+
         internal static Dictionary<TKey, TElement> ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -167,7 +153,7 @@ internal static Dictionary<TKey, TElement> ToDictionaryAt<TEnumerable, TEnumerat
             }
         }
         
-        [GeneratorIgnore]
+
         internal static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TResult, TPredicate, TSelector>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueReadOnlyCollection.cs
similarity index 83%
rename from NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueReadOnlyCollection.cs
index 6d3eb4e85..da53b8cae 100644
--- a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionary.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueReadOnlyCollection.cs
@@ -6,13 +6,6 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ValueReadOnlyCollectionExtensions
     {
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey>(this TEnumerable source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TKey : notnull
-            => ToDictionary<TEnumerable, TEnumerator, TSource, TKey, FunctionWrapper<TSource, TKey>>(source, new FunctionWrapper<TSource, TKey>(keySelector), comparer);
 
         public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -24,7 +17,7 @@ public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, T
                 ? new Dictionary<TKey, TSource>()
                 : ValueEnumerableExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector>(source, keySelector, comparer);
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -37,7 +30,7 @@ static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource,
                 : ValueEnumerableExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(source, keySelector, comparer, predicate);
 
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TSource> ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -49,7 +42,7 @@ static Dictionary<TKey, TSource> ToDictionaryAt<TEnumerable, TEnumerator, TSourc
                 ? new Dictionary<TKey, TSource>()
                 : ValueEnumerableExtensions.ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(source, keySelector, comparer, predicate);
         
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TResult> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -64,13 +57,6 @@ static Dictionary<TKey, TResult> ToDictionary<TEnumerable, TEnumerator, TSource,
 
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement>(this TEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TKey : notnull
-            => ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(source, new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
 
         public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -84,7 +70,7 @@ public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator,
                 : ValueEnumerableExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector>(source, keySelector, elementSelector, comparer);
 
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -98,7 +84,7 @@ static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource
                 : ValueEnumerableExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(source, keySelector, elementSelector, comparer, predicate);
 
 
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TElement> ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -111,7 +97,7 @@ static Dictionary<TKey, TElement> ToDictionaryAt<TEnumerable, TEnumerator, TSour
                 ? new Dictionary<TKey, TElement>()
                 : ValueEnumerableExtensions.ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(source, keySelector, elementSelector, comparer, predicate);
         
-        [GeneratorIgnore]
+
         static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TResult, TPredicate, TSelector>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueReadOnlyList.cs
new file mode 100644
index 000000000..edac0afbb
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionary.ValueReadOnlyList.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Dictionary<TKey, TSource> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector>(this TEnumerable source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TKey : notnull
+            where TKeySelector : struct, IFunction<TSource, TKey>
+            => ValueReadOnlyCollectionExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector>(source, keySelector, comparer);
+
+        //////////////////////////////////////////////////////////////////////////////////////////////////
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Dictionary<TKey, TElement> ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector>(this TEnumerable source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TKey : notnull
+            where TKeySelector : struct, IFunction<TSource, TKey>
+            where TElementSelector : struct, IFunction<TSource, TElement>
+            => ValueReadOnlyCollectionExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector>(source, keySelector, elementSelector, comparer);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionaryAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionaryAsync.AsyncValueEnumerable.cs
similarity index 88%
rename from NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionaryAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionaryAsync.AsyncValueEnumerable.cs
index 8dd683283..e098c5d12 100644
--- a/NetFabric.Hyperlinq/Conversion/ToDictionary/ToDictionaryAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToDictionary/ToDictionaryAsync.AsyncValueEnumerable.cs
@@ -9,16 +9,6 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class AsyncValueEnumerableExtensions
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey>(
-            this TEnumerable source, 
-            Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, 
-            IEqualityComparer<TKey>? comparer = default,
-            CancellationToken cancellationToken = default)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            where TKey : notnull 
-            => source.ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, AsyncFunctionWrapper<TSource, TKey>>(new AsyncFunctionWrapper<TSource, TKey>(keySelector), comparer, cancellationToken);
 
         public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector>(
             this TEnumerable source, 
@@ -58,7 +48,7 @@ await keySelector.InvokeAsync(item, cancellationToken).ConfigureAwait(false),
         }
 
         
-        [GeneratorIgnore]
+
         static async ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(
             this TEnumerable source, 
             TKeySelector keySelector, 
@@ -93,7 +83,7 @@ await keySelector.InvokeAsync(item, cancellationToken).ConfigureAwait(false),
         }
 
 
-        [GeneratorIgnore]
+
         static async ValueTask<Dictionary<TKey, TSource>> ToDictionaryAtAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(
             this TEnumerable source, 
             TKeySelector keySelector, 
@@ -131,7 +121,7 @@ await keySelector.InvokeAsync(item, cancellationToken).ConfigureAwait(false),
             }
         }
 
-        [GeneratorIgnore]
+
         static async ValueTask<Dictionary<TKey, TResult>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(
             this TEnumerable source, 
             TKeySelector keySelector, 
@@ -172,18 +162,6 @@ static async ValueTask<Dictionary<TKey, TResult>> ToDictionaryAsync<TEnumerable,
 
         //////////////////////////////////////////////////////////////////////////////////////////////////
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TElement>(
-            this TEnumerable source,
-            Func<TSource, CancellationToken, ValueTask<TKey>> keySelector,
-            Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector,
-            IEqualityComparer<TKey>? comparer = default,
-            CancellationToken cancellationToken = default)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            where TKey : notnull
-            => source.ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TElement, AsyncFunctionWrapper<TSource, TKey>, AsyncFunctionWrapper<TSource, TElement>>(new AsyncFunctionWrapper<TSource, TKey>(keySelector), new AsyncFunctionWrapper<TSource, TElement>(elementSelector), comparer, cancellationToken);
-
         public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector>(
             this TEnumerable source, 
             TKeySelector keySelector, 
@@ -223,7 +201,7 @@ await keySelector.InvokeAsync(item, cancellationToken).ConfigureAwait(false),
         }
 
         
-        [GeneratorIgnore]
+
         static async ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(
             this TEnumerable source, 
             TKeySelector keySelector, 
@@ -260,7 +238,7 @@ await keySelector.InvokeAsync(item, cancellationToken).ConfigureAwait(false),
         }
 
         
-        [GeneratorIgnore]
+
         static async ValueTask<Dictionary<TKey, TElement>> ToDictionaryAtAsync<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(
             this TEnumerable source, 
             TKeySelector keySelector, 
@@ -300,7 +278,7 @@ await keySelector.InvokeAsync(item, cancellationToken).ConfigureAwait(false),
         }
         
 
-        [GeneratorIgnore]
+
         static async ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TElement, TKeySelector, TElementSelector, TResult, TPredicate, TSelector>(
             this TEnumerable source, 
             TKeySelector keySelector, 
diff --git a/NetFabric.Hyperlinq/Conversion/ToList/ToList.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ReadOnlySpan.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Conversion/ToList/ToList.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ReadOnlySpan.cs
index ab86e865f..bb4f7dfb4 100644
--- a/NetFabric.Hyperlinq/Conversion/ToList/ToList.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ReadOnlySpan.cs
@@ -13,25 +13,25 @@ public static partial class ArrayExtensions
         static List<TSource> ToList<TSource>(this ReadOnlySpan<TSource> source)
             => source.ToArray().AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TSource> ToList<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, bool>
             => source.ToArray(predicate).AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TSource> ToListAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, int, bool>
             => source.ToArrayAt(predicate).AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToList<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
             => source.ToArray<TSource, TResult, TSelector>(selector).AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToListVector<TSource, TResult, TVectorSelector, TSelector>(this ReadOnlySpan<TSource> source, TVectorSelector vectorSelector, TSelector selector)
             where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
@@ -40,13 +40,13 @@ static List<TResult> ToListVector<TSource, TResult, TVectorSelector, TSelector>(
             where TResult : struct
             => source.ToArrayVector<TSource, TResult, TVectorSelector, TSelector>(vectorSelector, selector).AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToListAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
             => source.ToArrayAt<TSource, TResult, TSelector>(selector).AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToList<TSource, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TPredicate predicate, TSelector selector)
             where TPredicate : struct, IFunction<TSource, bool>
diff --git a/NetFabric.Hyperlinq/Conversion/ToList/ToList.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueEnumerable.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Conversion/ToList/ToList.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueEnumerable.cs
index 9a42620e6..2b03337c3 100644
--- a/NetFabric.Hyperlinq/Conversion/ToList/ToList.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueEnumerable.cs
@@ -14,7 +14,7 @@ public static List<TSource> ToList<TEnumerable, TEnumerator, TSource>(this TEnum
             => source.ToArray<TEnumerable, TEnumerator, TSource>().AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TSource> ToList<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -23,7 +23,7 @@ static List<TSource> ToList<TEnumerable, TEnumerator, TSource, TPredicate>(this
             => source.ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(predicate).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TSource> ToListAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -32,7 +32,7 @@ static List<TSource> ToListAt<TEnumerable, TEnumerator, TSource, TPredicate>(thi
             => source.ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(predicate).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToList<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -41,7 +41,7 @@ static List<TResult> ToList<TEnumerable, TEnumerator, TSource, TResult, TSelecto
             => source.ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(selector).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToListAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -49,7 +49,7 @@ static List<TResult> ToListAt<TEnumerable, TEnumerator, TSource, TResult, TSelec
             where TSelector : struct, IFunction<TSource, int, TResult>
             => source.ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(selector).AsList();
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToList<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Conversion/ToList/ToList.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueReadOnlyCollection.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Conversion/ToList/ToList.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueReadOnlyCollection.cs
index 73e8947a8..ae60dc6d8 100644
--- a/NetFabric.Hyperlinq/Conversion/ToList/ToList.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueReadOnlyCollection.cs
@@ -17,7 +17,7 @@ public static List<TSource> ToList<TEnumerable, TEnumerator, TSource>(this TEnum
                 _ => ToArray<TEnumerable, TEnumerator, TSource>(source).AsList(),
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TSource> ToList<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -25,7 +25,7 @@ static List<TSource> ToList<TEnumerable, TEnumerator, TSource, TPredicate>(this
             where TPredicate : struct, IFunction<TSource, bool>
             => ToArray<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate).AsList(); 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TSource> ToListAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -33,7 +33,7 @@ static List<TSource> ToListAt<TEnumerable, TEnumerator, TSource, TPredicate>(thi
             where TPredicate : struct, IFunction<TSource, int, bool>
             => ToArrayAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate).AsList(); 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static List<TResult> ToList<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -41,7 +41,7 @@ internal static List<TResult> ToList<TEnumerable, TEnumerator, TSource, TResult,
             where TSelector : struct, IFunction<TSource, TResult>
             => ToArray<TEnumerable, TEnumerator, TSource, TResult, TSelector>(source, selector).AsList(); 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static List<TResult> ToListAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -49,7 +49,7 @@ internal static List<TResult> ToListAt<TEnumerable, TEnumerator, TSource, TResul
             where TSelector : struct, IFunction<TSource, int, TResult>
             => ToArrayAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(source, selector).AsList(); 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static List<TResult> ToList<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueReadOnlyList.cs
new file mode 100644
index 000000000..e69e0402f
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToList.ValueReadOnlyList.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static List<TSource> ToList<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.ToList<TEnumerable, TEnumerator, TSource>(source);
+    }
+}
diff --git a/NetFabric.Hyperlinq/Conversion/ToList/ToListAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToListAsync.AsyncValueEnumerable.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Conversion/ToList/ToListAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Conversion/ToList/ToListAsync.AsyncValueEnumerable.cs
index 465d62854..3d4a0f681 100644
--- a/NetFabric.Hyperlinq/Conversion/ToList/ToListAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Conversion/ToList/ToListAsync.AsyncValueEnumerable.cs
@@ -16,7 +16,7 @@ public static async ValueTask<List<TSource>> ToListAsync<TEnumerable, TEnumerato
             => (await source.ToArrayAsync<TEnumerable, TEnumerator, TSource>(cancellationToken).ConfigureAwait(false)).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<List<TSource>> ToListAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -25,7 +25,7 @@ static async ValueTask<List<TSource>> ToListAsync<TEnumerable, TEnumerator, TSou
             => (await source.ToArrayAsync<TEnumerable, TEnumerator, TSource, TPredicate>(cancellationToken, predicate).ConfigureAwait(false)).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<List<TSource>> ToListAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -34,7 +34,7 @@ static async ValueTask<List<TSource>> ToListAtAsync<TEnumerable, TEnumerator, TS
             => (await source.ToArrayAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(cancellationToken, predicate).ConfigureAwait(false)).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<List<TResult>> ToListAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -43,7 +43,7 @@ static async ValueTask<List<TResult>> ToListAsync<TEnumerable, TEnumerator, TSou
             => (await source.ToArrayAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(cancellationToken, selector).ConfigureAwait(false)).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<List<TResult>> ToListAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -52,7 +52,7 @@ static async ValueTask<List<TResult>> ToListAtAsync<TEnumerable, TEnumerator, TS
             => (await source.ToArrayAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(cancellationToken, selector).ConfigureAwait(false)).AsList();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<List<TResult>> ToListAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ReadOnlyList.cs
similarity index 95%
rename from NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ReadOnlyList.cs
index 9a77a2622..371ffb7d7 100644
--- a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ReadOnlyList.cs
@@ -8,7 +8,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ReadOnlyListExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> ElementAt<TList, TSource>(this TList source, int index) 
             where TList : struct, IReadOnlyList<TSource>
@@ -17,7 +17,7 @@ static Option<TSource> ElementAt<TList, TSource>(this TList source, int index)
                 : Option.Some(source[index]);
 
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Option<TResult> ElementAt<TList, TSource, TResult, TSelector>(this TList source, int index, TSelector selector) 
             where TList : struct, IReadOnlyList<TSource>
@@ -27,7 +27,7 @@ internal static Option<TResult> ElementAt<TList, TSource, TResult, TSelector>(th
                 : Option.Some(selector.Invoke(source[index]));
 
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Option<TResult> ElementAtAt<TList, TSource, TResult, TSelector>(this TList source, int index, TSelector selector) 
             where TList : struct, IReadOnlyList<TSource>
diff --git a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ReadOnlySpan.cs
similarity index 95%
rename from NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ReadOnlySpan.cs
index 60e1dad20..a452d86e8 100644
--- a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ReadOnlySpan.cs
@@ -13,7 +13,7 @@ static Option<TSource> ElementAt<TSource>(this ReadOnlySpan<TSource> source, int
                 : Option.Some(source[index]);
 
         
-        [GeneratorIgnore]
+
         static Option<TSource> ElementAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, int index, TPredicate predicate) 
             where TPredicate : struct, IFunction<TSource, bool>
         {
@@ -29,7 +29,7 @@ static Option<TSource> ElementAt<TSource, TPredicate>(this ReadOnlySpan<TSource>
         }
 
         
-        [GeneratorIgnore]
+
         static Option<TSource> ElementAtAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, int index, TPredicate predicate) 
             where TPredicate : struct, IFunction<TSource, int, bool>
         {
@@ -46,7 +46,7 @@ static Option<TSource> ElementAtAt<TSource, TPredicate>(this ReadOnlySpan<TSourc
         }
 
         
-        [GeneratorIgnore]
+
         static Option<TResult> ElementAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, int index, TSelector selector) 
             where TSelector : struct, IFunction<TSource, TResult>
             => index < 0 || index >= source.Length 
@@ -54,7 +54,7 @@ static Option<TResult> ElementAt<TSource, TResult, TSelector>(this ReadOnlySpan<
                 : Option.Some(selector.Invoke(source[index]));
 
         
-        [GeneratorIgnore]
+
         static Option<TResult> ElementAtAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, int index, TSelector selector) 
             where TSelector : struct, IFunction<TSource, int, TResult>
             => index < 0 || index >= source.Length 
@@ -62,7 +62,7 @@ static Option<TResult> ElementAtAt<TSource, TResult, TSelector>(this ReadOnlySpa
                 : Option.Some(selector.Invoke(source[index], index));
 
         
-        [GeneratorIgnore]
+
         static Option<TResult> ElementAt<TSource, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, int index, TPredicate predicate, TSelector selector) 
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueEnumerable.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueEnumerable.cs
index 914a38426..c79dfe2c5 100644
--- a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueEnumerable.cs
@@ -23,7 +23,7 @@ public static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource>(this
         }
 
         
-        [GeneratorIgnore]
+
         internal static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, int index, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -42,7 +42,7 @@ internal static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource, TPr
         }
 
         
-        [GeneratorIgnore]
+
         internal static Option<TSource> ElementAtAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, int index, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -64,7 +64,7 @@ internal static Option<TSource> ElementAtAt<TEnumerable, TEnumerator, TSource, T
         }
 
         
-        [GeneratorIgnore]
+
         internal static Option<TResult> ElementAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, int index, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -84,7 +84,7 @@ internal static Option<TResult> ElementAt<TEnumerable, TEnumerator, TSource, TRe
         }
 
         
-        [GeneratorIgnore]
+
         internal static Option<TResult> ElementAtAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, int index, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -106,7 +106,7 @@ internal static Option<TResult> ElementAtAt<TEnumerable, TEnumerator, TSource, T
         }
 
         
-        [GeneratorIgnore]
+
         internal static Option<TResult> ElementAt<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, int index, TPredicate predicate, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueReadOnlyCollection.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueReadOnlyCollection.cs
index 68cac0e57..80eb7020b 100644
--- a/NetFabric.Hyperlinq/Element/ElementAt/ElementAt.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueReadOnlyCollection.cs
@@ -18,7 +18,7 @@ public static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource>(this
                     : Option.None
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, int index, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -30,7 +30,7 @@ static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource, TPredicate>(
                 _ => ValueEnumerableExtensions.ElementAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, index, predicate)
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> ElementAtAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, int index, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -42,7 +42,7 @@ static Option<TSource> ElementAtAt<TEnumerable, TEnumerator, TSource, TPredicate
                 _ => ValueEnumerableExtensions.ElementAtAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, index, predicate)
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> ElementAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, int index, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -57,7 +57,7 @@ static Option<TResult> ElementAt<TEnumerable, TEnumerator, TSource, TResult, TSe
             };
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> ElementAtAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, int index, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -71,7 +71,7 @@ static Option<TResult> ElementAtAt<TEnumerable, TEnumerator, TSource, TResult, T
                     : Option.None
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> ElementAt<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, int index, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueReadOnlyList.cs
new file mode 100644
index 000000000..736663171
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAt.ValueReadOnlyList.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Option<TSource> ElementAt<TEnumerable, TEnumerator, TSource>(this TEnumerable source, int index)
+            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => source switch
+            {
+                {Count: 0} => Option.None,
+                _ => index < source.Count
+                    ? ValueEnumerableExtensions.ElementAt<TEnumerable, TEnumerator, TSource>(source, index)
+                    : Option.None
+            };
+    }
+}
diff --git a/NetFabric.Hyperlinq/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.cs
index c9c3f5aca..c073a15ea 100644
--- a/NetFabric.Hyperlinq/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Element/ElementAt/ElementAtAsync.AsyncValueEnumerable.cs
@@ -35,7 +35,7 @@ static async ValueTask<Option<TSource>> ExecuteAsync(TEnumerable source, int ind
         }
 
         
-        [GeneratorIgnore]
+
         static ValueTask<Option<TSource>> ElementAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, int index, CancellationToken cancellationToken, TPredicate predicate) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -65,7 +65,7 @@ static async ValueTask<Option<TSource>> ExecuteAsync(TEnumerable source, int ind
         }
 
         
-        [GeneratorIgnore]
+
         static ValueTask<Option<TSource>> ElementAtAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, int index, CancellationToken cancellationToken, TPredicate predicate) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -98,7 +98,7 @@ static async ValueTask<Option<TSource>> ExecuteAsync(TEnumerable source, int ind
         }
 
         
-        [GeneratorIgnore]
+
         static ValueTask<Option<TResult>> ElementAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, int index, CancellationToken cancellationToken, TSelector selector) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -128,7 +128,7 @@ static async ValueTask<Option<TResult>> ExecuteAsync(TEnumerable source, int ind
         }
 
         
-        [GeneratorIgnore]
+
         static ValueTask<Option<TResult>> ElementAtAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, int index, CancellationToken cancellationToken, TSelector selector) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -161,7 +161,7 @@ static async ValueTask<Option<TResult>> ExecuteAsync(TEnumerable source, int ind
         }
 
         
-        [GeneratorIgnore]
+
         static ValueTask<Option<TResult>> ElementAtAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, int index, CancellationToken cancellationToken, TPredicate predicate, TSelector selector) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Element/First/First.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Element/First/First.ReadOnlyList.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Element/First/First.ReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Element/First/First.ReadOnlyList.cs
index 7b9af035e..d2aa13217 100644
--- a/NetFabric.Hyperlinq/Element/First/First.ReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Element/First/First.ReadOnlyList.cs
@@ -7,7 +7,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ReadOnlyListExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> First<TList, TSource>(this TList source) 
             where TList : struct, IReadOnlyList<TSource>
@@ -17,7 +17,7 @@ static Option<TSource> First<TList, TSource>(this TList source)
                 _ => Option.Some(source[0])
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Option<TResult> First<TList, TSource, TResult, TSelector>(this TList source, TSelector selector)
             where TList : struct, IReadOnlyList<TSource>
@@ -29,7 +29,7 @@ internal static Option<TResult> First<TList, TSource, TResult, TSelector>(this T
             };
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Option<TResult> FirstAt<TList, TSource, TResult, TSelector>(this TList source, TSelector selector)
             where TList : struct, IReadOnlyList<TSource>
diff --git a/NetFabric.Hyperlinq/Element/First/First.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Element/First/First.ReadOnlySpan.cs
similarity index 95%
rename from NetFabric.Hyperlinq/Element/First/First.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Element/First/First.ReadOnlySpan.cs
index 2e34346c1..830e8f082 100644
--- a/NetFabric.Hyperlinq/Element/First/First.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Element/First/First.ReadOnlySpan.cs
@@ -14,7 +14,7 @@ static Option<TSource> First<TSource>(this ReadOnlySpan<TSource> source)
                 _ => Option.Some(source[0])
             };
 
-        [GeneratorIgnore]
+
         static Option<TSource> First<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, bool>
         {
@@ -28,7 +28,7 @@ static Option<TSource> First<TSource, TPredicate>(this ReadOnlySpan<TSource> sou
         }
 
 
-        [GeneratorIgnore]
+
         static Option<TSource> FirstAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, int, bool>
         {
@@ -42,7 +42,7 @@ static Option<TSource> FirstAt<TSource, TPredicate>(this ReadOnlySpan<TSource> s
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> First<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
@@ -53,7 +53,7 @@ static Option<TResult> First<TSource, TResult, TSelector>(this ReadOnlySpan<TSou
             };
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> FirstAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
@@ -64,7 +64,7 @@ static Option<TResult> FirstAt<TSource, TResult, TSelector>(this ReadOnlySpan<TS
             };
 
 
-        [GeneratorIgnore]
+
         static Option<TResult> First<TSource, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TPredicate predicate, TSelector selector)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Element/First/First.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Element/First/First.ValueEnumerable.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Element/First/First.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Element/First/First.ValueEnumerable.cs
index 50251b11b..95379dea5 100644
--- a/NetFabric.Hyperlinq/Element/First/First.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Element/First/First.ValueEnumerable.cs
@@ -18,7 +18,7 @@ public static Option<TSource> First<TEnumerable, TEnumerator, TSource>(this TEnu
         }
 
 
-        [GeneratorIgnore]
+
         internal static Option<TSource> First<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -36,7 +36,7 @@ internal static Option<TSource> First<TEnumerable, TEnumerator, TSource, TPredic
         }
 
 
-        [GeneratorIgnore]
+
         internal static Option<TSource> FirstAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -56,7 +56,7 @@ internal static Option<TSource> FirstAt<TEnumerable, TEnumerator, TSource, TPred
         }
 
 
-        [GeneratorIgnore]
+
         internal static Option<TResult> First<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -71,7 +71,7 @@ internal static Option<TResult> First<TEnumerable, TEnumerator, TSource, TResult
         }
 
 
-        [GeneratorIgnore]
+
         internal static Option<TResult> FirstAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -86,7 +86,7 @@ internal static Option<TResult> FirstAt<TEnumerable, TEnumerator, TSource, TResu
         }
 
 
-        [GeneratorIgnore]
+
         internal static Option<TResult> First<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Element/First/First.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Element/First/First.ValueReadOnlyCollection.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Element/First/First.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Element/First/First.ValueReadOnlyCollection.cs
index 2f01ff17e..dcdd30bba 100644
--- a/NetFabric.Hyperlinq/Element/First/First.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Element/First/First.ValueReadOnlyCollection.cs
@@ -20,12 +20,12 @@ public static Option<TSource> First<TEnumerable, TEnumerator, TSource>(this TEnu
             static Option<TSource> GetFirst(TEnumerable source)
             {
                 using var enumerator = source.GetEnumerator();
-                enumerator.MoveNext();
+                _ = enumerator.MoveNext();
                 return Option.Some(enumerator.Current);
             }
         }
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> First<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -37,7 +37,7 @@ static Option<TSource> First<TEnumerable, TEnumerator, TSource, TPredicate>(this
                 _ => ValueEnumerableExtensions.First<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate)
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> FirstAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -49,7 +49,7 @@ static Option<TSource> FirstAt<TEnumerable, TEnumerator, TSource, TPredicate>(th
                 _ => ValueEnumerableExtensions.FirstAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate)
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> First<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -65,13 +65,13 @@ static Option<TResult> First<TEnumerable, TEnumerator, TSource, TResult, TSelect
             static Option<TResult> GetFirst(TEnumerable source, TSelector selector)
             {
                 using var enumerator = source.GetEnumerator();
-                enumerator.MoveNext();
+                _ = enumerator.MoveNext();
                 return Option.Some(selector.Invoke(enumerator.Current));
             }
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> FirstAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -87,13 +87,13 @@ static Option<TResult> FirstAt<TEnumerable, TEnumerator, TSource, TResult, TSele
             static Option<TResult> GetFirst(TEnumerable source, TSelector selector)
             {
                 using var enumerator = source.GetEnumerator();
-                enumerator.MoveNext();
+                _ = enumerator.MoveNext();
                 return Option.Some(selector.Invoke(enumerator.Current, 0));
             }
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> First<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq.Core/Element/First/First.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Element/First/First.ValueReadOnlyList.cs
new file mode 100644
index 000000000..19488681e
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Element/First/First.ValueReadOnlyList.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Option<TSource> First<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.First<TEnumerable, TEnumerator, TSource>(source);
+    }
+}
diff --git a/NetFabric.Hyperlinq/Element/First/FirstAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Element/First/FirstAsync.AsyncValueEnumerable.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Element/First/FirstAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Element/First/FirstAsync.AsyncValueEnumerable.cs
index 4ac0040c0..2216e721e 100644
--- a/NetFabric.Hyperlinq/Element/First/FirstAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Element/First/FirstAsync.AsyncValueEnumerable.cs
@@ -28,7 +28,7 @@ public static async ValueTask<Option<TSource>> FirstAsync<TEnumerable, TEnumerat
         }
 
 
-        [GeneratorIgnore]
+
         static async ValueTask<Option<TSource>> FirstAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -52,7 +52,7 @@ static async ValueTask<Option<TSource>> FirstAsync<TEnumerable, TEnumerator, TSo
         }
 
 
-        [GeneratorIgnore]
+
         static async ValueTask<Option<TSource>> FirstAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -79,7 +79,7 @@ static async ValueTask<Option<TSource>> FirstAtAsync<TEnumerable, TEnumerator, T
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Option<TResult>> FirstAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -102,7 +102,7 @@ static async ValueTask<Option<TResult>> FirstAsync<TEnumerable, TEnumerator, TSo
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Option<TResult>> FirstAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -125,7 +125,7 @@ static async ValueTask<Option<TResult>> FirstAtAsync<TEnumerable, TEnumerator, T
         }
 
 
-        [GeneratorIgnore]
+
         static async ValueTask<Option<TResult>> FirstAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate, TSelector selector) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Element/Single/Single.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Element/Single/Single.ReadOnlyList.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Element/Single/Single.ReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Element/Single/Single.ReadOnlyList.cs
index b121eaf53..45d81b242 100644
--- a/NetFabric.Hyperlinq/Element/Single/Single.ReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Element/Single/Single.ReadOnlyList.cs
@@ -6,7 +6,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ReadOnlyListExtensions
     {
 
-        [GeneratorIgnore]
+
         static Option<TSource> Single<TList, TSource>(this TList source) 
             where TList : struct, IReadOnlyList<TSource>
             => source switch
@@ -15,7 +15,7 @@ static Option<TSource> Single<TList, TSource>(this TList source)
                 _ => Option.None,
             };
         
-        [GeneratorIgnore]
+
         internal static Option<TResult> Single<TList, TSource, TResult, TSelector>(this TList source, TSelector selector)
             where TList : struct, IReadOnlyList<TSource>
             where TSelector : struct, IFunction<TSource, TResult>
@@ -26,7 +26,7 @@ internal static Option<TResult> Single<TList, TSource, TResult, TSelector>(this
             };
 
         
-        [GeneratorIgnore]
+
         internal static Option<TResult> SingleAt<TList, TSource, TResult, TSelector>(this TList source, TSelector selector)
             where TList : struct, IReadOnlyList<TSource>
             where TSelector : struct, IFunction<TSource, int, TResult>
diff --git a/NetFabric.Hyperlinq/Element/Single/Single.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Element/Single/Single.ReadOnlySpan.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Element/Single/Single.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Element/Single/Single.ReadOnlySpan.cs
index 56f05ceee..4042a258f 100644
--- a/NetFabric.Hyperlinq/Element/Single/Single.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Element/Single/Single.ReadOnlySpan.cs
@@ -12,7 +12,6 @@ static Option<TSource> Single<TSource>(this ReadOnlySpan<TSource> source)
                 _ => Option.None,
             };
 
-        [GeneratorIgnore]
         static Option<TSource> Single<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, bool>
         {
@@ -35,7 +34,6 @@ static Option<TSource> Single<TSource, TPredicate>(this ReadOnlySpan<TSource> so
         }
 
 
-        [GeneratorIgnore]
         static Option<TSource> SingleAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
             where TPredicate : struct, IFunction<TSource, int, bool>
         {
@@ -58,7 +56,6 @@ static Option<TSource> SingleAt<TSource, TPredicate>(this ReadOnlySpan<TSource>
         }
 
 
-        [GeneratorIgnore]
         static Option<TResult> Single<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
             => source switch
@@ -68,7 +65,6 @@ static Option<TResult> Single<TSource, TResult, TSelector>(this ReadOnlySpan<TSo
             };
 
 
-        [GeneratorIgnore]
         static Option<TResult> SingleAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
             => source switch
@@ -78,7 +74,7 @@ static Option<TResult> SingleAt<TSource, TResult, TSelector>(this ReadOnlySpan<T
             };
 
 
-        [GeneratorIgnore]
+
         static Option<TResult> Single<TSource, TResult, TPredicate, TSelector>(this ReadOnlySpan<TSource> source, TPredicate predicate, TSelector selector)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Element/Single/Single.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueEnumerable.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Element/Single/Single.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Element/Single/Single.ValueEnumerable.cs
index 9ab5eeb54..ae7ac435c 100644
--- a/NetFabric.Hyperlinq/Element/Single/Single.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueEnumerable.cs
@@ -13,7 +13,7 @@ public static Option<TSource> Single<TEnumerable, TEnumerator, TSource>(this TEn
             => source.GetSingle<TEnumerable, TEnumerator, TSource>();
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Option<TSource> Single<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -22,7 +22,7 @@ internal static Option<TSource> Single<TEnumerable, TEnumerator, TSource, TPredi
             => source.GetSingle<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Option<TSource> SingleAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -31,7 +31,7 @@ internal static Option<TSource> SingleAt<TEnumerable, TEnumerator, TSource, TPre
             => source.GetSingleAt<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
 
-        [GeneratorIgnore]
+
         static Option<TResult> Single<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -41,7 +41,7 @@ static Option<TResult> Single<TEnumerable, TEnumerator, TSource, TResult, TSelec
                 .Select<TResult, TSelector>(selector);
 
 
-        [GeneratorIgnore]
+
         static Option<TResult> SingleAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -63,7 +63,7 @@ public TResult Invoke(TSource item)
                 => selector.Invoke(item, 0);
         }
 
-        [GeneratorIgnore]
+
         internal static Option<TResult> Single<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -75,7 +75,7 @@ internal static Option<TResult> Single<TEnumerable, TEnumerator, TSource, TResul
         // GetSingle 
 
 
-        [GeneratorIgnore]
+
         static Option<TSource> GetSingle<TEnumerable, TEnumerator, TSource>(this TEnumerable source) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -93,7 +93,7 @@ static Option<TSource> GetSingle<TEnumerable, TEnumerator, TSource>(this TEnumer
         }
 
 
-        [GeneratorIgnore]
+
         static Option<TSource> GetSingle<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -120,7 +120,7 @@ static Option<TSource> GetSingle<TEnumerable, TEnumerator, TSource, TPredicate>(
         }
 
 
-        [GeneratorIgnore]
+
         static Option<TSource> GetSingleAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate) 
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Element/Single/Single.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueReadOnlyCollection.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Element/Single/Single.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Element/Single/Single.ValueReadOnlyCollection.cs
index e0a00e1ce..899a89bd4 100644
--- a/NetFabric.Hyperlinq/Element/Single/Single.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueReadOnlyCollection.cs
@@ -25,7 +25,7 @@ static Option<TSource> GetSingle(TEnumerable source)
             }
         }
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> Single<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -37,7 +37,7 @@ static Option<TSource> Single<TEnumerable, TEnumerator, TSource, TPredicate>(thi
                 _ => ValueEnumerableExtensions.Single<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate)
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TSource> SingleAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -49,7 +49,7 @@ static Option<TSource> SingleAt<TEnumerable, TEnumerator, TSource, TPredicate>(t
                 _ => ValueEnumerableExtensions.SingleAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate)
             };
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> Single<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -70,7 +70,7 @@ static Option<TResult> GetSingle(TEnumerable source, TSelector selector)
             }
         }
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> SingleAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector) 
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -92,7 +92,7 @@ static Option<TResult> GetSingle(TEnumerable source, TSelector selector)
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static Option<TResult> Single<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueReadOnlyList.cs
new file mode 100644
index 000000000..49e6dd264
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Element/Single/Single.ValueReadOnlyList.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Option<TSource> Single<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Single<TEnumerable, TEnumerator, TSource>(source);
+    }
+}
diff --git a/NetFabric.Hyperlinq/Element/Single/SingleAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Element/Single/SingleAsync.AsyncValueEnumerable.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Element/Single/SingleAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Element/Single/SingleAsync.AsyncValueEnumerable.cs
index 436690e85..1b46d236d 100644
--- a/NetFabric.Hyperlinq/Element/Single/SingleAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Element/Single/SingleAsync.AsyncValueEnumerable.cs
@@ -15,7 +15,7 @@ public static ValueTask<Option<TSource>> SingleAsync<TEnumerable, TEnumerator, T
             => source.GetSingleAsync<TEnumerable, TEnumerator, TSource>(cancellationToken);
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ValueTask<Option<TSource>> SingleAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate = default) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -24,7 +24,7 @@ static ValueTask<Option<TSource>> SingleAsync<TEnumerable, TEnumerator, TSource,
             => source.GetSingleAsync<TEnumerable, TEnumerator, TSource, TPredicate>(cancellationToken, predicate);
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ValueTask<Option<TSource>> SingleAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate = default) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -33,7 +33,7 @@ static ValueTask<Option<TSource>> SingleAtAsync<TEnumerable, TEnumerator, TSourc
             => source.GetSingleAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(cancellationToken, predicate);
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Option<TResult>> SingleAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector = default) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -45,7 +45,7 @@ static async ValueTask<Option<TResult>> SingleAsync<TEnumerable, TEnumerator, TS
         }
 
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Option<TResult>> SingleAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TSelector selector = default) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -69,7 +69,7 @@ public ValueTask<TResult> InvokeAsync(TSource item, CancellationToken cancellati
                 => selector.InvokeAsync(item, 0, cancellationToken);
         }
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static async ValueTask<Option<TResult>> SingleAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate, TSelector selector = default) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -85,7 +85,7 @@ static async ValueTask<Option<TResult>> SingleAsync<TEnumerable, TEnumerator, TS
         // GetSingleAsync
 
 
-        [GeneratorIgnore]
+
         static async ValueTask<Option<TSource>> GetSingleAsync<TEnumerable, TEnumerator, TSource>(this TEnumerable source, CancellationToken cancellationToken) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -109,7 +109,6 @@ static async ValueTask<Option<TSource>> GetSingleAsync<TEnumerable, TEnumerator,
             }
         }
 
-        [GeneratorIgnore]
         static async ValueTask<Option<TSource>> GetSingleAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -144,7 +143,7 @@ static async ValueTask<Option<TSource>> GetSingleAsync<TEnumerable, TEnumerator,
         }
 
 
-        [GeneratorIgnore]
+
         static async ValueTask<Option<TSource>> GetSingleAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate) 
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Equality/SequenceEqual/SequenceEqual.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Equality/SequenceEqual/SequenceEqual.ReadOnlySpan.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Equality/SequenceEqual/SequenceEqual.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Equality/SequenceEqual/SequenceEqual.ReadOnlySpan.cs
index a8ff05a86..6b6a86359 100644
--- a/NetFabric.Hyperlinq/Equality/SequenceEqual/SequenceEqual.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Equality/SequenceEqual/SequenceEqual.ReadOnlySpan.cs
@@ -5,7 +5,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorIgnore]
+
         static bool SequenceEqual<TEnumerable, TEnumerator, TSource>(this ReadOnlySpan<TSource> first, TEnumerable second, IEqualityComparer<TSource>? comparer = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ArraySegment.cs
similarity index 81%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/Where.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ArraySegment.cs
index e1443b60a..15df2b3f2 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ArraySegment.cs
@@ -10,7 +10,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ArraySegmentWhereEnumerable<TSource, FunctionWrapper<TSource, bool>> Where<TSource>(this in ArraySegment<TSource> source, Func<TSource, bool> predicate)
             => source.Where(new FunctionWrapper<TSource, bool>(predicate));
@@ -101,7 +101,7 @@ public readonly void Dispose() { }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Count(predicate);
+                => source.AsReadOnlySpan().Count(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count(Func<TSource, bool> predicate)
@@ -110,7 +110,7 @@ public int Count(Func<TSource, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Count(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().Count(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count(Func<TSource, int, bool> predicate)
@@ -119,14 +119,14 @@ public int Count(Func<TSource, int, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).CountAt(new PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().CountAt(new PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
             
             #endregion
             #region Quantifier
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).All(predicate);
+                => source.AsReadOnlySpan().All(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All(Func<TSource, bool> predicate)
@@ -135,7 +135,7 @@ public bool All(Func<TSource, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).All(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().All(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All(Func<TSource, int, bool> predicate)
@@ -144,11 +144,11 @@ public bool All(Func<TSource, int, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AllAt(new PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().AllAt(new PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Any(predicate);
+                => source.AsReadOnlySpan().Any(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any(Func<TSource, bool> predicate)
@@ -157,7 +157,7 @@ public bool Any(Func<TSource, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Any(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().Any(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any(Func<TSource, int, bool> predicate)
@@ -166,7 +166,7 @@ public bool Any(Func<TSource, int, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AnyAt(new PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().AnyAt(new PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             #endregion
             #region Filtering
@@ -206,16 +206,16 @@ public ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TSource> ElementAt(int index)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ElementAt(index, predicate);
+                => source.AsReadOnlySpan().ElementAt(index, predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TSource> First()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).First(predicate);
+                => source.AsReadOnlySpan().First(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TSource> Single()
 #pragma warning disable HLQ005 // Avoid Single() and SingleOrDefault()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Single(predicate);
+                => source.AsReadOnlySpan().Single(predicate);
 #pragma warning restore HLQ005 // Avoid Single() and SingleOrDefault()
             
             #endregion
@@ -223,7 +223,7 @@ public Option<TSource> Single()
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public TSource[] ToArray()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToArray(predicate);
+                => source.AsReadOnlySpan().ToArray(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
@@ -231,7 +231,7 @@ public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = def
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public List<TSource> ToList()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToList(predicate);
+                => source.AsReadOnlySpan().ToList(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
@@ -242,7 +242,7 @@ public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelec
             public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary(keySelector, comparer, predicate);
+                => source.AsReadOnlySpan().ToDictionary(keySelector, comparer, predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
@@ -254,7 +254,7 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
                 where TElementSelector : struct, IFunction<TSource, TElement>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(keySelector, elementSelector, comparer, predicate);
+                => source.AsReadOnlySpan().ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(keySelector, elementSelector, comparer, predicate);
             
             #endregion
         }
@@ -262,72 +262,72 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TPredicate>(this ArraySegmentWhereEnumerable<int, TPredicate> source)
             where TPredicate : struct, IFunction<int, bool>
-            => ((ReadOnlySpan<int>)source.source.AsSpan()).Sum<int, int, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<int, int, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TPredicate>(this ArraySegmentWhereEnumerable<int?, TPredicate> source)
             where TPredicate : struct, IFunction<int?, bool>
-            => ((ReadOnlySpan<int?>)source.source.AsSpan()).Sum<int?, int, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<int?, int, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TPredicate>(this ArraySegmentWhereEnumerable<nint, TPredicate> source)
             where TPredicate : struct, IFunction<nint, bool>
-            => ((ReadOnlySpan<nint>)source.source.AsSpan()).Sum<nint, nint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<nint, nint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TPredicate>(this ArraySegmentWhereEnumerable<nint?, TPredicate> source)
             where TPredicate : struct, IFunction<nint?, bool>
-            => ((ReadOnlySpan<nint?>)source.source.AsSpan()).Sum<nint?, nint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<nint?, nint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TPredicate>(this ArraySegmentWhereEnumerable<nuint, TPredicate> source)
             where TPredicate : struct, IFunction<nuint, bool>
-            => ((ReadOnlySpan<nuint>)source.source.AsSpan()).Sum<nuint, nuint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<nuint, nuint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TPredicate>(this ArraySegmentWhereEnumerable<nuint?, TPredicate> source)
             where TPredicate : struct, IFunction<nuint?, bool>
-            => ((ReadOnlySpan<nuint?>)source.source.AsSpan()).Sum<nuint?, nuint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<nuint?, nuint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TPredicate>(this ArraySegmentWhereEnumerable<long, TPredicate> source)
             where TPredicate : struct, IFunction<long, bool>
-            => ((ReadOnlySpan<long>)source.source.AsSpan()).Sum<long, long, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<long, long, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TPredicate>(this ArraySegmentWhereEnumerable<long?, TPredicate> source)
             where TPredicate : struct, IFunction<long?, bool>
-            => ((ReadOnlySpan<long?>)source.source.AsSpan()).Sum<long?, long, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<long?, long, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TPredicate>(this ArraySegmentWhereEnumerable<float, TPredicate> source)
             where TPredicate : struct, IFunction<float, bool>
-            => ((ReadOnlySpan<float>)source.source.AsSpan()).Sum<float, float, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<float, float, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TPredicate>(this ArraySegmentWhereEnumerable<float?, TPredicate> source)
             where TPredicate : struct, IFunction<float?, bool>
-            => ((ReadOnlySpan<float?>)source.source.AsSpan()).Sum<float?, float, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<float?, float, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TPredicate>(this ArraySegmentWhereEnumerable<double, TPredicate> source)
             where TPredicate : struct, IFunction<double, bool>
-            => ((ReadOnlySpan<double>)source.source.AsSpan()).Sum<double, double, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<double, double, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TPredicate>(this ArraySegmentWhereEnumerable<double?, TPredicate> source)
             where TPredicate : struct, IFunction<double?, bool>
-            => ((ReadOnlySpan<double?>)source.source.AsSpan()).Sum<double?, double, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<double?, double, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TPredicate>(this ArraySegmentWhereEnumerable<decimal, TPredicate> source)
             where TPredicate : struct, IFunction<decimal, bool>
-            => ((ReadOnlySpan<decimal>)source.source.AsSpan()).Sum<decimal, decimal, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<decimal, decimal, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TPredicate>(this ArraySegmentWhereEnumerable<decimal?, TPredicate> source)
             where TPredicate : struct, IFunction<decimal?, bool>
-            => ((ReadOnlySpan<decimal?>)source.source.AsSpan()).Sum<decimal?, decimal, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().Sum<decimal?, decimal, TPredicate>(source.predicate);
     }
 }
 
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.AsyncValueEnumerable.cs
similarity index 84%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/Where.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.AsyncValueEnumerable.cs
index 622f4eeca..62c36eeaf 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.AsyncValueEnumerable.cs
@@ -12,13 +12,6 @@ namespace NetFabric.Hyperlinq
     public static partial class AsyncValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.AsyncFunctionWrapper<TSource, bool>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static WhereEnumerable<TEnumerable, TEnumerator, TSource, AsyncFunctionWrapper<TSource, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            => source.Where<TEnumerable, TEnumerator, TSource, AsyncFunctionWrapper<TSource, bool>>(new AsyncFunctionWrapper<TSource, bool>(predicate));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> Where<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -206,19 +199,11 @@ readonly void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine
             public ValueTask<int> CountAsync(CancellationToken cancellationToken = default)
                 => source.CountAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<int> CountAsync(Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => CountAsync(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<int> CountAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.CountAsync<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate), cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<int> CountAsync(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => CountAtAsync(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<int> CountAtAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, int, bool>
@@ -231,19 +216,11 @@ public ValueTask<int> CountAtAsync<TPredicate2>(TPredicate2 predicate = default,
             public ValueTask<bool> AllAsync(CancellationToken cancellationToken = default)
                 => source.AllAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AllAsync(Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AllAsync(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AllAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.AllAsync<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate), cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AllAsync(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AllAtAsync(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AllAtAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, int, bool>
@@ -253,19 +230,11 @@ public ValueTask<bool> AllAtAsync<TPredicate2>(TPredicate2 predicate = default,
             public ValueTask<bool> AnyAsync(CancellationToken cancellationToken = default)
                 => source.AnyAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AnyAsync(Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AnyAsync(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AnyAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.AnyAsync<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate), cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AnyAsync(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AnyAtAsync(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AnyAtAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, int, bool>
@@ -274,10 +243,6 @@ public ValueTask<bool> AnyAtAsync<TPredicate2>(TPredicate2 predicate = default,
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, AsyncFunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, CancellationToken, ValueTask<TResult>> selector)
-                => Select<TResult, AsyncFunctionWrapper<TSource, TResult>>(new AsyncFunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> Select<TResult, TSelector>(TSelector selector = default)
                 where TSelector : struct, IAsyncFunction<TSource, TResult>
@@ -286,18 +251,10 @@ public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredic
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateCombination<TPredicate, AsyncFunctionWrapper<TSource, bool>, TSource>> Where(Func<TSource, CancellationToken, ValueTask<bool>> predicate)
-                => Where(new AsyncFunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.Where<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new AsyncPredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate, AsyncFunctionWrapper<TSource, int, bool>, TSource>> Where(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
-                => WhereAt(new AsyncFunctionWrapper<TSource, int, bool>(predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>> WhereAt<TPredicate2>(TPredicate2 predicate = default)
@@ -335,11 +292,6 @@ public ValueTask<Lease<TSource>> ToArrayAsync(ArrayPool<TSource> pool, Cancellat
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken = default)
                 => source.ToListAsync<TEnumerable, TEnumerator, TSource, TPredicate>(cancellationToken, predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey>(Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
-                where TKey : notnull
-                => ToDictionaryAsync(new AsyncFunctionWrapper<TSource, TKey>(keySelector), comparer, cancellationToken);
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
@@ -347,11 +299,6 @@ public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey, TKeySelector
                 where TKeySelector : struct, IAsyncFunction<TSource, TKey>
                 => source.ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(keySelector, comparer, cancellationToken, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement>(Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
-                where TKey : notnull
-                => ToDictionaryAsync<TKey, TElement, AsyncFunctionWrapper<TSource, TKey>, AsyncFunctionWrapper<TSource, TElement>>(new AsyncFunctionWrapper<TSource, TKey>(keySelector), new AsyncFunctionWrapper<TSource, TElement>(elementSelector), comparer, cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ReadOnlyMemory.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ReadOnlyMemory.cs
index b6242cfcf..bc3a4da78 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ReadOnlyMemory.cs
@@ -10,7 +10,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static MemoryWhereEnumerable<TSource, FunctionWrapper<TSource, bool>> Where<TSource>(this ReadOnlyMemory<TSource> source, Func<TSource, bool> predicate) 
             => source.Where(new FunctionWrapper<TSource, bool>(predicate));
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ReadOnlySpan.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ReadOnlySpan.cs
index b587ab670..2f3334d28 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ReadOnlySpan.cs
@@ -9,7 +9,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanWhereEnumerable<TSource, FunctionWrapper<TSource, bool>> Where<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, bool> predicate) 
             => source.Where(new FunctionWrapper<TSource, bool>(predicate));
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueEnumerable.cs
similarity index 83%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/Where.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueEnumerable.cs
index 42f503c9e..a7ce272bd 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueEnumerable.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static WhereEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Where<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> Where<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -103,19 +96,11 @@ public void Dispose()
             public int Count()
                 => source.Count<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, bool> predicate)
-                => Count(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.Count<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, int, bool> predicate)
-                => CountAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -142,22 +127,12 @@ public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = def
             public List<TSource> ToList()
                 => source.ToList<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
                 => source.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(keySelector, comparer, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary<TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
@@ -172,19 +147,11 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
             public bool All()
                 => source.All<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, bool> predicate)
-                => All(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.All<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -194,19 +161,11 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
             public bool Any()
                 => source.Any<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, bool> predicate)
-                => Any(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.Any<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -215,19 +174,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, FunctionWrapper<TSource, bool>, TSource>> Where(Func<TSource, bool> predicate)
-                => Where(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.Where<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate, FunctionWrapper<TSource, int, bool>, TSource>> Where(Func<TSource, int, bool> predicate)
-                => WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -236,10 +187,6 @@ public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAt
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, FunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, TResult> selector)
-                => Select<TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> Select<TResult, TSelector>(TSelector selector = default)
                 where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueReadOnlyCollection.cs
similarity index 83%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/Where.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueReadOnlyCollection.cs
index a0ec54406..6e4022ee0 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueReadOnlyCollection.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyCollectionExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static WhereEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => Where<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(source, new FunctionWrapper<TSource, bool>(predicate));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> Where<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -102,19 +95,11 @@ public void Dispose()
             public int Count()
                 => ValueReadOnlyCollectionExtensions.Count<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, bool> predicate)
-                => Count(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.Count<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(source, new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, int, bool> predicate)
-                => CountAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -127,19 +112,11 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
             public bool All()
                 => ValueReadOnlyCollectionExtensions.All<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, bool> predicate)
-                => All(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.All<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(source, new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -149,19 +126,11 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
             public bool Any()
                 => ValueReadOnlyCollectionExtensions.Any<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, bool> predicate)
-                => Any(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.Any<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(source, new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -170,19 +139,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, FunctionWrapper<TSource, bool>, TSource>> Where(Func<TSource, bool> predicate)
-                => Where(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.Where<TEnumerable, TEnumerator, TSource, PredicatePredicateCombination<TPredicate, TPredicate2, TSource>>(source, new PredicatePredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate, FunctionWrapper<TSource, int, bool>, TSource>> Where(Func<TSource, int, bool> predicate)
-                => WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate, TPredicate2, TSource>> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -191,10 +152,6 @@ public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAt
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, FunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, TResult> selector)
-                => Select<TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> Select<TResult, TSelector>(TSelector selector = default)
                 where TSelector : struct, IFunction<TSource, TResult>
@@ -232,22 +189,12 @@ public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = def
             public List<TSource> ToList()
                 => ValueReadOnlyCollectionExtensions.ToList<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
                 => ValueReadOnlyCollectionExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(source, keySelector, comparer, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary<TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueReadOnlyList.cs
new file mode 100644
index 000000000..15759c6ba
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/Where.ValueReadOnlyList.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueReadOnlyCollectionExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> Where<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate : struct, IFunction<TSource, bool>
+            => ValueReadOnlyCollectionExtensions.Where<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/WhereEnumerator.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/Where/WhereEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Filtering/Where/Where/WhereEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/Where/WhereEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs
similarity index 80%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs
index 63db8ad6c..545773f06 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs
@@ -10,7 +10,6 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, bool>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ArraySegmentWhereAtEnumerable<TSource, FunctionWrapper<TSource, int, bool>> Where<TSource>(this in ArraySegment<TSource> source, Func<TSource, int, bool> predicate)
             => source.WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
@@ -107,7 +106,7 @@ public readonly void Dispose() { }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).CountAt(predicate);
+                => source.AsReadOnlySpan().CountAt(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count(Func<TSource, bool> predicate)
@@ -116,7 +115,7 @@ public int Count(Func<TSource, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).CountAt(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
+                => source.AsReadOnlySpan().CountAt(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count(Func<TSource, int, bool> predicate)
@@ -125,7 +124,7 @@ public int Count(Func<TSource, int, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).CountAt(new PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().CountAt(new PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             #endregion
             #region Quantifier
@@ -133,7 +132,7 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AllAt(predicate);
+                => source.AsReadOnlySpan().AllAt(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All(Func<TSource, bool> predicate)
@@ -142,7 +141,7 @@ public bool All(Func<TSource, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AllAt(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
+                => source.AsReadOnlySpan().AllAt(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All(Func<TSource, int, bool> predicate)
@@ -151,11 +150,11 @@ public bool All(Func<TSource, int, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AllAt(new PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().AllAt(new PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AnyAt(predicate);
+                => source.AsReadOnlySpan().AnyAt(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any(Func<TSource, bool> predicate)
@@ -164,7 +163,7 @@ public bool Any(Func<TSource, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AnyAt(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
+                => source.AsReadOnlySpan().AnyAt(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any(Func<TSource, int, bool> predicate)
@@ -173,7 +172,7 @@ public bool Any(Func<TSource, int, bool> predicate)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AnyAt(new PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
+                => source.AsReadOnlySpan().AnyAt(new PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
 
             #endregion
             #region Filtering
@@ -204,16 +203,16 @@ public ArraySegmentWhereAtEnumerable<TSource, PredicateAtPredicateAtCombination<
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TSource> ElementAt(int index)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ElementAtAt(index, predicate);
+                => source.AsReadOnlySpan().ElementAtAt(index, predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TSource> First()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).FirstAt(predicate);
+                => source.AsReadOnlySpan().FirstAt(predicate);
 
 #pragma warning disable HLQ005 // Avoid Single() and SingleOrDefault()
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TSource> Single()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).SingleAt(predicate);
+                => source.AsReadOnlySpan().SingleAt(predicate);
 #pragma warning restore HLQ005 // Avoid Single() and SingleOrDefault()
             
             #endregion
@@ -221,7 +220,7 @@ public Option<TSource> Single()
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public TSource[] ToArray()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToArrayAt(predicate);
+                => source.AsReadOnlySpan().ToArrayAt(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
@@ -229,7 +228,7 @@ public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = def
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public List<TSource> ToList()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToListAt(predicate);
+                => source.AsReadOnlySpan().ToListAt(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
@@ -240,7 +239,7 @@ public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelec
             public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionaryAt(keySelector, comparer, predicate);
+                => source.AsReadOnlySpan().ToDictionaryAt(keySelector, comparer, predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
@@ -252,7 +251,7 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
                 where TElementSelector : struct, IFunction<TSource, TElement>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionaryAt<TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(keySelector, elementSelector, comparer, predicate);
+                => source.AsReadOnlySpan().ToDictionaryAt<TSource, TKey, TElement, TKeySelector, TElementSelector, TPredicate>(keySelector, elementSelector, comparer, predicate);
             
             #endregion
         }
@@ -260,72 +259,72 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<int, TPredicate> source)
             where TPredicate : struct, IFunction<int, int, bool>
-            => ((ReadOnlySpan<int>)source.source.AsSpan()).SumAt<int, int, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<int, int, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<int?, TPredicate> source)
             where TPredicate : struct, IFunction<int?, int, bool>
-            => ((ReadOnlySpan<int?>)source.source.AsSpan()).SumAt<int?, int, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<int?, int, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<nint, TPredicate> source)
             where TPredicate : struct, IFunction<nint, int, bool>
-            => ((ReadOnlySpan<nint>)source.source.AsSpan()).SumAt<nint, nint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<nint, nint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<nint?, TPredicate> source)
             where TPredicate : struct, IFunction<nint?, int, bool>
-            => ((ReadOnlySpan<nint?>)source.source.AsSpan()).SumAt<nint?, nint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<nint?, nint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<nuint, TPredicate> source)
             where TPredicate : struct, IFunction<nuint, int, bool>
-            => ((ReadOnlySpan<nuint>)source.source.AsSpan()).SumAt<nuint, nuint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<nuint, nuint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<nuint?, TPredicate> source)
             where TPredicate : struct, IFunction<nuint?, int, bool>
-            => ((ReadOnlySpan<nuint?>)source.source.AsSpan()).SumAt<nuint?, nuint, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<nuint?, nuint, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<long, TPredicate> source)
             where TPredicate : struct, IFunction<long, int, bool>
-            => ((ReadOnlySpan<long>)source.source.AsSpan()).SumAt<long, long, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<long, long, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<long?, TPredicate> source)
             where TPredicate : struct, IFunction<long?, int, bool>
-            => ((ReadOnlySpan<long?>)source.source.AsSpan()).SumAt<long?, long, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<long?, long, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<float, TPredicate> source)
             where TPredicate : struct, IFunction<float, int, bool>
-            => ((ReadOnlySpan<float>)source.source.AsSpan()).SumAt<float, float, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<float, float, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<float?, TPredicate> source)
             where TPredicate : struct, IFunction<float?, int, bool>
-            => ((ReadOnlySpan<float?>)source.source.AsSpan()).SumAt<float?, float, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<float?, float, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<double, TPredicate> source)
             where TPredicate : struct, IFunction<double, int, bool>
-            => ((ReadOnlySpan<double>)source.source.AsSpan()).SumAt<double, double, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<double, double, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<double?, TPredicate> source)
             where TPredicate : struct, IFunction<double?, int, bool>
-            => ((ReadOnlySpan<double?>)source.source.AsSpan()).SumAt<double?, double, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<double?, double, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<decimal, TPredicate> source)
             where TPredicate : struct, IFunction<decimal, int, bool>
-            => ((ReadOnlySpan<decimal>)source.source.AsSpan()).SumAt<decimal, decimal, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<decimal, decimal, TPredicate>(source.predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TPredicate>(this ArraySegmentWhereAtEnumerable<decimal?, TPredicate> source)
             where TPredicate : struct, IFunction<decimal?, int, bool>
-            => ((ReadOnlySpan<decimal?>)source.source.AsSpan()).SumAt<decimal?, decimal, TPredicate>(source.predicate);
+            => source.source.AsReadOnlySpan().SumAt<decimal?, decimal, TPredicate>(source.predicate);
     }
 }
 
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.AsyncValueEnumerable.cs
similarity index 85%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.AsyncValueEnumerable.cs
index cfacfac20..2c01b55c3 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.AsyncValueEnumerable.cs
@@ -12,13 +12,6 @@ namespace NetFabric.Hyperlinq
     public static partial class AsyncValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.AsyncFunctionWrapper<TSource, int, bool>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncFunctionWrapper<TSource, int, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            => source.WhereAt<TEnumerable, TEnumerator, TSource, AsyncFunctionWrapper<TSource, int, bool>>(new AsyncFunctionWrapper<TSource, int, bool>(predicate));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static WhereAtEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> WhereAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -208,19 +201,11 @@ readonly void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine
             public ValueTask<int> CountAsync(CancellationToken cancellationToken = default)
                 => source.CountAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<int> CountAsync(Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => CountAsync(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<int> CountAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.CountAtAsync<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate), cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<int> CountAsync(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => CountAtAsync(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<int> CountAtAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, int, bool>
@@ -233,19 +218,11 @@ public ValueTask<int> CountAtAsync<TPredicate2>(TPredicate2 predicate, Cancellat
             public ValueTask<bool> AllAsync(CancellationToken cancellationToken = default)
                 => source.AllAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AllAsync(Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AllAsync(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AllAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.AllAtAsync<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate), cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AllAsync(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AllAtAsync(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AllAtAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, int, bool>
@@ -255,19 +232,11 @@ public ValueTask<bool> AllAtAsync<TPredicate2>(TPredicate2 predicate, Cancellati
             public ValueTask<bool> AnyAsync(CancellationToken cancellationToken = default)
                 => source.AnyAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AnyAsync(Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AnyAsync(new AsyncFunctionWrapper<TSource, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AnyAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.AnyAtAsync<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate), cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AnyAsync(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AnyAtAsync(new AsyncFunctionWrapper<TSource, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AnyAtAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, int, bool>
@@ -279,18 +248,10 @@ public ValueTask<bool> AnyAtAsync<TPredicate2>(TPredicate2 predicate, Cancellati
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<AsyncFunctionWrapper<TSource, bool>, TPredicate, TSource>> Where(Func<TSource, CancellationToken, ValueTask<bool>> predicate)
-                => Where(new AsyncFunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IAsyncFunction<TSource, bool>
                 => source.WhereAt<TEnumerable, TEnumerator, TSource, AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new AsyncPredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicateAtPredicateAtCombination<TPredicate, AsyncFunctionWrapper<TSource, int, bool>, TSource>> Where(Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
-                => WhereAt(new AsyncFunctionWrapper<TSource, int, bool>(predicate));
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, AsyncPredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>> WhereAt<TPredicate2>(TPredicate2 predicate = default)
@@ -328,11 +289,6 @@ public ValueTask<Lease<TSource>> ToArrayAsync(ArrayPool<TSource> pool, Cancellat
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken = default)
                 => source.ToListAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(cancellationToken, predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey>(Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
-                where TKey : notnull
-                => ToDictionaryAsync(new AsyncFunctionWrapper<TSource, TKey>(keySelector), comparer, cancellationToken);
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
@@ -340,11 +296,6 @@ public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey, TKeySelector
                 where TKeySelector : struct, IAsyncFunction<TSource, TKey>
                 => source.ToDictionaryAtAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(keySelector, comparer, cancellationToken, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement>(Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
-                where TKey : notnull
-                => ToDictionaryAsync<TKey, TElement, AsyncFunctionWrapper<TSource, TKey>, AsyncFunctionWrapper<TSource, TElement>>(new AsyncFunctionWrapper<TSource, TKey>(keySelector), new AsyncFunctionWrapper<TSource, TElement>(elementSelector), comparer, cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ReadOnlyMemory.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ReadOnlyMemory.cs
index b5f9d02d4..a08a106c6 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ReadOnlyMemory.cs
@@ -11,7 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, bool>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static MemoryWhereAtEnumerable<TSource, FunctionWrapper<TSource, int, bool>> Where<TSource>(this ReadOnlyMemory<TSource> source, Func<TSource, int, bool> predicate) 
             => source.WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ReadOnlySpan.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ReadOnlySpan.cs
index 69b2d3edd..c346fffda 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ReadOnlySpan.cs
@@ -9,7 +9,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, bool>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanWhereAtEnumerable<TSource, FunctionWrapper<TSource, int, bool>> Where<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, int, bool> predicate) 
             => source.WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueEnumerable.cs
similarity index 84%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueEnumerable.cs
index 9bc9a5b54..ccf932394 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueEnumerable.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, bool>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static WhereAtEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.WhereAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(new FunctionWrapper<TSource, int, bool>(predicate));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static WhereAtEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> WhereAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -108,19 +101,11 @@ public void Dispose()
             public int Count()
                 => source.CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, bool> predicate)
-                => Count(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.CountAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, int, bool> predicate)
-                => CountAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -133,19 +118,11 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
             public bool All()
                 => source.AllAt<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, bool> predicate)
-                => All(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.AllAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -155,19 +132,11 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
             public bool Any()
                 => source.AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, bool> predicate)
-                => Any(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.AnyAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -176,19 +145,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<FunctionWrapper<TSource, bool>, TPredicate, TSource>> Where(Func<TSource, bool> predicate)
-                => Where(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => source.WhereAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicateAtPredicateAtCombination<TPredicate, FunctionWrapper<TSource, int, bool>, TSource>> Where(Func<TSource, int, bool> predicate)
-                => WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -229,22 +190,12 @@ public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = def
             public List<TSource> ToList()
                 => source.ToListAt<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionaryAt(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionaryAt<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
                 => source.ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(keySelector, comparer, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionaryAt<TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionaryAt<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyCollection.cs
similarity index 84%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyCollection.cs
index 52701135b..686e5fffe 100644
--- a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyCollection.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyCollectionExtensions
     {
 
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static WhereAtEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => WhereAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(source, new FunctionWrapper<TSource, int, bool>(predicate));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static WhereAtEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> WhereAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -107,19 +100,11 @@ public void Dispose()
             public int Count()
                 => CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, bool> predicate)
-                => Count(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.CountAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(source, new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TSource, int, bool> predicate)
-                => CountAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -132,19 +117,11 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
             public bool All()
                 => ValueReadOnlyCollectionExtensions.AllAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, bool> predicate)
-                => All(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.AllAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(source, new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -154,19 +131,11 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
             public bool Any()
                 => ValueReadOnlyCollectionExtensions.AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, bool> predicate)
-                => Any(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.AnyAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(source, new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -175,19 +144,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<FunctionWrapper<TSource, bool>, TPredicate, TSource>> Where(Func<TSource, bool> predicate)
-                => Where(new FunctionWrapper<TSource, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, bool>
                 => ValueReadOnlyCollectionExtensions.WhereAt<TEnumerable, TEnumerator, TSource, PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>>(source, new PredicatePredicateAtCombination<TPredicate2, TPredicate, TSource>(predicate, this.predicate));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicateAtPredicateAtCombination<TPredicate, FunctionWrapper<TSource, int, bool>, TSource>> Where(Func<TSource, int, bool> predicate)
-                => WhereAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<TEnumerable, TEnumerator, TSource, PredicateAtPredicateAtCombination<TPredicate, TPredicate2, TSource>> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TSource, int, bool>
@@ -228,22 +189,12 @@ public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = def
             public List<TSource> ToList()
                 => ToListAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TSource, TKey>
                 => ToDictionaryAt<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TPredicate>(source, keySelector, comparer, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary<TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyList.cs
new file mode 100644
index 000000000..8d1102f04
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAt.ValueReadOnlyList.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueReadOnlyCollectionExtensions.WhereAtEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> WhereAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate : struct, IFunction<TSource, int, bool>
+            => ValueReadOnlyCollectionExtensions.WhereAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAtEnumerator.cs b/NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAtEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAtEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Filtering/Where/WhereAt/WhereAtEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs
similarity index 76%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs
index 0af6eba60..656f059a8 100644
--- a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs
@@ -10,7 +10,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector> WhereSelect<TSource, TResult, TPredicate, TSelector>(
             this in ArraySegment<TSource> source, 
@@ -20,7 +20,6 @@ static ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector
             where TSelector : struct, IFunction<TSource, TResult>
             => new(source, predicate, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>
             : IValueEnumerable<TResult, ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>.Enumerator>
@@ -105,7 +104,7 @@ public readonly void Dispose() { }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Count(predicate);
+                => source.AsReadOnlySpan().Count(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count(Func<TResult, bool> predicate)
@@ -131,7 +130,7 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).All(predicate);
+                => source.AsReadOnlySpan().All(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All(Func<TResult, bool> predicate)
@@ -153,7 +152,7 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Any(predicate);
+                => source.AsReadOnlySpan().Any(predicate);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any(Func<TResult, bool> predicate)
@@ -176,19 +175,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereEnumerable<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => this.Where<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereEnumerable<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.Where<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereAtEnumerable<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-                => this.Where<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereAtEnumerable<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -197,21 +188,11 @@ public ValueEnumerableExtensions.WhereAtEnumerable<ArraySegmentWhereSelectEnumer
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentWhereSelectEnumerable<TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ArraySegmentWhereSelectEnumerable<TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => source.WhereSelect<TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(predicate, new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
                 where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
@@ -224,22 +205,22 @@ public ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentWhereSelectEnu
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> ElementAt(int index)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ElementAt<TSource, TResult, TPredicate, TSelector>(index, predicate, selector);
+                => source.AsReadOnlySpan().ElementAt<TSource, TResult, TPredicate, TSelector>(index, predicate, selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> First()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).First<TSource, TResult, TPredicate, TSelector>(predicate, selector);
+                => source.AsReadOnlySpan().First<TSource, TResult, TPredicate, TSelector>(predicate, selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> Single()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Single<TSource, TResult, TPredicate, TSelector>(predicate, selector);
+                => source.AsReadOnlySpan().Single<TSource, TResult, TPredicate, TSelector>(predicate, selector);
             
             #endregion
             #region Conversion
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public TResult[] ToArray()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToArray<TSource, TResult, TPredicate, TSelector>(predicate, selector);
+                => source.AsReadOnlySpan().ToArray<TSource, TResult, TPredicate, TSelector>(predicate, selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = default)
@@ -247,7 +228,7 @@ public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = def
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public List<TResult> ToList()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToList<TSource, TResult, TPredicate, TSelector>(predicate, selector);
+                => source.AsReadOnlySpan().ToList<TSource, TResult, TPredicate, TSelector>(predicate, selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TResult> ToDictionary<TKey>(Func<TResult, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
@@ -258,7 +239,7 @@ public Dictionary<TKey, TResult> ToDictionary<TKey>(Func<TResult, TKey> keySelec
             public Dictionary<TKey, TResult> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TResult, TKey>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary<TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(keySelector, comparer, predicate, selector);
+                => source.AsReadOnlySpan().ToDictionary<TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(keySelector, comparer, predicate, selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TResult, TKey> keySelector, Func<TResult, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
@@ -270,7 +251,7 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TResult, TKey>
                 where TElementSelector : struct, IFunction<TResult, TElement>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector, TResult, TPredicate, TSelector>(keySelector, elementSelector, comparer, predicate, selector);
+                => source.AsReadOnlySpan().ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector, TResult, TPredicate, TSelector>(keySelector, elementSelector, comparer, predicate, selector);
             
             #endregion
         }
@@ -279,85 +260,85 @@ public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TEl
         public static int Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, int, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, int>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, int, int, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, int, int, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, int?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, int?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, int?, int, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, int?, int, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, nint, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, nint>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nint, nint, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nint, nint, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, nint?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, nint?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nint?, nint, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nint?, nint, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, nuint, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, nuint>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nuint, nuint, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nuint, nuint, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, nuint?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, nuint?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nuint?, nuint, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nuint?, nuint, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, long, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, long>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, long, long, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, long, long, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, long?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, long?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, long?, long, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, long?, long, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, float, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, float>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, float, float, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, float, float, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, float?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, float?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, float?, float, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, float?, float, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, double, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, double>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, double, double, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, double, double, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, double?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, double?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, double?, double, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, double?, double, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, decimal, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, decimal>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, decimal, decimal, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, decimal, decimal, TPredicate, TSelector>(source.predicate, source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TSource, TPredicate, TSelector>(this ArraySegmentWhereSelectEnumerable<TSource, decimal?, TPredicate, TSelector> source)
             where TPredicate : struct, IFunction<TSource, bool>
             where TSelector : struct, IFunction<TSource, decimal?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, decimal?, decimal, TPredicate, TSelector>(source.predicate, source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, decimal?, decimal, TPredicate, TSelector>(source.predicate, source.selector);
     }
 }
 
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.AsyncValueEnumerable.cs
similarity index 86%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.AsyncValueEnumerable.cs
index 02d24b5d6..dd5799b49 100644
--- a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.AsyncValueEnumerable.cs
@@ -11,7 +11,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class AsyncValueEnumerableExtensions
     {
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> WhereSelect<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(
             this TEnumerable source,
@@ -23,7 +23,6 @@ static WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredic
             where TSelector : struct, IAsyncFunction<TSource, TResult>
             => new(in source, predicate, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>
             : IAsyncValueEnumerable<TResult, WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>.Enumerator>
@@ -234,19 +233,11 @@ void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
             public ValueTask<int> CountAsync(CancellationToken cancellationToken = default)
                 => source.CountAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<int> CountAsync(Func<TResult, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => CountAsync(new AsyncFunctionWrapper<TResult, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<int> CountAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, bool>
                 => AsyncValueEnumerableExtensions.CountAsync<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(this, predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<int> CountAsync(Func<TResult, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => CountAtAsync(new AsyncFunctionWrapper<TResult, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<int> CountAtAsync<TPredicate2>(TPredicate2 predicate = default, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, int, bool>
@@ -259,19 +250,11 @@ public ValueTask<int> CountAtAsync<TPredicate2>(TPredicate2 predicate = default,
             public ValueTask<bool> AllAsync(CancellationToken cancellationToken = default)
                 => source.AllAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AllAsync(Func<TResult, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AllAsync(new AsyncFunctionWrapper<TResult, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AllAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, bool>
                 => this.AllAsync<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AllAsync(Func<TResult, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AllAtAsync(new AsyncFunctionWrapper<TResult, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AllAtAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, int, bool>
@@ -281,19 +264,11 @@ public ValueTask<bool> AllAtAsync<TPredicate2>(TPredicate2 predicate, Cancellati
             public ValueTask<bool> AnyAsync(CancellationToken cancellationToken = default)
                 => source.AnyAsync<TEnumerable, TEnumerator, TSource, TPredicate>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AnyAsync(Func<TResult, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AnyAsync(new AsyncFunctionWrapper<TResult, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AnyAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, bool>
                 => this.AnyAsync<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate, cancellationToken);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<bool> AnyAsync(Func<TResult, int, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
-                => AnyAtAsync(new AsyncFunctionWrapper<TResult, int, bool>(predicate), cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<bool> AnyAtAsync<TPredicate2>(TPredicate2 predicate, CancellationToken cancellationToken = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, int, bool>
@@ -302,19 +277,11 @@ public ValueTask<bool> AnyAtAsync<TPredicate2>(TPredicate2 predicate, Cancellati
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, AsyncFunctionWrapper<TResult, bool>> Where(Func<TResult, CancellationToken, ValueTask<bool>> predicate)
-                => this.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, bool>
                 => this.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, AsyncFunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, CancellationToken, ValueTask<bool>> predicate)
-                => this.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IAsyncFunction<TResult, int, bool>
@@ -323,10 +290,6 @@ public WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, AsyncSelectorSelectorCombination<TSelector, AsyncFunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, CancellationToken, ValueTask<TResult2>> selector)
-                => Select<TResult2, AsyncFunctionWrapper<TResult, TResult2>>(new AsyncFunctionWrapper<TResult, TResult2>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, AsyncSelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IAsyncFunction<TResult, TResult2>
@@ -364,22 +327,12 @@ public ValueTask<Lease<TResult>> ToArrayAsync(ArrayPool<TResult> pool, Cancellat
             public ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken = default)
                 => source.ToListAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(cancellationToken, predicate, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TResult>> ToDictionaryAsync<TKey>(Func<TResult, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
-                where TKey : notnull
-                => ToDictionaryAsync(new AsyncFunctionWrapper<TResult, TKey>(keySelector), comparer, cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<Dictionary<TKey, TResult>> ToDictionaryAsync<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
                 where TKey : notnull
                 where TKeySelector : struct, IAsyncFunction<TResult, TKey>
                 => source.ToDictionaryAsync<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(keySelector, comparer, cancellationToken, predicate, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement>(Func<TResult, CancellationToken, ValueTask<TKey>> keySelector, Func<TResult, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
-                where TKey : notnull
-                => ToDictionaryAsync<TKey, TElement, AsyncFunctionWrapper<TResult, TKey>, AsyncFunctionWrapper<TResult, TElement>>(new AsyncFunctionWrapper<TResult, TKey>(keySelector), new AsyncFunctionWrapper<TResult, TElement>(elementSelector), comparer, cancellationToken);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlyMemory.cs
similarity index 90%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlyMemory.cs
index 883bdc1c2..bfb1469e9 100644
--- a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlyMemory.cs
@@ -11,7 +11,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector> WhereSelect<TSource, TResult, TPredicate, TSelector>(
             this ReadOnlyMemory<TSource> source, 
@@ -21,7 +21,6 @@ static MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector> Wher
             where TSelector : struct, IFunction<TSource, TResult>
             => new(source, predicate, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>
             : IValueEnumerable<TResult, MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>.Enumerator>
@@ -173,19 +172,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereEnumerable<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => this.Where<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereEnumerable<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.Where<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereAtEnumerable<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-                => this.Where<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereAtEnumerable<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -194,21 +185,11 @@ public ValueEnumerableExtensions.WhereAtEnumerable<MemoryWhereSelectEnumerable<T
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public MemoryWhereSelectEnumerable<TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public MemoryWhereSelectEnumerable<TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => source.WhereSelect<TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(predicate, new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectManyEnumerable<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectManyEnumerable<MemoryWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
                 where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlySpan.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlySpan.cs
index 07cfb1f15..5cbabe94b 100644
--- a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ReadOnlySpan.cs
@@ -9,7 +9,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector> WhereSelect<TSource, TResult, TPredicate, TSelector>(
             this ReadOnlySpan<TSource> source, 
@@ -19,7 +19,6 @@ static SpanWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector> WhereS
             where TSelector : struct, IFunction<TSource, TResult>
             => new(source, predicate, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly ref struct SpanWhereSelectEnumerable<TSource, TResult, TPredicate, TSelector>
             where TPredicate : struct, IFunction<TSource, bool>
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueEnumerable.cs
similarity index 83%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueEnumerable.cs
index 8a816f47e..212b14883 100644
--- a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueEnumerable.cs
@@ -11,7 +11,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> WhereSelect<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(
             this TEnumerable source, 
@@ -23,7 +23,6 @@ static WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredic
             where TSelector : struct, IFunction<TSource, TResult>
             => new(in source, predicate, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> 
             : IValueEnumerable<TResult, WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>.Enumerator>
@@ -108,19 +107,11 @@ public void Dispose()
             public int Count()
                 => source.Count<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TResult, bool> predicate)
-                => Count(new FunctionWrapper<TResult, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => ValueEnumerableExtensions.Count<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(this, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TResult, int, bool> predicate)
-                => CountAt(new FunctionWrapper<TResult, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -133,19 +124,11 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
             public bool All()
                 => source.All<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TResult, bool> predicate)
-                => All(new FunctionWrapper<TResult, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.All<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TResult, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TResult, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -155,19 +138,11 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
             public bool Any()
                 => source.Any<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TResult, bool> predicate)
-                => Any(new FunctionWrapper<TResult, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.Any<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TResult, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TResult, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -176,19 +151,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => this.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-                => this.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -197,21 +164,11 @@ public WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => source.WhereSelect<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(predicate, new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectManyEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectManyEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
                 where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
@@ -249,22 +206,12 @@ public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = def
             public List<TResult> ToList()
                 => source.ToList<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(predicate, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TResult> ToDictionary<TKey>(Func<TResult, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary(new FunctionWrapper<TResult, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TResult> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TResult, TKey>
                 => source.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(keySelector, comparer, predicate, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TResult, TKey> keySelector, Func<TResult, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary<TKey, TElement, FunctionWrapper<TResult, TKey>, FunctionWrapper<TResult, TElement>>(new FunctionWrapper<TResult, TKey>(keySelector), new FunctionWrapper<TResult, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueReadOnlyCollection.cs
similarity index 84%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueReadOnlyCollection.cs
index f0f53d467..d163a0fce 100644
--- a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelect.ValueReadOnlyCollection.cs
@@ -11,7 +11,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyCollectionExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> WhereSelect<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(
             this TEnumerable source, 
@@ -23,7 +23,6 @@ static WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredic
             where TSelector : struct, IFunction<TSource, TResult>
             => new(in source, predicate, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector> 
             : IValueEnumerable<TResult, WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>.Enumerator>
@@ -108,19 +107,11 @@ public void Dispose()
             public int Count()
                 => ValueReadOnlyCollectionExtensions.Count<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TResult, bool> predicate)
-                => Count(new FunctionWrapper<TResult, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Count<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => ValueEnumerableExtensions.Count<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(this, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Count(Func<TResult, int, bool> predicate)
-                => CountAt(new FunctionWrapper<TResult, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int CountAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -133,19 +124,11 @@ public int CountAt<TPredicate2>(TPredicate2 predicate = default)
             public bool All()
                 => ValueReadOnlyCollectionExtensions.All<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TResult, bool> predicate)
-                => All(new FunctionWrapper<TResult, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool All<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.All<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TResult, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TResult, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -155,19 +138,11 @@ public bool AllAt<TPredicate2>(TPredicate2 predicate = default)
             public bool Any()
                 => ValueReadOnlyCollectionExtensions.Any<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TResult, bool> predicate)
-                => Any(new FunctionWrapper<TResult, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => this.Any<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TResult, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TResult, int, bool>(predicate));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -176,19 +151,11 @@ public bool AnyAt<TPredicate2>(TPredicate2 predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => ValueEnumerableExtensions.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> Where<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, bool>
                 => ValueEnumerableExtensions.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2>(this, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-                => ValueEnumerableExtensions.Where<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereAtEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TPredicate2> WhereAt<TPredicate2>(TPredicate2 predicate = default)
                 where TPredicate2 : struct, IFunction<TResult, int, bool>
@@ -197,21 +164,11 @@ public ValueEnumerableExtensions.WhereAtEnumerable<WhereSelectEnumerable<TEnumer
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => WhereSelect<TEnumerable, TEnumerator, TSource, TResult2, TPredicate, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, predicate, new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectManyEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => ValueEnumerableExtensions.SelectMany<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectManyEnumerable<WhereSelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
                 where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
@@ -249,22 +206,12 @@ public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = def
             public List<TResult> ToList()
                 => ValueReadOnlyCollectionExtensions.ToList<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(source, predicate, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TResult> ToDictionary<TKey>(Func<TResult, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary(new FunctionWrapper<TResult, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TResult> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
                 where TKeySelector : struct, IFunction<TResult, TKey>
                 => ValueReadOnlyCollectionExtensions.ToDictionary<TEnumerable, TEnumerator, TSource, TKey, TKeySelector, TResult, TPredicate, TSelector>(source, keySelector, comparer, predicate, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TResult, TKey> keySelector, Func<TResult, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary<TKey, TElement, FunctionWrapper<TResult, TKey>, FunctionWrapper<TResult, TElement>>(new FunctionWrapper<TResult, TKey>(keySelector), new FunctionWrapper<TResult, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelectEnumerator.cs b/NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelectEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelectEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Filtering/WhereSelect/WhereSelect/WhereSelectEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Empty.cs b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Empty.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Empty.cs
rename to NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Empty.cs
diff --git a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Range.cs b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Range.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Range.cs
rename to NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Range.cs
index 474d2d5a8..63f676f55 100644
--- a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Range.cs
+++ b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Range.cs
@@ -29,7 +29,6 @@ public static RangeEnumerable Range(int start, int count)
             return new RangeEnumerable(start, count, end);
         }
 
-        [GeneratorMapping("TSource", "int", true)]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct RangeEnumerable
             : IAsyncValueEnumerable<int, RangeEnumerable.DisposableEnumerator>
diff --git a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Repeat.cs b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Repeat.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Repeat.cs
rename to NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Repeat.cs
index e175a1a28..7989ab37d 100644
--- a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Repeat.cs
+++ b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Repeat.cs
@@ -155,10 +155,6 @@ public ValueTask<bool> ContainsAsync(TSource value, IEqualityComparer<TSource>?
                     ? new ValueTask<bool>(result: count is not 0 && EqualityComparer<TSource>.Default.Equals(this.value, value))
                     : new ValueTask<bool>(result: count is not 0 && comparer.Equals(this.value, value));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public RepeatEnumerable<TResult> Select<TResult>(Func<TSource, CancellationToken, ValueTask<TResult>> selector) 
-                => Select<TResult, AsyncFunctionWrapper<TSource, TResult>>(new AsyncFunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public RepeatEnumerable<TResult> Select<TResult, TSelector>(TSelector selector = default) 
                 where TSelector : struct, IAsyncFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Return.cs b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Return.cs
similarity index 72%
rename from NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Return.cs
rename to NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Return.cs
index f9887481d..3e936f76c 100644
--- a/NetFabric.Hyperlinq/Generation/AsyncValueEnumerable/Return.cs
+++ b/NetFabric.Hyperlinq.Core/Generation/AsyncValueEnumerable/Return.cs
@@ -93,10 +93,6 @@ public ValueTask<bool> ContainsAsync(TSource value, IEqualityComparer<TSource>?
                     ? new ValueTask<bool>(result: EqualityComparer<TSource>.Default.Equals(this.value, value))
                     : new ValueTask<bool>(result: comparer.Equals(this.value, value));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ReturnEnumerable<TResult> Select<TResult>(Func<TSource, CancellationToken, ValueTask<TResult>> selector) 
-                => Select<TResult, AsyncFunctionWrapper<TSource, TResult>>(new AsyncFunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ReturnEnumerable<TResult> Select<TResult, TSelector>(TSelector selector = default) 
                 where TSelector : struct, IAsyncFunction<TSource, TResult>
@@ -129,29 +125,19 @@ public ValueTask<List<TSource>> ToListAsync()
                 => new(result: new List<TSource>(1) { value });
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionaryAsync(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
+            public async ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
                 where TKey : notnull
-                where TKeySelector : struct, IFunction<TSource, TKey>
+                where TKeySelector : struct, IAsyncFunction<TSource, TKey>
                 // ReSharper disable once HeapView.ObjectAllocation.Evident
-                => new(result: new Dictionary<TKey, TSource>(1, comparer) { { keySelector.Invoke(value), value } });
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionaryAsync<TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
+                => new Dictionary<TKey, TSource>(1, comparer) { { await keySelector.InvokeAsync(value, cancellationToken).ConfigureAwait(false), value } };
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
+            public async ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default, CancellationToken cancellationToken = default)
                 where TKey : notnull
-                where TKeySelector : struct, IFunction<TSource, TKey>
-                where TElementSelector : struct, IFunction<TSource, TElement>
+                where TKeySelector : struct, IAsyncFunction<TSource, TKey>
+                where TElementSelector : struct, IAsyncFunction<TSource, TElement>
                 // ReSharper disable once HeapView.ObjectAllocation.Evident
-                => new(result: new Dictionary<TKey, TElement>(1, comparer) { { keySelector.Invoke(value), elementSelector.Invoke(value) } });
+                => new Dictionary<TKey, TElement>(1, comparer) { { await keySelector.InvokeAsync(value, cancellationToken).ConfigureAwait(false), await elementSelector.InvokeAsync(value, cancellationToken).ConfigureAwait(false) } };
         }
 
 #pragma warning disable IDE0060 // Remove unused parameter
diff --git a/NetFabric.Hyperlinq/Generation/ValueEnumerable/CreateValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/CreateValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Generation/ValueEnumerable/CreateValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/CreateValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Empty.cs b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Empty.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Generation/ValueEnumerable/Empty.cs
rename to NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Empty.cs
diff --git a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Range.cs b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Range.cs
similarity index 92%
rename from NetFabric.Hyperlinq/Generation/ValueEnumerable/Range.cs
rename to NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Range.cs
index dbe032359..2443a0670 100644
--- a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Range.cs
+++ b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Range.cs
@@ -29,7 +29,6 @@ public static RangeEnumerable Range(int start, int count)
             return new RangeEnumerable(start, count);
         }
 
-        [GeneratorMapping("TSource", "int", true)]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct RangeEnumerable
             : IValueReadOnlyList<int, RangeEnumerable.DisposableEnumerator>
@@ -123,23 +122,20 @@ void IList<int>.RemoveAt(int index)
             public struct Enumerator
             {
                 readonly int end;
-                int current;
 
                 internal Enumerator(in RangeEnumerable enumerable)
                 {
-                    current = enumerable.start - 1;
-                    end = current + enumerable.Count;
+                    Current = enumerable.start - 1;
+                    end = Current + enumerable.Count;
                 }
 
-                public int Current
-                {
-                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    get => current;
+                public int Current { [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get; private set;
                 }
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
-                    => ++current <= end;
+                    => ++Current <= end;
             }
 
             [StructLayout(LayoutKind.Auto)]
@@ -147,26 +143,23 @@ public struct DisposableEnumerator
                 : IEnumerator<int>
             {
                 readonly int end;
-                int current;
 
                 internal DisposableEnumerator(in RangeEnumerable enumerable)
                 {
-                    current = enumerable.start - 1;
-                    end = current + enumerable.Count;
+                    Current = enumerable.start - 1;
+                    end = Current + enumerable.Count;
                 }
 
-                public int Current
-                {
-                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    get => current;
+                public int Current { [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get; private set;
                 }
                 object? IEnumerator.Current
                     // ReSharper disable once HeapView.BoxingAllocation
-                    => current;
+                    => Current;
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
-                    => ++current <= end;
+                    => ++Current <= end;
 
                 [ExcludeFromCodeCoverage]
                 [DoesNotReturn]
diff --git a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Repeat.cs b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Repeat.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Generation/ValueEnumerable/Repeat.cs
rename to NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Repeat.cs
index 2f3a0ac0b..e45ccc3f7 100644
--- a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Repeat.cs
+++ b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Repeat.cs
@@ -166,10 +166,6 @@ public bool Contains(TSource value, IEqualityComparer<TSource>? comparer)
                     _ => count is not 0 && comparer.Equals(this.value, value)
                 };
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public RepeatEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
-                => Select<TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public RepeatEnumerable<TResult> Select<TResult, TSelector>(TSelector selector = default) 
                 where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Return.cs b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Return.cs
similarity index 88%
rename from NetFabric.Hyperlinq/Generation/ValueEnumerable/Return.cs
rename to NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Return.cs
index 58f85cb90..2011435bd 100644
--- a/NetFabric.Hyperlinq/Generation/ValueEnumerable/Return.cs
+++ b/NetFabric.Hyperlinq.Core/Generation/ValueEnumerable/Return.cs
@@ -173,10 +173,6 @@ public bool Contains(TSource value, IEqualityComparer<TSource>? comparer)
                     _ => comparer.Equals(this.value, value)
                 };
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ReturnEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
-                => Select<TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ReturnEnumerable<TResult> Select<TResult, TSelector>(TSelector selector = default) 
                 where TSelector : struct, IFunction<TSource, TResult>
@@ -207,11 +203,6 @@ public TSource[] ToArray()
             public List<TSource> ToList()
                 => new(1) { value };
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary(new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
@@ -219,11 +210,6 @@ public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector k
                 // ReSharper disable once HeapView.ObjectAllocation.Evident
                 => new(new Dictionary<TKey, TSource>(1, comparer) { { keySelector.Invoke(value), value } });
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ToDictionary<TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
                 where TKey : notnull
diff --git a/NetFabric.Hyperlinq/GlobalSuppressions.cs b/NetFabric.Hyperlinq.Core/GlobalSuppressions.cs
similarity index 100%
rename from NetFabric.Hyperlinq/GlobalSuppressions.cs
rename to NetFabric.Hyperlinq.Core/GlobalSuppressions.cs
diff --git a/NetFabric.Hyperlinq/Lease.cs b/NetFabric.Hyperlinq.Core/Lease.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Lease.cs
rename to NetFabric.Hyperlinq.Core/Lease.cs
diff --git a/NetFabric.Hyperlinq.Core/NetFabric.Hyperlinq.Core.csproj b/NetFabric.Hyperlinq.Core/NetFabric.Hyperlinq.Core.csproj
new file mode 100644
index 000000000..c36b41a0c
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/NetFabric.Hyperlinq.Core.csproj
@@ -0,0 +1,84 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+    <PackageId>NetFabric.Hyperlinq.Core</PackageId>
+    <Title>NetFabric.Hyperlinq.Core</Title>
+    <Description> The main assembly of NetFabric.Hyperlinq.</Description>
+    <Version>1.0.0-beta00</Version>
+    <PackageIcon>Icon.png</PackageIcon>
+    <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    <PackageTags>netfabric, hyperlinq, linq, enumeration, extensions, performance</PackageTags>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <!-- <TreatWarningsAsErrors>true</TreatWarningsAsErrors> -->
+    <RootNamespace>NetFabric.Hyperlinq</RootNamespace>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'=='net461' Or '$(TargetFramework)'=='netstandard2.0' Or '$(TargetFramework)'=='netcoreapp2.1'">
+    <!-- disable nullable warning -->
+    <NoWarn>$(NoWarn);8600;8601;8602;8603;8604</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <SupportedPlatform Include="browser" />
+  </ItemGroup>
+  
+  <ItemGroup Condition="'$(TargetFramework)' == 'net461' Or '$(TargetFramework)' == 'netstandard2.0'">
+    <Compile Remove="Conversion\AsValueEnumerable\AsValueEnumerable.ImmutableArray.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\Icon.png" Pack="true" PackagePath="" />
+    <None Include="..\LICENSE" Pack="true" PackagePath="" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NetFabric.Hyperlinq.Abstractions\NetFabric.Hyperlinq.Abstractions.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net461' Or '$(TargetFramework)'=='netstandard2.0'">
+    <PackageReference Include="System.Memory" Version="4.5.4" />
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="5.0.0" />
+    <PackageReference Include="System.Buffers" Version="4.5.1" />
+    <PackageReference Include="Nullable" Version="1.3.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Meziantou.Analyzer" Version="1.0.667">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="UnoptimizedAssemblyDetector" Version="0.1.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Resource.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resource.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Update="Resource.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resource.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+
+</Project>
diff --git a/NetFabric.Hyperlinq/Option/NoneOption.cs b/NetFabric.Hyperlinq.Core/Option/NoneOption.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Option/NoneOption.cs
rename to NetFabric.Hyperlinq.Core/Option/NoneOption.cs
diff --git a/NetFabric.Hyperlinq/Option/Option.cs b/NetFabric.Hyperlinq.Core/Option/Option.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Option/Option.cs
rename to NetFabric.Hyperlinq.Core/Option/Option.cs
index 6eb50cea1..88744c90d 100644
--- a/NetFabric.Hyperlinq/Option/Option.cs
+++ b/NetFabric.Hyperlinq.Core/Option/Option.cs
@@ -222,7 +222,6 @@ public List<TValue> ToList()
             }; 
 
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct SelectManyEnumerable<TSubEnumerable, TSubEnumerator, TResult, TSelector>
             : IValueEnumerable<TResult, SelectManyEnumerable<TSubEnumerable, TSubEnumerator, TResult, TSelector>.Enumerator>
diff --git a/NetFabric.Hyperlinq/Partitioning/Skip/Skip.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/Skip/Skip.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Partitioning/Skip/Skip.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ReadOnlyList.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Partitioning/Skip/Skip.ReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ReadOnlyList.cs
index 4e30d7049..132bfd81a 100644
--- a/NetFabric.Hyperlinq/Partitioning/Skip/Skip.ReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ReadOnlyList.cs
@@ -7,7 +7,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ReadOnlyListExtensions
     {
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static SkipTakeEnumerable<TList, TSource> Skip<TList, TSource>(this TList source, int count)
             where TList : struct, IReadOnlyList<TSource>
diff --git a/NetFabric.Hyperlinq/Partitioning/Skip/Skip.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/Skip/Skip.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Partitioning/Skip/Skip.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueReadOnlyCollection.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/Skip/Skip.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueReadOnlyCollection.cs
diff --git a/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueReadOnlyList.cs
new file mode 100644
index 000000000..6c808b833
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Partitioning/Skip/Skip.ValueReadOnlyList.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueReadOnlyCollectionExtensions.SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> Skip<TEnumerable, TEnumerator, TSource>(this TEnumerable source, int count)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Skip<TEnumerable, TEnumerator, TSource>(source, count);
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ReadOnlyList.cs
similarity index 88%
rename from NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ReadOnlyList.cs
index d98d9f8f1..69727b49b 100644
--- a/NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ReadOnlyList.cs
@@ -278,32 +278,5 @@ static bool ComparerContains(TList source, TSource value, IEqualityComparer<TSou
                 }
             }
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource>(this in SkipTakeEnumerable<TList, TSource> source)
-            where TList : struct, IReadOnlyList<TSource>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource>(this SkipTakeEnumerable<TList, TSource> source, Func<TSource, bool> predicate)
-            where TList : struct, IReadOnlyList<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource, TPredicate>(this SkipTakeEnumerable<TList, TSource> source, TPredicate predicate = default)
-            where TList : struct, IReadOnlyList<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource>(this SkipTakeEnumerable<TList, TSource> source, Func<TSource, int, bool> predicate)
-            where TList : struct, IReadOnlyList<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TList, TSource, TPredicate>(this SkipTakeEnumerable<TList, TSource> source, TPredicate predicate = default)
-            where TList : struct, IReadOnlyList<TSource>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ValueReadOnlyCollection.cs
similarity index 82%
rename from NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ValueReadOnlyCollection.cs
index ab93810ac..d3070fa55 100644
--- a/NetFabric.Hyperlinq/Partitioning/SkipTake/SkipTake.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Partitioning/SkipTake/SkipTake.ValueReadOnlyCollection.cs
@@ -250,37 +250,5 @@ public SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> Take(int count)
             
             #endregion
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this in SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> source)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
     }
 }
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Partitioning/Take/Take.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/Take/Take.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Take/Take.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Partitioning/Take/Take.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ReadOnlyList.cs
similarity index 94%
rename from NetFabric.Hyperlinq/Partitioning/Take/Take.ReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ReadOnlyList.cs
index c9c2f0361..915fe8bcf 100644
--- a/NetFabric.Hyperlinq/Partitioning/Take/Take.ReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ReadOnlyList.cs
@@ -6,7 +6,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ReadOnlyListExtensions
     {
         
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static SkipTakeEnumerable<TList, TSource> Take<TList, TSource>(this TList source, int count)
             where TList : struct, IReadOnlyList<TSource>
diff --git a/NetFabric.Hyperlinq/Partitioning/Take/Take.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/Take/Take.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Partitioning/Take/Take.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueReadOnlyCollection.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Partitioning/Take/Take.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueReadOnlyCollection.cs
diff --git a/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueReadOnlyList.cs
new file mode 100644
index 000000000..02fa9d9ad
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Partitioning/Take/Take.ValueReadOnlyList.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueReadOnlyCollectionExtensions.SkipTakeEnumerable<TEnumerable, TEnumerator, TSource> Take<TEnumerable, TEnumerator, TSource>(this TEnumerable source, int count)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Take<TEnumerable, TEnumerator, TSource>(source, count);
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ArraySegment.cs
similarity index 73%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ArraySegment.cs
index f72ec8ee4..a8a19b00d 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ArraySegment.cs
@@ -10,7 +10,6 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ArraySegmentSelectEnumerable<TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TSource, TResult>(this in ArraySegment<TSource> source, Func<TSource, TResult> selector)
             => source.Select<TSource, TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
@@ -20,7 +19,6 @@ static ArraySegmentSelectEnumerable<TSource, TResult, TSelector> Select<TSource,
             where TSelector : struct, IFunction<TSource, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct ArraySegmentSelectEnumerable<TSource, TResult, TSelector>
             : IValueReadOnlyList<TResult, ArraySegmentSelectEnumerable<TSource, TResult, TSelector>.Enumerator>
@@ -92,7 +90,7 @@ void ICollection<TResult>.Add(TResult item)
             void ICollection<TResult>.Clear()
                 => Throw.NotSupportedException();
             public bool Contains(TResult item)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Contains(item, default, selector);
+                => source.AsReadOnlySpan().Contains(item, default, selector);
             bool ICollection<TResult>.Remove(TResult item)
                 => Throw.NotSupportedException<bool>();
 
@@ -183,41 +181,28 @@ public ArraySegmentSelectAtEnumerable<TSource, TResult2, SelectorSelectorAtCombi
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => source.SelectAt<TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> ElementAt(int index)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ElementAt<TSource, TResult, TSelector>(index, selector);
+                => source.AsReadOnlySpan().ElementAt<TSource, TResult, TSelector>(index, selector);
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> First()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).First<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().First<TSource, TResult, TSelector>(selector);
 
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> Single()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Single<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().Single<TSource, TResult, TSelector>(selector);
             
             #endregion
             #region Conversion
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public TResult[] ToArray()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToArray<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().ToArray<TSource, TResult, TSelector>(selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = default)
@@ -225,32 +210,17 @@ public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = def
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public List<TResult> ToList()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToList<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().ToList<TSource, TResult, TSelector>(selector);
             
             #endregion
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectEnumerable<TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, ArraySegmentSelectEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TSource, TResult, TSelector, TPredicate>(this ArraySegmentSelectEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, TResult>
             where TPredicate : struct, IFunction<TResult, bool>
             => ValueReadOnlyCollectionExtensions.Count<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, ArraySegmentSelectEnumerable<TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectEnumerable<TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, ArraySegmentSelectEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TSource, TResult, TSelector, TPredicate>(this ArraySegmentSelectEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, TResult>
@@ -260,72 +230,72 @@ public static int CountAt<TSource, TResult, TSelector, TPredicate>(this ArraySeg
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, int, TSelector> source)
             where TSelector : struct, IFunction<TSource, int>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, int, int, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, int, int, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, int?, TSelector> source)
             where TSelector : struct, IFunction<TSource, int?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, int?, int, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, int?, int, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, nint, TSelector> source)
             where TSelector : struct, IFunction<TSource, nint>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nint, nint, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nint, nint, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, nint?, TSelector> source)
             where TSelector : struct, IFunction<TSource, nint?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nint?, nint, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nint?, nint, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, nuint, TSelector> source)
             where TSelector : struct, IFunction<TSource, nuint>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nuint, nuint, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nuint, nuint, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nuint Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, nuint?, TSelector> source)
             where TSelector : struct, IFunction<TSource, nuint?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, nuint?, nuint, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, nuint?, nuint, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, long, TSelector> source)
             where TSelector : struct, IFunction<TSource, long>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, long, long, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, long, long, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, long?, TSelector> source)
             where TSelector : struct, IFunction<TSource, long?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, long?, long, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, long?, long, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, float, TSelector> source)
             where TSelector : struct, IFunction<TSource, float>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, float, float, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, float, float, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, float?, TSelector> source)
             where TSelector : struct, IFunction<TSource, float?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, float?, float, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, float?, float, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, double, TSelector> source)
             where TSelector : struct, IFunction<TSource, double>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, double, double, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, double, double, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, double?, TSelector> source)
             where TSelector : struct, IFunction<TSource, double?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, double?, double, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, double?, double, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, decimal, TSelector> source)
             where TSelector : struct, IFunction<TSource, decimal>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, decimal, decimal, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, decimal, decimal, TSelector>(source.selector);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static decimal Sum<TSource, TSelector>(this ArraySegmentSelectEnumerable<TSource, decimal?, TSelector> source)
             where TSelector : struct, IFunction<TSource, decimal?>
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).Sum<TSource, decimal?, decimal, TSelector>(source.selector);
+            => source.source.AsReadOnlySpan().Sum<TSource, decimal?, decimal, TSelector>(source.selector);
 
     }
 }
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.AsyncValueEnumerable.cs
similarity index 92%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.AsyncValueEnumerable.cs
index 49d3d76a7..cf9417147 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.AsyncValueEnumerable.cs
@@ -12,13 +12,6 @@ namespace NetFabric.Hyperlinq
     public static partial class AsyncValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.AsyncFunctionWrapper<TSource, TResult>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, AsyncFunctionWrapper<TSource, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            => source.Select<TEnumerable, TEnumerator, TSource, TResult, AsyncFunctionWrapper<TSource, TResult>>(new AsyncFunctionWrapper<TSource, TResult>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> Select<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -26,7 +19,6 @@ public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSele
             where TSelector : struct, IAsyncFunction<TSource, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
             : IAsyncValueEnumerable<TResult, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -216,20 +208,12 @@ public ValueTask<bool> AnyAsync(CancellationToken cancellationToken = default)
             
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorSelectorCombination<TSelector, AsyncFunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, CancellationToken, ValueTask<TResult2>> selector)
-                => Select<TResult2, AsyncFunctionWrapper<TResult, TResult2>>(new AsyncFunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IAsyncFunction<TResult, TResult2>
                 => source.Select<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new AsyncSelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorSelectorAtCombination<TSelector, AsyncFunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, CancellationToken, ValueTask<TResult2>> selector)
-                => SelectAt<TResult2, AsyncFunctionWrapper<TResult, int, TResult2>>(new AsyncFunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IAsyncFunction<TResult, int, TResult2>
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ReadOnlyMemory.cs
similarity index 84%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ReadOnlyMemory.cs
index b62a3715c..6b7094a0f 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ReadOnlyMemory.cs
@@ -11,7 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static MemorySelectEnumerable<TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TSource, TResult>(this ReadOnlyMemory<TSource> source, Func<TSource, TResult> selector)
             => source.Select<TSource, TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
@@ -21,7 +20,6 @@ static MemorySelectEnumerable<TSource, TResult, TSelector> Select<TSource, TResu
             where TSelector : struct, IFunction<TSource, TResult>
             => new(source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct MemorySelectEnumerable<TSource, TResult, TSelector>
             : IValueReadOnlyList<TResult, MemorySelectEnumerable<TSource, TResult, TSelector>.Enumerator>
@@ -171,19 +169,6 @@ public MemorySelectAtEnumerable<TSource, TResult2, SelectorSelectorAtCombination
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => source.SelectAt<TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<MemorySelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<MemorySelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<MemorySelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<MemorySelectEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
@@ -215,27 +200,12 @@ public List<TResult> ToList()
             #endregion
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this MemorySelectEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this MemorySelectEnumerable<TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<MemorySelectEnumerable<TSource, TResult, TSelector>, MemorySelectEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TSource, TResult, TSelector, TPredicate>(this MemorySelectEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, TResult>
             where TPredicate : struct, IFunction<TResult, bool>
             => ValueReadOnlyCollectionExtensions.Count<MemorySelectEnumerable<TSource, TResult, TSelector>, MemorySelectEnumerable<TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this MemorySelectEnumerable<TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<MemorySelectEnumerable<TSource, TResult, TSelector>, MemorySelectEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TSource, TResult, TSelector, TPredicate>(this MemorySelectEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ReadOnlySpan.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ReadOnlySpan.cs
index 7c3bae6fa..81181db8a 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ReadOnlySpan.cs
@@ -9,7 +9,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanSelectEnumerable<TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TSource, TResult>(this ReadOnlySpan<TSource> source, Func<TSource, TResult> selector)
             => source.Select<TSource, TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
@@ -19,7 +18,6 @@ static SpanSelectEnumerable<TSource, TResult, TSelector> Select<TSource, TResult
             where TSelector : struct, IFunction<TSource, TResult>
             => new(source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public ref struct SpanSelectEnumerable<TSource, TResult, TSelector>
             where TSelector : struct, IFunction<TSource, TResult>
@@ -132,11 +130,6 @@ public bool SequenceEqual(IEnumerable<TResult> other, IEqualityComparer<TResult>
             }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this SpanSelectEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => source.Count;
-
         // [MethodImpl(MethodImplOptions.AggressiveInlining)]
         // public static int Count<TSource, TResult, TSelector>(this SpanSelectEnumerable<TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
         //     where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueEnumerable.cs
similarity index 86%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueEnumerable.cs
index 868a3013e..f45fc6316 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueEnumerable.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, TResult> selector)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Select<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<TSource, TResult>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> Select<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -25,7 +18,6 @@ public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSele
             where TSelector : struct, IFunction<TSource, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> 
             : IValueEnumerable<TResult, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -106,31 +98,17 @@ public bool Any()
             
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => source.Select<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, FunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-                => SelectAt<TResult2, FunctionWrapper<TResult, int, TResult2>>(new FunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => source.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectManyEnumerable<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectManyEnumerable<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
                 where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueReadOnlyCollection.cs
similarity index 77%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueReadOnlyCollection.cs
index 03ae3ac84..b472b0695 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueReadOnlyCollection.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyCollectionExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, TResult> selector)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => Select<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>>(source, new FunctionWrapper<TSource, TResult>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> Select<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -25,7 +18,6 @@ public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSele
             where TSelector : struct, IFunction<TSource, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
             : IValueReadOnlyCollection<TResult, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -140,38 +132,17 @@ public bool Any()
             
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => ValueReadOnlyCollectionExtensions.Select<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, FunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-                => SelectAt<TResult2, FunctionWrapper<TResult, int, TResult2>>(new FunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => ValueReadOnlyCollectionExtensions.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
@@ -204,20 +175,6 @@ public List<TResult> ToList()
             
             #endregion
         }
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this in SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => Count<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
@@ -227,13 +184,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, T
             where TPredicate : struct, IFunction<TResult, bool>
             => Count<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => Count<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueReadOnlyList.cs
similarity index 81%
rename from NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueReadOnlyList.cs
index 67ee2408c..9966ada5c 100644
--- a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ValueReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/Select/Select.ValueReadOnlyList.cs
@@ -11,7 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyListExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, TResult> selector)
             where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
@@ -25,7 +24,6 @@ public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSele
             where TSelector : struct, IFunction<TSource, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
             : IValueReadOnlyList<TResult, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -160,38 +158,17 @@ public void Dispose()
 
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => ValueReadOnlyListExtensions.Select<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, FunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-                => SelectAt<TResult2, FunctionWrapper<TResult, int, TResult2>>(new FunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => ValueReadOnlyListExtensions.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
@@ -230,20 +207,6 @@ public readonly List<TResult> ToList()
            
             #endregion
         }
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this in SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source)
-            where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
@@ -253,13 +216,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, T
             where TPredicate : struct, IFunction<TResult, bool>
             => ValueReadOnlyCollectionExtensions.Count<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/SelectEnumerator.cs b/NetFabric.Hyperlinq.Core/Projection/Select/Select/SelectEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Projection/Select/Select/SelectEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/Select/SelectEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ArraySegment.cs
similarity index 81%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ArraySegment.cs
index 8c531f0d7..8a86230a4 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ArraySegment.cs
@@ -10,7 +10,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, TResult>")]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ArraySegmentSelectAtEnumerable<TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TSource, TResult>(this in ArraySegment<TSource> source, Func<TSource, int, TResult> selector)
             => source.SelectAt<TSource, TResult, FunctionWrapper<TSource, int, TResult>>(new FunctionWrapper<TSource, int, TResult>(selector));
@@ -20,7 +20,6 @@ static ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> SelectAt<TSou
             where TSelector : struct, IFunction<TSource, int, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>
             : IValueReadOnlyList<TResult, ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>.Enumerator>
@@ -85,7 +84,7 @@ void ICollection<TResult>.Add(TResult item)
             void ICollection<TResult>.Clear()
                 => Throw.NotSupportedException();
             public bool Contains(TResult item)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ContainsAt(item, default, selector);
+                => source.AsReadOnlySpan().ContainsAt(item, default, selector);
             bool ICollection<TResult>.Remove(TResult item)
                 => Throw.NotSupportedException<bool>();
             int IList<TResult>.IndexOf(TResult item)
@@ -175,40 +174,27 @@ public ArraySegmentSelectAtEnumerable<TSource, TResult2, SelectorAtSelectorAtCom
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => source.SelectAt<TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> ElementAt(int index)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ElementAtAt<TSource, TResult, TSelector>(index, selector);
+                => source.AsReadOnlySpan().ElementAtAt<TSource, TResult, TSelector>(index, selector);
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> First()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).FirstAt<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().FirstAt<TSource, TResult, TSelector>(selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Option<TResult> Single()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).SingleAt<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().SingleAt<TSource, TResult, TSelector>(selector);
             
             #endregion
             #region Conversion
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public TResult[] ToArray()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToArrayAt<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().ToArrayAt<TSource, TResult, TSelector>(selector);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = default)
@@ -216,32 +202,17 @@ public Lease<TResult> ToArray(ArrayPool<TResult> pool, bool clearOnDispose = def
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public List<TResult> ToList()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToListAt<TSource, TResult, TSelector>(selector);
+                => source.AsReadOnlySpan().ToListAt<TSource, TResult, TSelector>(selector);
             
             #endregion
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TSource, TResult, TSelector, TPredicate>(this ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, int, TResult>
             where TPredicate : struct, IFunction<TResult, bool>
             => ValueReadOnlyCollectionExtensions.Count<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>, ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TSource, TResult, TSelector, TPredicate>(this ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, int, TResult>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.AsyncValueEnumerable.cs
similarity index 92%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.AsyncValueEnumerable.cs
index f299225a0..d4b1152cd 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.AsyncValueEnumerable.cs
@@ -12,13 +12,6 @@ namespace NetFabric.Hyperlinq
     public static partial class AsyncValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.AsyncFunctionWrapper<TSource, int, TResult>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, AsyncFunctionWrapper<TSource, int, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, int, CancellationToken, ValueTask<TResult>> selector)
-            where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IAsyncEnumerator<TSource>
-            => source.SelectAt<TEnumerable, TEnumerator, TSource, TResult, AsyncFunctionWrapper<TSource, int, TResult>>(new AsyncFunctionWrapper<TSource, int, TResult>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> SelectAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
@@ -26,7 +19,6 @@ public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSe
             where TSelector : struct, IAsyncFunction<TSource, int, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
             : IAsyncValueEnumerable<TResult, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -218,20 +210,12 @@ public ValueTask<bool> AnyAsync(CancellationToken cancellationToken = default)
             
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorAtSelectorCombination<TSelector, AsyncFunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, CancellationToken, ValueTask<TResult2>> selector)
-                => Select<TResult2, AsyncFunctionWrapper<TResult, TResult2>>(new AsyncFunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IAsyncFunction<TResult, TResult2>
                 => source.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new AsyncSelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorAtSelectorAtCombination<TSelector, AsyncFunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, CancellationToken, ValueTask<TResult2>> selector)
-                => SelectAt<TResult2, AsyncFunctionWrapper<TResult, int, TResult2>>(new AsyncFunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, AsyncSelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IAsyncFunction<TResult, int, TResult2>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ReadOnlyMemory.cs
similarity index 83%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ReadOnlyMemory.cs
index 74f31826f..b67c20fec 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ReadOnlyMemory.cs
@@ -11,7 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static MemorySelectAtEnumerable<TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TSource, TResult>(this ReadOnlyMemory<TSource> source, Func<TSource, int, TResult> selector)
             => source.SelectAt<TSource, TResult, FunctionWrapper<TSource, int, TResult>>(new FunctionWrapper<TSource, int, TResult>(selector));
@@ -21,7 +20,6 @@ static MemorySelectAtEnumerable<TSource, TResult, TSelector> SelectAt<TSource, T
             where TSelector : struct, IFunction<TSource, int, TResult>
             => new(source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct MemorySelectAtEnumerable<TSource, TResult, TSelector>
             : IValueReadOnlyList<TResult, MemorySelectAtEnumerable<TSource, TResult, TSelector>.Enumerator>
@@ -163,19 +161,6 @@ public MemorySelectAtEnumerable<TSource, TResult2, SelectorAtSelectorAtCombinati
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => source.SelectAt<TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<MemorySelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<MemorySelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<MemorySelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<MemorySelectAtEnumerable<TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
@@ -207,27 +192,12 @@ public List<TResult> ToList()
             #endregion
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this MemorySelectAtEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this MemorySelectAtEnumerable<TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<MemorySelectAtEnumerable<TSource, TResult, TSelector>, MemorySelectAtEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TSource, TResult, TSelector, TPredicate>(this MemorySelectAtEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, int, TResult>
             where TPredicate : struct, IFunction<TResult, bool>
             => source.Count(predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this MemorySelectAtEnumerable<TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<MemorySelectAtEnumerable<TSource, TResult, TSelector>, MemorySelectAtEnumerable<TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TSource, TResult, TSelector, TPredicate>(this MemorySelectAtEnumerable<TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TSelector : struct, IFunction<TSource, int, TResult>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ReadOnlySpan.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ReadOnlySpan.cs
index dc30405c3..77490c8b0 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ReadOnlySpan.cs
@@ -9,7 +9,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanSelectAtEnumerable<TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TSource, TResult>(this ReadOnlySpan<TSource> source, Func<TSource, int, TResult> selector)
             => source.SelectAt<TSource, TResult, FunctionWrapper<TSource, int, TResult>>(new FunctionWrapper<TSource, int, TResult>(selector));
@@ -19,7 +18,6 @@ static SpanSelectAtEnumerable<TSource, TResult, TSelector> SelectAt<TSource, TRe
             where TSelector : struct, IFunction<TSource, int, TResult>
             => new(source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public ref struct SpanSelectAtEnumerable<TSource, TResult, TSelector>
             where TSelector : struct, IFunction<TSource, int, TResult>
@@ -132,11 +130,6 @@ public bool SequenceEqual(IEnumerable<TResult> other, IEqualityComparer<TResult>
             }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TResult, TSelector>(this SpanSelectAtEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => source.Count;
-
         // [MethodImpl(MethodImplOptions.AggressiveInlining)]
         // public static int Count<TSource, TResult, TSelector>(this SpanSelectAtEnumerable<TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
         //     where TSelector : struct, IFunction<TSource, int, TResult>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueEnumerable.cs
similarity index 86%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueEnumerable.cs
index 524d6dc67..6ce156e76 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueEnumerable.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, TResult>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, int, TResult> selector)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.SelectAt<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, int, TResult>>(new FunctionWrapper<TSource, int, TResult>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> SelectAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -25,7 +18,6 @@ public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSe
             where TSelector : struct, IFunction<TSource, int, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> 
             : IValueEnumerable<TResult, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -116,31 +108,17 @@ public bool Any()
             
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => source.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, FunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-                => SelectAt<TResult2, FunctionWrapper<TResult, int, TResult2>>(new FunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => source.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(new SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectManyEnumerable<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectManyEnumerable<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
                 where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueReadOnlyCollection.cs
similarity index 78%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueReadOnlyCollection.cs
index cfd0e6ca8..98f68523f 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueReadOnlyCollection.cs
@@ -11,13 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyCollectionExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, TResult>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, int, TResult> selector)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => SelectAt<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, int, TResult>>(source, new FunctionWrapper<TSource, int, TResult>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> SelectAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -25,7 +18,6 @@ public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSe
             where TSelector : struct, IFunction<TSource, int, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
             : IValueReadOnlyCollection<TResult, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -149,38 +141,17 @@ public bool Any()
             
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => ValueReadOnlyCollectionExtensions.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, FunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-                => SelectAt<TResult2, FunctionWrapper<TResult, int, TResult2>>(new FunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => ValueReadOnlyCollectionExtensions.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
@@ -213,20 +184,6 @@ public List<TResult> ToList()
             
             #endregion
         }
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this in SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => Count<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
@@ -236,13 +193,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, T
             where TPredicate : struct, IFunction<TResult, bool>
             => Count<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => Count<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueReadOnlyList.cs
similarity index 81%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueReadOnlyList.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueReadOnlyList.cs
index 6c8435ce8..9d270ce69 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ValueReadOnlyList.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAt.ValueReadOnlyList.cs
@@ -11,7 +11,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueReadOnlyListExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, int, TResult>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, int, TResult> selector)
             where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
@@ -25,7 +24,6 @@ public static SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSe
             where TSelector : struct, IFunction<TSource, int, TResult>
             => new(in source, selector);
 
-        [GeneratorMapping("TSource", "TResult")]
         [StructLayout(LayoutKind.Auto)]
         public partial struct SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
             : IValueReadOnlyList<TResult, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator>
@@ -176,38 +174,17 @@ public void Dispose()
 
             #endregion
             #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<TResult2, FunctionWrapper<TResult, TResult2>>(new FunctionWrapper<TResult, TResult2>(selector));
             
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public readonly SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
                 => ValueReadOnlyListExtensions.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorAtSelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
             
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, FunctionWrapper<TResult, int, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-                => SelectAt<TResult2, FunctionWrapper<TResult, int, TResult2>>(new FunctionWrapper<TResult, int, TResult2>(selector));
-            
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public readonly SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
                 => ValueReadOnlyListExtensions.SelectAt<TEnumerable, TEnumerator, TSource, TResult2, SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorAtSelectorAtCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, FunctionWrapper<TResult, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult2>(Func<TResult, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                => this.SelectMany<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerableExtensions.SelectManyEnumerable<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2> SelectMany<TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(TSelector2 selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult2, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult2>
-                where TSelector2 : struct, IFunction<TResult, TSubEnumerable>
-                => this.SelectMany<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, Enumerator, TResult, TSubEnumerable, TSubEnumerator, TResult2, TSelector2>(selector);
-
             #endregion
             #region Element
 
@@ -247,20 +224,6 @@ public readonly List<TResult> ToList()
             #endregion
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this in SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source)
-            where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, bool> predicate)
-            where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
@@ -269,13 +232,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector, T
             where TPredicate : struct, IFunction<TResult, bool>
             => ValueReadOnlyCollectionExtensions.Count<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult, TPredicate>(source, predicate);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, Func<TResult, int, bool> predicate)
-            where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, int, TResult>
-            => ValueReadOnlyCollectionExtensions.Count<SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.Enumerator, TResult>(source, predicate);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int CountAt<TEnumerable, TEnumerator, TSource, TResult, TSelector, TPredicate>(this SelectAtEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> source, TPredicate predicate = default)
             where TEnumerable : struct, IValueReadOnlyList<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAtEnumerator.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAtEnumerator.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAtEnumerator.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectAt/SelectAtEnumerator.cs
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectVector/SelectVector.Range.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectVector/SelectVector.Range.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Projection/Select/SelectVector/SelectVector.Range.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectVector/SelectVector.Range.cs
index db1b3deda..9da26df94 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectVector/SelectVector.Range.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectVector/SelectVector.Range.cs
@@ -30,7 +30,7 @@ static RangeSelectVectorContext<TResult, TVectorSelector, TSelector> SelectVecto
             where TResult : struct
             => new(start, count, vectorSelector, selector);
 
-        [GeneratorIgnore]
+
         [StructLayout(LayoutKind.Auto)]
         public partial struct RangeSelectVectorContext<TResult, TVectorSelector, TSelector>
             where TVectorSelector : struct, IFunction<Vector<int>, Vector<TResult>>
diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectVector/SelectVector.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Projection/Select/SelectVector/SelectVector.ReadOnlySpan.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Projection/Select/SelectVector/SelectVector.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Projection/Select/SelectVector/SelectVector.ReadOnlySpan.cs
index a3a7aee03..63532d693 100644
--- a/NetFabric.Hyperlinq/Projection/Select/SelectVector/SelectVector.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/Select/SelectVector/SelectVector.ReadOnlySpan.cs
@@ -10,14 +10,12 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore(true)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanSelectVectorContext<TSource, TResult, FunctionWrapper<Vector<TSource>, Vector<TResult>>, FunctionWrapper<TSource, TResult>> SelectVector<TSource, TResult>(this ReadOnlySpan<TSource> source, Func<Vector<TSource>, Vector<TResult>> vectorSelector, Func<TSource, TResult> selector)
             where TSource : struct
             where TResult : struct
             => source.SelectVector<TSource, TResult, FunctionWrapper<Vector<TSource>, Vector<TResult>>, FunctionWrapper<TSource, TResult>>(new FunctionWrapper<Vector<TSource>, Vector<TResult>>(vectorSelector), new FunctionWrapper<TSource, TResult>(selector));
 
-        [GeneratorIgnore(true)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanSelectVectorContext<TSource, TResult, TSelector, TSelector> SelectVector<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TSelector selector = default)
             where TSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ArraySegment.cs
similarity index 88%
rename from NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ArraySegment.cs
index 0bd25b721..0ff7c776a 100644
--- a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ArraySegment.cs
@@ -9,7 +9,6 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ArrayExtensions
     {
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TSubEnumerable>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>> SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult>(this in ArraySegment<TSource> source, Func<TSource, TSubEnumerable> selector)
             where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
@@ -23,7 +22,7 @@ static ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator,
             where TSelector : struct, IFunction<TSource, TSubEnumerable>
             => new(source, selector);
 
-        [GeneratorIgnore]
+
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>
             : IValueEnumerable<TResult, ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>.Enumerator>
@@ -131,19 +130,11 @@ public int Count()
             public bool Any()
                 => this.Any<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>();
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any<TPredicate>(Func<TResult, bool> predicate)
-                => this.Any<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate>(TPredicate predicate = default)
                 where TPredicate : struct, IFunction<TResult, bool>
                 => this.Any<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any<TPredicate>(Func<TResult, int, bool> predicate)
-                => this.Any<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate>(TPredicate predicate = default)
                 where TPredicate : struct, IFunction<TResult, int, bool>
@@ -152,19 +143,11 @@ public bool AnyAt<TPredicate>(TPredicate predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereAtEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-            => ValueEnumerableExtensions.Where<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereAtEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate> WhereAt<TPredicate>(TPredicate predicate = default)
             where TPredicate : struct, IFunction<TResult, int, bool>
                 => ValueEnumerableExtensions.WhereAt<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate>(this, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => ValueEnumerableExtensions.Where<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate> Where<TPredicate>(TPredicate predicate = default)
             where TPredicate : struct, IFunction<TResult, bool>
@@ -173,19 +156,11 @@ public ValueEnumerableExtensions.WhereEnumerable<ArraySegmentSelectManyEnumerabl
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, FunctionWrapper<TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-            => ValueEnumerableExtensions.Select<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
             => ValueEnumerableExtensions.Select<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2>(this, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectAtEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, FunctionWrapper<TResult, int, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-            => ValueEnumerableExtensions.Select<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectAtEnumerable<ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
diff --git a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ReadOnlyMemory.cs
similarity index 88%
rename from NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ReadOnlyMemory.cs
index 5fa18194b..fa71360ee 100644
--- a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ReadOnlyMemory.cs
@@ -10,7 +10,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TSubEnumerable>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>> SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult>(this in ReadOnlyMemory<TSource> source, Func<TSource, TSubEnumerable> selector)
             where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
@@ -24,7 +23,7 @@ static MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResu
             where TSelector : struct, IFunction<TSource, TSubEnumerable>
             => new(source, selector);
 
-        [GeneratorIgnore]
+
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>
             : IValueEnumerable<TResult, MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>.Enumerator>
@@ -130,19 +129,11 @@ public int Count()
             public bool Any()
                 => this.Any<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>();
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any<TPredicate>(Func<TResult, bool> predicate)
-                => this.Any<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate>(TPredicate predicate = default)
                 where TPredicate : struct, IFunction<TResult, bool>
                 => this.Any<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any<TPredicate>(Func<TResult, int, bool> predicate)
-                => this.Any<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate>(TPredicate predicate = default)
                 where TPredicate : struct, IFunction<TResult, int, bool>
@@ -151,19 +142,11 @@ public bool AnyAt<TPredicate>(TPredicate predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereAtEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-            => ValueEnumerableExtensions.Where<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereAtEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate> WhereAt<TPredicate>(TPredicate predicate = default)
             where TPredicate : struct, IFunction<TResult, int, bool>
                 => ValueEnumerableExtensions.WhereAt<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate>(this, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.WhereEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => ValueEnumerableExtensions.Where<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.WhereEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate> Where<TPredicate>(TPredicate predicate = default)
             where TPredicate : struct, IFunction<TResult, bool>
@@ -172,19 +155,11 @@ public ValueEnumerableExtensions.WhereEnumerable<MemorySelectManyEnumerable<TSou
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, FunctionWrapper<TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-            => ValueEnumerableExtensions.Select<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
             => ValueEnumerableExtensions.Select<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2>(this, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.SelectAtEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, FunctionWrapper<TResult, int, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-            => ValueEnumerableExtensions.Select<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public ValueEnumerableExtensions.SelectAtEnumerable<MemorySelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
diff --git a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ReadOnlySpan.cs
similarity index 99%
rename from NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ReadOnlySpan.cs
index 6f7bff87a..32ba6343b 100644
--- a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ReadOnlySpan.cs
@@ -9,7 +9,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TSubEnumerable>")]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static SpanSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>> SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult>(this ReadOnlySpan<TSource> source, Func<TSource, TSubEnumerable> selector)
             where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
@@ -23,7 +22,7 @@ static SpanSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult
             where TSelector : struct, IFunction<TSource, TSubEnumerable>
             => new(source, selector);
 
-        [GeneratorIgnore]
+
         [StructLayout(LayoutKind.Auto)]
         public readonly ref struct SpanSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>
             where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
diff --git a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueEnumerable.cs
similarity index 86%
rename from NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueEnumerable.cs
index bc5c33140..b07960280 100644
--- a/NetFabric.Hyperlinq/Projection/SelectMany/SelectMany/SelectMany.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueEnumerable.cs
@@ -10,15 +10,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TSubEnumerable>")]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>> SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult>(this TEnumerable source, Func<TSource, TSubEnumerable> selector)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
-            where TSubEnumerator : struct, IEnumerator<TResult>
-            => source.SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>>(new FunctionWrapper<TSource, TSubEnumerable>(selector));
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector> SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
@@ -28,7 +19,7 @@ public static SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumer
             where TSelector : struct, IFunction<TSource, TSubEnumerable>
             => new(source, selector);
 
-        [GeneratorIgnore]
+
         [StructLayout(LayoutKind.Auto)]
         public readonly partial struct SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>
             : IValueEnumerable<TResult, SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>.Enumerator>
@@ -132,19 +123,11 @@ public int Count()
             public bool Any()
                 => this.Any<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>();
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TResult, bool> predicate)
-                => this.Any<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool Any<TPredicate>(TPredicate predicate = default)
                 where TPredicate : struct, IFunction<TResult, bool>
                 => this.Any<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate>(predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TResult, int, bool> predicate)
-                => this.Any<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool AnyAt<TPredicate>(TPredicate predicate = default)
                 where TPredicate : struct, IFunction<TResult, int, bool>
@@ -153,19 +136,11 @@ public bool AnyAt<TPredicate>(TPredicate predicate = default)
             #endregion
             #region Filtering
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereAtEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, int, bool>> Where(Func<TResult, int, bool> predicate)
-            => ValueEnumerableExtensions.Where<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereAtEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate> WhereAt<TPredicate>(TPredicate predicate = default)
             where TPredicate : struct, IFunction<TResult, int, bool>
                 => ValueEnumerableExtensions.WhereAt<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate>(this, predicate);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public WhereEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, FunctionWrapper<TResult, bool>> Where(Func<TResult, bool> predicate)
-                => ValueEnumerableExtensions.Where<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult>(this, predicate);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public WhereEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TPredicate> Where<TPredicate>(TPredicate predicate = default)
             where TPredicate : struct, IFunction<TResult, bool>
@@ -174,19 +149,11 @@ public WhereEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, T
             #endregion
             #region Projection
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, FunctionWrapper<TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-            => ValueEnumerableExtensions.Select<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2> Select<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, TResult2>
             => ValueEnumerableExtensions.Select<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2>(this, selector);
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SelectAtEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, FunctionWrapper<TResult, int, TResult2>> Select<TResult2>(Func<TResult, int, TResult2> selector)
-            => ValueEnumerableExtensions.Select<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2>(this, selector);
-
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public SelectAtEnumerable<SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>, Enumerator, TResult, TResult2, TSelector2> SelectAt<TResult2, TSelector2>(TSelector2 selector = default)
                 where TSelector2 : struct, IFunction<TResult, int, TResult2>
diff --git a/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueReadOnlyCollection.cs
new file mode 100644
index 000000000..b171a53c8
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueReadOnlyCollection.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadonlyCollectionExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueEnumerableExtensions.SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector> SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
+            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
+            where TSubEnumerator : struct, IEnumerator<TResult>
+            where TSelector : struct, IFunction<TSource, TSubEnumerable>
+            => ValueEnumerableExtensions.SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(source, selector);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueReadOnlyList.cs
new file mode 100644
index 000000000..2425f25bb
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Projection/SelectMany/SelectMany/SelectMany.ValueReadOnlyList.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadonlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueEnumerableExtensions.SelectManyEnumerable<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector> SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
+            where TSubEnumerator : struct, IEnumerator<TResult>
+            where TSelector : struct, IFunction<TSource, TSubEnumerable>
+            => ValueEnumerableExtensions.SelectMany<TEnumerable, TEnumerator, TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(source, selector);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.Core/Properties/AssemblyInfo.cs b/NetFabric.Hyperlinq.Core/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..c1bd8a3cf
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Properties/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly:InternalsVisibleTo("NetFabric.Hyperlinq.Core.UnitTests")]
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Quantifier/All/All.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ReadOnlySpan.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Quantifier/All/All.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/All/All.ReadOnlySpan.cs
diff --git a/NetFabric.Hyperlinq/Quantifier/All/All.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueEnumerable.cs
similarity index 61%
rename from NetFabric.Hyperlinq/Quantifier/All/All.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueEnumerable.cs
index a43bc4eeb..356f3c912 100644
--- a/NetFabric.Hyperlinq/Quantifier/All/All.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueEnumerable.cs
@@ -7,12 +7,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
         
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool All<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.All<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-        
         public static bool All<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -26,13 +20,6 @@ public static bool All<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnum
             }
             return true;
         }
-
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool All<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.AllAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(new FunctionWrapper<TSource, int, bool>(predicate));
         
         public static bool AllAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq/Quantifier/All/All.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueReadOnlyCollection.cs
similarity index 57%
rename from NetFabric.Hyperlinq/Quantifier/All/All.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueReadOnlyCollection.cs
index 7eb86823a..b1abcc6b7 100644
--- a/NetFabric.Hyperlinq/Quantifier/All/All.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueReadOnlyCollection.cs
@@ -6,12 +6,6 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class ValueReadOnlyCollectionExtensions
     {
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool All<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => All<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(source, new FunctionWrapper<TSource, bool>(predicate));
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool All<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
@@ -19,12 +13,6 @@ public static bool All<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnum
             where TEnumerator : struct, IEnumerator<TSource>
             where TPredicate : struct, IFunction<TSource, bool>
             => source.Count is 0 || ValueEnumerableExtensions.All<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool All<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AllAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(source, new FunctionWrapper<TSource, int, bool>(predicate));
         
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool AllAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
diff --git a/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueReadOnlyList.cs
new file mode 100644
index 000000000..d94386393
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Quantifier/All/All.ValueReadOnlyList.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool All<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate : struct, IFunction<TSource, bool>
+            => ValueReadOnlyCollectionExtensions.All<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool AllAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate : struct, IFunction<TSource, int, bool>
+            => ValueReadOnlyCollectionExtensions.AllAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Quantifier/All/AllAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/All/AllAsync.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Quantifier/All/AllAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/All/AllAsync.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Quantifier/Any/Any.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ReadOnlySpan.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Quantifier/Any/Any.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ReadOnlySpan.cs
diff --git a/NetFabric.Hyperlinq/Quantifier/Any/Any.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueEnumerable.cs
similarity index 66%
rename from NetFabric.Hyperlinq/Quantifier/Any/Any.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueEnumerable.cs
index 6cfd4c202..985603f09 100644
--- a/NetFabric.Hyperlinq/Quantifier/Any/Any.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueEnumerable.cs
@@ -15,12 +15,6 @@ public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable sourc
             return enumerator.MoveNext();
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Any<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-
         public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -35,12 +29,6 @@ public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnum
             return false;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.AnyAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(new FunctionWrapper<TSource, int, bool>(predicate));
-
         public static bool AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueReadOnlyCollection.cs
similarity index 78%
rename from NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueReadOnlyCollection.cs
index 49d4c1145..5dad306eb 100644
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueReadOnlyCollection.cs
@@ -14,17 +14,18 @@ public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable sourc
             => source.Count is not 0;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
+        public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
-            => Any<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(source, new FunctionWrapper<TSource, bool>(predicate));
+            where TPredicate : struct, IFunction<TSource, bool>
+            => source.Count is not 0 && ValueEnumerableExtensions.Any<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+        public static bool AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count is not 0 && ValueEnumerableExtensions.Any<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+            where TPredicate : struct, IFunction<TSource, int, bool>
+            => source.Count is not 0 && ValueEnumerableExtensions.AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
     }
 }
 
diff --git a/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueReadOnlyList.cs
new file mode 100644
index 000000000..d2df510ab
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Any/Any.ValueReadOnlyList.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Any<TEnumerable, TEnumerator, TSource>(source);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate : struct, IFunction<TSource, bool>
+            => ValueReadOnlyCollectionExtensions.Any<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            where TPredicate : struct, IFunction<TSource, int, bool>
+            => ValueReadOnlyCollectionExtensions.AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Quantifier/Any/AnyAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/Any/AnyAsync.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Quantifier/Any/AnyAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Any/AnyAsync.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.Enumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.Enumerable.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Quantifier/Contains/Contains.Enumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.Enumerable.cs
index 0d061f9d6..052400a66 100644
--- a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.Enumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.Enumerable.cs
@@ -4,7 +4,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class EnumerableExtensions
     {
-        [GeneratorIgnore]
+
         internal static bool Contains<TEnumerable, TSource>(this TEnumerable source, TSource value, IEqualityComparer<TSource>? comparer = default)
             where TEnumerable : IEnumerable<TSource>
         {
@@ -44,7 +44,7 @@ static bool ComparerContains(TEnumerable source, TSource value, IEqualityCompare
             }
         }
 
-        [GeneratorIgnore]
+
         internal static bool Contains<TEnumerable, TEnumerator, TSource, TEnumeratorGenerator>(this TEnumerable source, TEnumeratorGenerator getEnumerator, TSource value, IEqualityComparer<TSource>? comparer = default)
             where TEnumerable : IEnumerable<TSource>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ReadOnlySpan.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Quantifier/Contains/Contains.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ReadOnlySpan.cs
index 767f1619b..67fcb78d4 100644
--- a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ReadOnlySpan.cs
@@ -37,7 +37,7 @@ static bool ReferenceContains(ReadOnlySpan<TSource> source, TSource value, IEqua
             }
         }
 
-        [GeneratorIgnore]
+
         static bool Contains<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TResult value, IEqualityComparer<TResult>? comparer, TSelector selector)
             where TSelector : struct, IFunction<TSource, TResult>
         {
@@ -71,7 +71,7 @@ static bool ReferenceContains(ReadOnlySpan<TSource> source, TResult value, IEqua
             }
         }
 
-        [GeneratorIgnore]
+
         static bool ContainsAt<TSource, TResult, TSelector>(this ReadOnlySpan<TSource> source, TResult value, IEqualityComparer<TResult>? comparer, TSelector selector)
             where TSelector : struct, IFunction<TSource, int, TResult>
         {
diff --git a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueEnumerable.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Quantifier/Contains/Contains.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueEnumerable.cs
index 6f5605ad9..0540ec1b5 100644
--- a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueEnumerable.cs
@@ -45,7 +45,7 @@ static bool ComparerContains(TEnumerable source, TSource value, IEqualityCompare
         }
 
 
-        [GeneratorIgnore]
+
         internal static bool Contains<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TResult value, IEqualityComparer<TResult>? comparer, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -80,7 +80,7 @@ static bool ReferenceContains(TEnumerable source, TResult value, IEqualityCompar
             }
         }
 
-        [GeneratorIgnore]
+
         internal static bool ContainsAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TResult value, IEqualityComparer<TResult>? comparer, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueReadOnlyCollection.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Quantifier/Contains/Contains.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueReadOnlyCollection.cs
index 080b9a4f3..4c4e1e62e 100644
--- a/NetFabric.Hyperlinq/Quantifier/Contains/Contains.ValueReadOnlyCollection.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueReadOnlyCollection.cs
@@ -11,7 +11,7 @@ public static bool Contains<TEnumerable, TEnumerator, TSource>(this TEnumerable
             where TEnumerator : struct, IEnumerator<TSource>
             => source.Count is not 0 && ValueEnumerableExtensions.Contains<TEnumerable, TEnumerator, TSource>(source, value, comparer);
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static bool Contains<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TResult value, IEqualityComparer<TResult>? comparer, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
@@ -19,7 +19,7 @@ internal static bool Contains<TEnumerable, TEnumerator, TSource, TResult, TSelec
             where TSelector : struct, IFunction<TSource, TResult>
             => source.Count is not 0 && ValueEnumerableExtensions.Contains<TEnumerable, TEnumerator, TSource, TResult, TSelector>(source, value, comparer, selector);
 
-        [GeneratorIgnore]
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static bool ContainsAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TResult value, IEqualityComparer<TResult>? comparer, TSelector selector)
             where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
diff --git a/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueReadOnlyList.cs
new file mode 100644
index 000000000..fd94cdc4d
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Quantifier/Contains/Contains.ValueReadOnlyList.cs
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool Contains<TEnumerable, TEnumerator, TSource>(this TEnumerable source, TSource value, IEqualityComparer<TSource>? comparer = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Contains<TEnumerable, TEnumerator, TSource>(source, value, comparer);
+    }
+}
diff --git a/NetFabric.Hyperlinq/Quantifier/Contains/ContainsAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Quantifier/Contains/ContainsAsync.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Quantifier/Contains/ContainsAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/Contains/ContainsAsync.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.cs
similarity index 98%
rename from NetFabric.Hyperlinq/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.cs
index 516503ef2..11c7e6beb 100644
--- a/NetFabric.Hyperlinq/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/ContainsVector/ContainsVector.ReadOnlySpan.cs
@@ -34,7 +34,7 @@ static bool ContainsVector<TSource>(this ReadOnlySpan<TSource> source, TSource v
             return false;
         }
 
-        [GeneratorIgnore]
+
         static bool ContainsVector<TSource, TResult, TVectorSelector, TSelector>(this ReadOnlySpan<TSource> source, TResult value, TVectorSelector vectorSelector, TSelector selector)
             where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
             where TSelector : struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Quantifier/ContainsVector/ContainsVector.Span.cs b/NetFabric.Hyperlinq.Core/Quantifier/ContainsVector/ContainsVector.Span.cs
similarity index 82%
rename from NetFabric.Hyperlinq/Quantifier/ContainsVector/ContainsVector.Span.cs
rename to NetFabric.Hyperlinq.Core/Quantifier/ContainsVector/ContainsVector.Span.cs
index 9dbfc7401..0bfe618fe 100644
--- a/NetFabric.Hyperlinq/Quantifier/ContainsVector/ContainsVector.Span.cs
+++ b/NetFabric.Hyperlinq.Core/Quantifier/ContainsVector/ContainsVector.Span.cs
@@ -9,7 +9,7 @@ public static partial class ArrayExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static bool ContainsVector<TSource>(this Span<TSource> source, TSource value)
             where TSource : struct
-            => ((ReadOnlySpan<TSource>)source).ContainsVector(value);
+            => source.AsReadOnlySpan().ContainsVector(value);
 
     }
 }
diff --git a/NetFabric.Hyperlinq.Core/Resource.Designer.cs b/NetFabric.Hyperlinq.Core/Resource.Designer.cs
new file mode 100644
index 000000000..ff4ee5dc4
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Resource.Designer.cs
@@ -0,0 +1,72 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace NetFabric.Hyperlinq {
+    using System;
+    
+    
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resource {
+        
+        private static System.Resources.ResourceManager resourceMan;
+        
+        private static System.Globalization.CultureInfo resourceCulture;
+        
+        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resource() {
+        }
+        
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.Equals(null, resourceMan)) {
+                    System.Resources.ResourceManager temp = new System.Resources.ResourceManager("NetFabric.Hyperlinq.Resource", typeof(Resource).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        internal static string ArraySegmentNull {
+            get {
+                return ResourceManager.GetString("ArraySegmentNull", resourceCulture);
+            }
+        }
+        
+        internal static string DestinationNotLongEnough {
+            get {
+                return ResourceManager.GetString("DestinationNotLongEnough", resourceCulture);
+            }
+        }
+        
+        internal static string EmptySequence {
+            get {
+                return ResourceManager.GetString("EmptySequence", resourceCulture);
+            }
+        }
+        
+        internal static string NotSingleSequence {
+            get {
+                return ResourceManager.GetString("NotSingleSequence", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.Core/Resource.resx b/NetFabric.Hyperlinq.Core/Resource.resx
new file mode 100644
index 000000000..05b1efb3f
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Resource.resx
@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ArraySegmentNull" xml:space="preserve">
+    <value>The array in the ArraySegment is null</value>
+  </data>
+  <data name="DestinationNotLongEnough" xml:space="preserve">
+    <value>Destination array was not long enough. Check the destination index, length, and the array's lower bounds.</value>
+  </data>
+  <data name="EmptySequence" xml:space="preserve">
+    <value>Sequence contains no elements</value>
+  </data>
+  <data name="NotSingleSequence" xml:space="preserve">
+    <value>Sequence contains more than one element</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ArraySegment.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ArraySegment.cs
similarity index 58%
rename from NetFabric.Hyperlinq/Set/Distinct/Distinct.ArraySegment.cs
rename to NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ArraySegment.cs
index 8a2511cfc..ffbe3f74b 100644
--- a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ArraySegment.cs
+++ b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ArraySegment.cs
@@ -148,62 +148,6 @@ public List<TSource> ToList()
             
             #endregion
         }
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ArraySegmentDistinctEnumerable<int> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<int>, ArraySegmentDistinctEnumerable<int>.Enumerator, int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ArraySegmentDistinctEnumerable<int?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<int?>, ArraySegmentDistinctEnumerable<int?>.Enumerator, int?, int>();
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ArraySegmentDistinctEnumerable<nint> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<nint>, ArraySegmentDistinctEnumerable<nint>.Enumerator, nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ArraySegmentDistinctEnumerable<nint?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<nint?>, ArraySegmentDistinctEnumerable<nint?>.Enumerator, nint?, nint>();
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ArraySegmentDistinctEnumerable<nuint> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<nuint>, ArraySegmentDistinctEnumerable<nuint>.Enumerator, nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ArraySegmentDistinctEnumerable<nuint?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<nuint?>, ArraySegmentDistinctEnumerable<nuint?>.Enumerator, nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ArraySegmentDistinctEnumerable<long> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<long>, ArraySegmentDistinctEnumerable<long>.Enumerator, long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ArraySegmentDistinctEnumerable<long?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<long?>, ArraySegmentDistinctEnumerable<long?>.Enumerator, long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ArraySegmentDistinctEnumerable<float> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<float>, ArraySegmentDistinctEnumerable<float>.Enumerator, float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ArraySegmentDistinctEnumerable<float?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<float?>, ArraySegmentDistinctEnumerable<float?>.Enumerator, float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ArraySegmentDistinctEnumerable<double> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<double>, ArraySegmentDistinctEnumerable<double>.Enumerator, double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ArraySegmentDistinctEnumerable<double?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<double?>, ArraySegmentDistinctEnumerable<double?>.Enumerator, double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ArraySegmentDistinctEnumerable<decimal> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<decimal>, ArraySegmentDistinctEnumerable<decimal>.Enumerator, decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ArraySegmentDistinctEnumerable<decimal?> source)
-            => source.Sum<ArraySegmentDistinctEnumerable<decimal?>, ArraySegmentDistinctEnumerable<decimal?>.Enumerator, decimal?, decimal>();
     }
 }
 
diff --git a/NetFabric.Hyperlinq/Set/Distinct/Distinct.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.AsyncValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Set/Distinct/Distinct.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.AsyncValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ReadOnlyMemory.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ReadOnlyMemory.cs
similarity index 59%
rename from NetFabric.Hyperlinq/Set/Distinct/Distinct.ReadOnlyMemory.cs
rename to NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ReadOnlyMemory.cs
index d028c5864..9a7d0fbd2 100644
--- a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ReadOnlyMemory.cs
+++ b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ReadOnlyMemory.cs
@@ -146,62 +146,6 @@ public List<TSource> ToList()
             
             #endregion
         }
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this MemoryDistinctEnumerable<int> source)
-            => source.Sum<MemoryDistinctEnumerable<int>, MemoryDistinctEnumerable<int>.Enumerator, int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this MemoryDistinctEnumerable<int?> source)
-            => source.Sum<MemoryDistinctEnumerable<int?>, MemoryDistinctEnumerable<int?>.Enumerator, int?, int>();
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this MemoryDistinctEnumerable<nint> source)
-            => source.Sum<MemoryDistinctEnumerable<nint>, MemoryDistinctEnumerable<nint>.Enumerator, nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this MemoryDistinctEnumerable<nint?> source)
-            => source.Sum<MemoryDistinctEnumerable<nint?>, MemoryDistinctEnumerable<nint?>.Enumerator, nint?, nint>();
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this MemoryDistinctEnumerable<nuint> source)
-            => source.Sum<MemoryDistinctEnumerable<nuint>, MemoryDistinctEnumerable<nuint>.Enumerator, nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this MemoryDistinctEnumerable<nuint?> source)
-            => source.Sum<MemoryDistinctEnumerable<nuint?>, MemoryDistinctEnumerable<nuint?>.Enumerator, nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this MemoryDistinctEnumerable<long> source)
-            => source.Sum<MemoryDistinctEnumerable<long>, MemoryDistinctEnumerable<long>.Enumerator, long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this MemoryDistinctEnumerable<long?> source)
-            => source.Sum<MemoryDistinctEnumerable<long?>, MemoryDistinctEnumerable<long?>.Enumerator, long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this MemoryDistinctEnumerable<float> source)
-            => source.Sum<MemoryDistinctEnumerable<float>, MemoryDistinctEnumerable<float>.Enumerator, float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this MemoryDistinctEnumerable<float?> source)
-            => source.Sum<MemoryDistinctEnumerable<float?>, MemoryDistinctEnumerable<float?>.Enumerator, float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this MemoryDistinctEnumerable<double> source)
-            => source.Sum<MemoryDistinctEnumerable<double>, MemoryDistinctEnumerable<double>.Enumerator, double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this MemoryDistinctEnumerable<double?> source)
-            => source.Sum<MemoryDistinctEnumerable<double?>, MemoryDistinctEnumerable<double?>.Enumerator, double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this MemoryDistinctEnumerable<decimal> source)
-            => source.Sum<MemoryDistinctEnumerable<decimal>, MemoryDistinctEnumerable<decimal>.Enumerator, decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this MemoryDistinctEnumerable<decimal?> source)
-            => source.Sum<MemoryDistinctEnumerable<decimal?>, MemoryDistinctEnumerable<decimal?>.Enumerator, decimal?, decimal>();
     }
 }
 
diff --git a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ReadOnlySpan.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Set/Distinct/Distinct.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ReadOnlySpan.cs
diff --git a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueEnumerable.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Set/Distinct/Distinct.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueEnumerable.cs
diff --git a/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueReadOnlyCollection.cs
new file mode 100644
index 000000000..bac8fe6d2
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueReadOnlyCollection.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyCollectionExtensions
+    {
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource> Distinct<TEnumerable, TEnumerator, TSource>(
+            this TEnumerable source, 
+            IEqualityComparer<TSource>? comparer = default)
+            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueEnumerableExtensions.Distinct<TEnumerable, TEnumerator, TSource>(source, comparer);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueReadOnlyList.cs
new file mode 100644
index 000000000..dc8954e86
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Set/Distinct/Distinct.ValueReadOnlyList.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ValueReadOnlyListExtensions
+    {
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource> Distinct<TEnumerable, TEnumerator, TSource>(
+            this TEnumerable source, 
+            IEqualityComparer<TSource>? comparer = default)
+            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
+            where TEnumerator : struct, IEnumerator<TSource>
+            => ValueReadOnlyCollectionExtensions.Distinct<TEnumerable, TEnumerator, TSource>(source, comparer);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq/Set/Distinct/Set.cs b/NetFabric.Hyperlinq.Core/Set/Distinct/Set.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Set/Distinct/Set.cs
rename to NetFabric.Hyperlinq.Core/Set/Distinct/Set.cs
diff --git a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ArrayBuilder.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ArrayBuilder.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/ArrayBuilder/ArrayBuilder.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ArrayBuilder.cs
diff --git a/NetFabric.Hyperlinq/Utils/ArrayBuilder/LargeArrayBuilder.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/LargeArrayBuilder.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/ArrayBuilder/LargeArrayBuilder.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/LargeArrayBuilder.cs
diff --git a/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlyList.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlyList.cs
new file mode 100644
index 000000000..585f4adc3
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlyList.cs
@@ -0,0 +1,70 @@
+using System.Buffers;
+using System.Collections.Generic;
+
+namespace NetFabric.Hyperlinq
+{
+    public static partial class ReadOnlyListExtensions
+    {
+
+
+        static LargeArrayBuilder<TSource> ToArrayBuilder<TList, TSource, TPredicate>(in TList source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate, int offset, int count)
+            where TList : struct, IReadOnlyList<TSource>
+            where TPredicate: struct, IFunction<TSource, bool>
+        {
+            var builder = new LargeArrayBuilder<TSource>(pool, clearOnDispose);
+            var end = offset + count;
+            for (var index = offset; index < end; index++)
+            {
+                var item = source[index];
+                if (predicate.Invoke(item))
+                    builder.Add(item);
+            }
+            return builder;
+        }
+
+
+        static LargeArrayBuilder<TSource> ToArrayBuilderAt<TList, TSource, TPredicate>(in TList source, ArrayPool<TSource> pool, bool clearOnDispose, TPredicate predicate, int offset, int count)
+            where TList : struct, IReadOnlyList<TSource>
+            where TPredicate: struct, IFunction<TSource, int, bool>
+        {
+            var builder = new LargeArrayBuilder<TSource>(pool, clearOnDispose);
+            var end = count;
+            if (offset is 0)
+            {
+                for (var index = 0; index < end; index++)
+                {
+                    var item = source[index];
+                    if (predicate.Invoke(item, index))
+                        builder.Add(item);
+                }
+            }
+            else
+            {
+                for (var index = 0; index < end; index++)
+                {
+                    var item = source[index + offset];
+                    if (predicate.Invoke(item, index))
+                        builder.Add(item);
+                }
+            }
+            return builder;
+        }
+
+
+        static LargeArrayBuilder<TResult> ToArrayBuilder<TList, TSource, TResult, TPredicate, TSelector>(in TList source, ArrayPool<TResult> pool, bool clearOnDispose, TPredicate predicate, TSelector selector, int offset, int count)
+            where TList : struct, IReadOnlyList<TSource>
+            where TSelector: struct, IFunction<TSource, TResult>
+            where TPredicate: struct, IFunction<TSource, bool>
+        {
+            var builder = new LargeArrayBuilder<TResult>(pool, clearOnDispose);
+            var end = offset + count;
+            for (var index = offset; index < end; index++)
+            {
+                var item = source[index];
+                if (predicate.Invoke(item))
+                    builder.Add(selector.Invoke(item));
+            }
+            return builder;
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlySpan.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlySpan.cs
index 4bf675d81..558e23fff 100644
--- a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlySpan.cs
+++ b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ReadOnlySpan.cs
@@ -6,7 +6,7 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TSource> ToArrayBuilder<TSource, TPredicate>(ReadOnlySpan<TSource> source, ArrayPool<TSource> arrayPool, bool clearOnDispose, TPredicate predicate)
             where TPredicate: struct, IFunction<TSource, bool>
         {
@@ -19,7 +19,7 @@ static LargeArrayBuilder<TSource> ToArrayBuilder<TSource, TPredicate>(ReadOnlySp
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TSource> ToArrayBuilderAt<TSource, TPredicate>(ReadOnlySpan<TSource> source, ArrayPool<TSource> arrayPool, bool clearOnDispose, TPredicate predicate)
             where TPredicate: struct, IFunction<TSource, int, bool>
         {
@@ -33,7 +33,7 @@ static LargeArrayBuilder<TSource> ToArrayBuilderAt<TSource, TPredicate>(ReadOnly
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TResult> ToArrayBuilder<TSource, TResult, TPredicate, TSelector>(ReadOnlySpan<TSource> source, ArrayPool<TResult> arrayPool, bool clearOnDispose, TPredicate predicate, TSelector selector)
             where TPredicate: struct, IFunction<TSource, bool>
             where TSelector: struct, IFunction<TSource, TResult>
diff --git a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilder.ValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ValueEnumerable.cs
similarity index 96%
rename from NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilder.ValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ValueEnumerable.cs
index 4729f52c6..c85c6972c 100644
--- a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilder.ValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilder.ValueEnumerable.cs
@@ -6,7 +6,6 @@ namespace NetFabric.Hyperlinq
     public static partial class ValueEnumerableExtensions
     {
 
-        [GeneratorIgnore]
         internal static LargeArrayBuilder<TSource> ToArrayBuilder<TEnumerable, TEnumerator, TSource>(TEnumerable source, ArrayPool<TSource> arrayPool, bool clearOnDispose)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -21,7 +20,7 @@ internal static LargeArrayBuilder<TSource> ToArrayBuilder<TEnumerable, TEnumerat
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TSource> ToArrayBuilder<TEnumerable, TEnumerator, TSource, TPredicate>(TEnumerable source, ArrayPool<TSource> arrayPool, bool clearOnDispose, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -38,7 +37,7 @@ static LargeArrayBuilder<TSource> ToArrayBuilder<TEnumerable, TEnumerator, TSour
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TSource> ToArrayBuilderAt<TEnumerable, TEnumerator, TSource, TPredicate>(TEnumerable source, ArrayPool<TSource> arrayPool, bool clearOnDispose, TPredicate predicate)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -55,7 +54,7 @@ static LargeArrayBuilder<TSource> ToArrayBuilderAt<TEnumerable, TEnumerator, TSo
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TResult> ToArrayBuilder<TEnumerable, TEnumerator, TSource, TResult, TSelector>(TEnumerable source, ArrayPool<TResult> arrayPool, bool clearOnDispose, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -71,7 +70,7 @@ static LargeArrayBuilder<TResult> ToArrayBuilder<TEnumerable, TEnumerator, TSour
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TResult> ToArrayBuilderAt<TEnumerable, TEnumerator, TSource, TResult, TSelector>(TEnumerable source, ArrayPool<TResult> arrayPool, bool clearOnDispose, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -90,7 +89,7 @@ static LargeArrayBuilder<TResult> ToArrayBuilderAt<TEnumerable, TEnumerator, TSo
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static LargeArrayBuilder<TResult> ToArrayBuilder<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(TEnumerable source, ArrayPool<TResult> arrayPool, bool clearOnDispose, TPredicate predicate, TSelector selector)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilderAsync.AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilderAsync.AsyncValueEnumerable.cs
similarity index 97%
rename from NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilderAsync.AsyncValueEnumerable.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilderAsync.AsyncValueEnumerable.cs
index 4faaf8995..f4e6689a5 100644
--- a/NetFabric.Hyperlinq/Utils/ArrayBuilder/ToArrayBuilderAsync.AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Core/Utils/ArrayBuilder/ToArrayBuilderAsync.AsyncValueEnumerable.cs
@@ -7,7 +7,7 @@ namespace NetFabric.Hyperlinq
 {
     public static partial class AsyncValueEnumerableExtensions
     {
-        [GeneratorIgnore]
+
         static async ValueTask<LargeArrayBuilder<TSource>> ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource>(this TEnumerable source, ArrayPool<TSource> arrayPool, bool clearOnDispose, CancellationToken cancellationToken)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -29,7 +29,7 @@ static async ValueTask<LargeArrayBuilder<TSource>> ToArrayBuilderAsync<TEnumerab
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static async ValueTask<LargeArrayBuilder<TSource>> ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> arrayPool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -55,7 +55,7 @@ static async ValueTask<LargeArrayBuilder<TSource>> ToArrayBuilderAsync<TEnumerab
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static async ValueTask<LargeArrayBuilder<TSource>> ToArrayBuilderAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool<TSource> arrayPool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -84,7 +84,7 @@ static async ValueTask<LargeArrayBuilder<TSource>> ToArrayBuilderAtAsync<TEnumer
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static async ValueTask<LargeArrayBuilder<TResult>> ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> arrayPool, bool clearOnDispose, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -108,7 +108,7 @@ static async ValueTask<LargeArrayBuilder<TResult>> ToArrayBuilderAsync<TEnumerab
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static async ValueTask<LargeArrayBuilder<TResult>> ToArrayBuilderAtAsync<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool<TResult> arrayPool, bool clearOnDispose, CancellationToken cancellationToken, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
@@ -135,7 +135,7 @@ static async ValueTask<LargeArrayBuilder<TResult>> ToArrayBuilderAtAsync<TEnumer
             return builder;
         }
 
-        [GeneratorIgnore]
+
         static async ValueTask<LargeArrayBuilder<TResult>> ToArrayBuilderAsync<TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, ArrayPool<TResult> arrayPool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate, TSelector selector)
             where TEnumerable : IAsyncValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IAsyncEnumerator<TSource>
diff --git a/NetFabric.Hyperlinq.Core/Utils/ArrayExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayExtensions.cs
new file mode 100644
index 000000000..bdaa467ae
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Utils/ArrayExtensions.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    static class InternalArrayExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlySpan<T> AsReadOnlySpan<T>(this T[] source)
+            => source;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlyMemory<T> AsReadOnlyMemory<T>(this T[] source)
+            => source;
+    }
+}
diff --git a/NetFabric.Hyperlinq/Utils/ArrayPoolExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/ArrayPoolExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/ArrayPoolExtensions.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArrayPoolExtensions.cs
diff --git a/NetFabric.Hyperlinq/Utils/ArraySegmentExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/ArraySegmentExtensions.cs
similarity index 70%
rename from NetFabric.Hyperlinq/Utils/ArraySegmentExtensions.cs
rename to NetFabric.Hyperlinq.Core/Utils/ArraySegmentExtensions.cs
index 30acec5f6..69fed9d4a 100644
--- a/NetFabric.Hyperlinq/Utils/ArraySegmentExtensions.cs
+++ b/NetFabric.Hyperlinq.Core/Utils/ArraySegmentExtensions.cs
@@ -12,7 +12,10 @@ public static bool IsEmpty<T>(this in ArraySegment<T> source)
         // NOTE: Inner array can only be null if length is zero. Should validate before calling this method.
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool IsWhole<T>(this in ArraySegment<T> source)
-            => source.Count == source.Array!.Length; 
+            => source.Count == source.Array!.Length;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlySpan<T> AsReadOnlySpan<T>(this in ArraySegment<T> source)
+            => source.AsSpan();
     }
 }
diff --git a/NetFabric.Hyperlinq/Utils/BooleanExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/BooleanExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/BooleanExtensions.cs
rename to NetFabric.Hyperlinq.Core/Utils/BooleanExtensions.cs
diff --git a/NetFabric.Hyperlinq/Utils/Copy/Copy.Range.cs b/NetFabric.Hyperlinq.Core/Utils/Copy/Copy.Range.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Copy/Copy.Range.cs
rename to NetFabric.Hyperlinq.Core/Utils/Copy/Copy.Range.cs
diff --git a/NetFabric.Hyperlinq/Utils/Copy/Copy.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Utils/Copy/Copy.ReadOnlySpan.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Copy/Copy.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Utils/Copy/Copy.ReadOnlySpan.cs
diff --git a/NetFabric.Hyperlinq/Utils/Copy/Copy.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Utils/Copy/Copy.ValueReadOnlyCollection.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Copy/Copy.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Utils/Copy/Copy.ValueReadOnlyCollection.cs
diff --git a/NetFabric.Hyperlinq/Utils/Default.cs b/NetFabric.Hyperlinq.Core/Utils/Default.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Default.cs
rename to NetFabric.Hyperlinq.Core/Utils/Default.cs
diff --git a/NetFabric.Hyperlinq/Utils/EnumeratorState.cs b/NetFabric.Hyperlinq.Core/Utils/EnumeratorState.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/EnumeratorState.cs
rename to NetFabric.Hyperlinq.Core/Utils/EnumeratorState.cs
diff --git a/NetFabric.Hyperlinq/Utils/FunctionCombination/AsyncPredicateCombination.cs b/NetFabric.Hyperlinq.Core/Utils/FunctionCombination/AsyncPredicateCombination.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/FunctionCombination/AsyncPredicateCombination.cs
rename to NetFabric.Hyperlinq.Core/Utils/FunctionCombination/AsyncPredicateCombination.cs
diff --git a/NetFabric.Hyperlinq/Utils/FunctionCombination/AsyncSelectorCombination.cs b/NetFabric.Hyperlinq.Core/Utils/FunctionCombination/AsyncSelectorCombination.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/FunctionCombination/AsyncSelectorCombination.cs
rename to NetFabric.Hyperlinq.Core/Utils/FunctionCombination/AsyncSelectorCombination.cs
diff --git a/NetFabric.Hyperlinq/Utils/FunctionCombination/PredicateCombination.cs b/NetFabric.Hyperlinq.Core/Utils/FunctionCombination/PredicateCombination.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/FunctionCombination/PredicateCombination.cs
rename to NetFabric.Hyperlinq.Core/Utils/FunctionCombination/PredicateCombination.cs
diff --git a/NetFabric.Hyperlinq/Utils/FunctionCombination/PredicateInCombination.cs b/NetFabric.Hyperlinq.Core/Utils/FunctionCombination/PredicateInCombination.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/FunctionCombination/PredicateInCombination.cs
rename to NetFabric.Hyperlinq.Core/Utils/FunctionCombination/PredicateInCombination.cs
diff --git a/NetFabric.Hyperlinq/Utils/FunctionCombination/SelectorCombination.cs b/NetFabric.Hyperlinq.Core/Utils/FunctionCombination/SelectorCombination.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/FunctionCombination/SelectorCombination.cs
rename to NetFabric.Hyperlinq.Core/Utils/FunctionCombination/SelectorCombination.cs
diff --git a/NetFabric.Hyperlinq/Utils/IndexOf/IndexOf.ReadOnlySpan.cs b/NetFabric.Hyperlinq.Core/Utils/IndexOf/IndexOf.ReadOnlySpan.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/IndexOf/IndexOf.ReadOnlySpan.cs
rename to NetFabric.Hyperlinq.Core/Utils/IndexOf/IndexOf.ReadOnlySpan.cs
diff --git a/NetFabric.Hyperlinq/Utils/IndexOf/IndexOf.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq.Core/Utils/IndexOf/IndexOf.ValueReadOnlyCollection.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/IndexOf/IndexOf.ValueReadOnlyCollection.cs
rename to NetFabric.Hyperlinq.Core/Utils/IndexOf/IndexOf.ValueReadOnlyCollection.cs
diff --git a/NetFabric.Hyperlinq/Utils/IntExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/IntExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/IntExtensions.cs
rename to NetFabric.Hyperlinq.Core/Utils/IntExtensions.cs
diff --git a/NetFabric.Hyperlinq.Core/Utils/MemoryExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/MemoryExtensions.cs
new file mode 100644
index 000000000..99cfc73b2
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Utils/MemoryExtensions.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    static class MemoryExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlyMemory<T> AsReadOnlyMemory<T>(this Memory<T> source)
+            => source;
+    }
+}
diff --git a/NetFabric.Hyperlinq/Utils/Scalar.cs b/NetFabric.Hyperlinq.Core/Utils/Scalar.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Scalar.cs
rename to NetFabric.Hyperlinq.Core/Utils/Scalar.cs
diff --git a/NetFabric.Hyperlinq.Core/Utils/SpanExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/SpanExtensions.cs
new file mode 100644
index 000000000..07b150b9e
--- /dev/null
+++ b/NetFabric.Hyperlinq.Core/Utils/SpanExtensions.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq
+{
+    static class SpanExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ReadOnlySpan<T> AsReadOnlySpan<T>(this Span<T> source)
+            => source;
+    }
+}
diff --git a/NetFabric.Hyperlinq/Utils/Throw.cs b/NetFabric.Hyperlinq.Core/Utils/Throw.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Throw.cs
rename to NetFabric.Hyperlinq.Core/Utils/Throw.cs
diff --git a/NetFabric.Hyperlinq/Utils/ThrowIfArgument.cs b/NetFabric.Hyperlinq.Core/Utils/ThrowIfArgument.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/ThrowIfArgument.cs
rename to NetFabric.Hyperlinq.Core/Utils/ThrowIfArgument.cs
diff --git a/NetFabric.Hyperlinq/Utils/Utils.AllocateUninitializedArray.cs b/NetFabric.Hyperlinq.Core/Utils/Utils.AllocateUninitializedArray.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Utils.AllocateUninitializedArray.cs
rename to NetFabric.Hyperlinq.Core/Utils/Utils.AllocateUninitializedArray.cs
diff --git a/NetFabric.Hyperlinq/Utils/Utils.EqualityComparer.cs b/NetFabric.Hyperlinq.Core/Utils/Utils.EqualityComparer.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Utils.EqualityComparer.cs
rename to NetFabric.Hyperlinq.Core/Utils/Utils.EqualityComparer.cs
diff --git a/NetFabric.Hyperlinq/Utils/Utils.SkipTake.cs b/NetFabric.Hyperlinq.Core/Utils/Utils.SkipTake.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/Utils.SkipTake.cs
rename to NetFabric.Hyperlinq.Core/Utils/Utils.SkipTake.cs
diff --git a/NetFabric.Hyperlinq/Utils/VectorExtensions.cs b/NetFabric.Hyperlinq.Core/Utils/VectorExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq/Utils/VectorExtensions.cs
rename to NetFabric.Hyperlinq.Core/Utils/VectorExtensions.cs
diff --git a/NetFabric.Hyperlinq.Immutable/NetFabric.Hyperlinq.Immutable.csproj b/NetFabric.Hyperlinq.Immutable/NetFabric.Hyperlinq.Immutable.csproj
deleted file mode 100644
index f433a0dbc..000000000
--- a/NetFabric.Hyperlinq.Immutable/NetFabric.Hyperlinq.Immutable.csproj
+++ /dev/null
@@ -1,55 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
-    <PackageId>NetFabric.Hyperlinq.Immutable</PackageId>
-    <Title>NetFabric.Hyperlinq.Immutable</Title>
-    <Description> High performance LINQ implementation with minimal heap allocations. Supports all collections in System.Collections.Immutable.</Description>
-    <Version>1.0.0-beta01</Version>
-    <PackageIcon>Icon.png</PackageIcon>
-    <PackageLicenseFile>LICENSE</PackageLicenseFile>
-    <PackageTags>netfabric, hyperlinq, linq, enumeration, extensions, performance</PackageTags>
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <!-- <TreatWarningsAsErrors>true</TreatWarningsAsErrors> -->
-  </PropertyGroup>
-
-  <ItemGroup>
-    <SupportedPlatform Include="browser" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Include="..\Icon.png" Pack="true" PackagePath="" />
-    <None Include="..\LICENSE" Pack="true" PackagePath="" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\NetFabric.Hyperlinq\NetFabric.Hyperlinq.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="System.Collections.Immutable" Version="5.0.0" />
-    <PackageReference Include="Nullable" Version="1.3.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Meziantou.Analyzer" Version="1.0.667">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableArrayExtensions.cs" Link="ImmutableArrayExtensions.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableDictionaryExtensions.cs" Link="ImmutableDictionaryExtensions.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableHashSetExtensions.cs" Link="ImmutableHashSetExtensions.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableListExtensions.cs" Link="ImmutableListExtensions.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableQueueExtensions.cs" Link="ImmutableQueueExtensions.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableSortedDictionaryExtensions.cs" Link="ImmutableSortedDictionaryExtensions.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq\Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\ImmutableStackExtensions.cs" Link="ImmutableStackExtensions.cs" />
-  </ItemGroup>
-
-</Project>
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/CollectExtensionMethodsTests.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/CollectExtensionMethodsTests.cs
deleted file mode 100644
index 1bf2b271d..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/CollectExtensionMethodsTests.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using Microsoft.CodeAnalysis;
-using NetFabric.Assertive;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using Xunit;
-
-namespace NetFabric.Hyperlinq.SourceGenerator.UnitTests
-{
-    public class CollectExtensionMethodsTests
-    {
-        public static TheoryData<string[], int> ExtensionMethods
-            => new()
-            {
-                { new[] { "TestData/Source/NoExtensionMethods.cs" }, 0 },
-                { new[] { "TestData/Source/ExtensionMethods.cs" }, 3 },
-
-                { new[] { "TestData/Source/Distinct.ArraySegment.cs" }, 1},
-                { new[] { "TestData/Source/Count.ValueEnumerable.cs" }, 1 },
-                { new[] { "TestData/Source/Distinct.ValueEnumerable.cs" }, 1 },
-
-                { new[] { "TestData/Source/Where.ArraySegment.cs" }, 2 },
-                { new[] { "TestData/Source/Select.ArraySegment.cs" }, 2 },
-                { new[] { "TestData/Source/Where.ValueEnumerable.cs" }, 2 },
-                { new[] { "TestData/Source/Select.ValueEnumerable.cs" }, 2 },
-            };
-
-        [Theory]
-        [MemberData(nameof(ExtensionMethods))]
-        public async Task ShouldCollectExpectedNumberOfExtensionMethods(string[] paths, int expected)
-        {
-            // Arrange
-            var generator = new OverloadsGenerator();
-            var project = Verifier.CreateProject(
-                paths
-                .Concat(Directory.EnumerateFiles("TestData/Source/Common", "*.cs", SearchOption.AllDirectories))
-                .Concat(Directory.EnumerateFiles("../../../../NetFabric.Hyperlinq.SourceGenerator/Attributes/", "*.cs", SearchOption.AllDirectories))
-                .Select(path => File.ReadAllText(path)));
-            var context = new CompilationContext(await project.GetCompilationAsync().ConfigureAwait(false) ?? throw new System.Exception("Error getting compilation!"));
-
-            // Act
-            var result = generator.CollectExtensionMethods(context);
-
-            // Assert
-            _ = result.Count.Must()
-                .BeEqualTo(expected);
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/GenerateSourceTests.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/GenerateSourceTests.cs
deleted file mode 100644
index 44078968f..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/GenerateSourceTests.cs
+++ /dev/null
@@ -1,241 +0,0 @@
-using Microsoft.CodeAnalysis;
-using NetFabric.Assertive;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using Xunit;
-
-namespace NetFabric.Hyperlinq.SourceGenerator.UnitTests
-{
-    public class GenerateSourceTests
-    {
-        public static TheoryData<string[]> ClassesWithOverloads
-            => new()
-            {
-                new[] {
-                    "TestData/Source/Count.ValueEnumerable.cs",
-                },
-                new[] {
-                    "TestData/Source/Where.ValueEnumerable.cs",
-                },
-                new[] {
-                    "TestData/Source/Select.ValueEnumerable.cs",
-                },
-            };
-
-        [Theory]
-        [MemberData(nameof(ClassesWithOverloads))]
-        public async Task ClassesWithOverloadsShouldNotGenerate(string[] paths)
-        {
-            // Arrange
-            var generator = new OverloadsGenerator();
-            var project = Verifier.CreateProject(
-                paths
-                .Concat(Directory.EnumerateFiles("TestData/Source/Common", "*.cs", SearchOption.AllDirectories))
-                .Concat(Directory.EnumerateFiles("../../../../NetFabric.Hyperlinq.SourceGenerator/Attributes/", "*.cs", SearchOption.AllDirectories))
-                .Select(path => File.ReadAllText(path)));
-            var context = new CompilationContext(await project.GetCompilationAsync().ConfigureAwait(false) ?? throw new System.Exception("Error getting compilation!"));
-
-            // Act
-            var extensionMethods = generator.CollectExtensionMethods(context);
-            var result = generator.GenerateSource(extensionMethods, context);
-
-            // Assert
-            _ = result.Must()
-                .BeEnumerableOf<(INamedTypeSymbol, INamedTypeSymbol, string)>()
-                .BeEmpty();
-        }
-
-        // -----------------------------------------------------
-
-        public static TheoryData<string[], string[]> GeneratorSources
-            => new()
-            {
-                {
-                    new[] {
-                        "TestData/Source/Range.cs",
-                        "TestData/Source/Contains.ValueEnumerable.cs",
-                    },
-                    new string[] {
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Select.ArraySegment.cs",
-                        "TestData/Source/Contains.ValueEnumerable.cs",
-                    },
-                    new string[] {
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Range.cs",
-                        "TestData/Source/Count.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Range.Count.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Repeat.cs",
-                        "TestData/Source/Count.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Repeat.Count.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Range.cs",
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Range.Where.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Range.cs",
-                        "TestData/Source/Select.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Range.Select.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Count.ValueEnumerable.cs",
-                        "TestData/Source/Where.ArraySegment.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Where.ArraySegment.Count.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Any.ArraySegment.cs",
-                        "TestData/Source/Any.ValueReadOnlyList.cs",
-                        "TestData/Source/Any.ValueEnumerable.cs",
-                        "TestData/Source/Any.ValueReadOnlyCollection.cs",
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                    },
-                    new string[] {
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Any.ArraySegment.cs",
-                        "TestData/Source/Any.ValueReadOnlyList.cs",
-                        "TestData/Source/Any.ValueEnumerable.cs",
-                        "TestData/Source/Any.ValueReadOnlyCollection.cs",
-                        "TestData/Source/Select.ArraySegment.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Select.ArraySegment.Any.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Any.ArraySegment.cs",
-                        "TestData/Source/Any.ValueReadOnlyList.cs",
-                        "TestData/Source/Any.ValueEnumerable.cs",
-                        "TestData/Source/Any.ValueReadOnlyCollection.cs",
-                        "TestData/Source/Select.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Select.ValueEnumerable.Any.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Count.ValueEnumerable.cs",
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Where.ValueEnumerable.Count.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/First.ValueEnumerable.cs",
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Where.ValueEnumerable.First.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/First.ValueEnumerable.cs",
-                        "TestData/Source/Select.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Select.ValueEnumerable.First.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                        "TestData/Source/Distinct.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Where.ValueEnumerable.Distinct.cs",
-                        "TestData/Results/Distinct.ValueEnumerable.Where.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                        "TestData/Source/Select.ValueEnumerable.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Where.ValueEnumerable.Select.cs",
-                        "TestData/Results/Select.ValueEnumerable.Where.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Where.ValueEnumerable.cs",
-                        "TestData/Source/Dictionary.Bindings.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Dictionary.Where.cs",
-                    }
-                },
-                {
-                    new[] {
-                        "TestData/Source/Select.ValueEnumerable.cs",
-                        "TestData/Source/Dictionary.Bindings.cs",
-                    },
-                    new[] {
-                        "TestData/Results/Dictionary.Select.cs",
-                    }
-                },
-            };
-
-        [Theory]
-        [MemberData(nameof(GeneratorSources))]
-        public async Task GenerateSourceShouldGenerate(string[] paths, string[] expected)
-        {
-            // Arrange
-            var generator = new OverloadsGenerator();
-            var project = Verifier.CreateProject(
-                paths
-                .Concat(Directory.EnumerateFiles("TestData/Source/Common", "*.cs", SearchOption.AllDirectories))
-                .Concat(Directory.EnumerateFiles("../../../../NetFabric.Hyperlinq.SourceGenerator/Attributes/", "*.cs", SearchOption.AllDirectories))
-                .Select(path => File.ReadAllText(path)));
-            var context = new CompilationContext(await project.GetCompilationAsync().ConfigureAwait(false) ?? throw new System.Exception("Error getting compilation!"));
-
-            // Act
-            var extensionMethods = generator.CollectExtensionMethods(context);
-            var result = generator.GenerateSource(extensionMethods, context);
-
-            // Assert
-            _ = result.Select(item => item.Source)
-                .ToArray()
-                .Must()
-                .BeEqualTo(expected.Select(path => File.ReadAllText(path)));
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Dictionary.Select.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Dictionary.Select.cs
deleted file mode 100644
index 00caa8d8c..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Dictionary.Select.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class DictionaryBindings
-    {
-        public partial struct ValueWrapper<TKey, TValue>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult, NetFabric.Hyperlinq.FunctionWrapper<System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult>> Select<TResult>(System.Func<System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult> selector)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult>(this, selector);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-            where TSelector : struct, NetFabric.Hyperlinq.IFunction<System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, TResult, TSelector>(this, selector);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Dictionary.Where.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Dictionary.Where.cs
deleted file mode 100644
index 1e44137c6..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Dictionary.Where.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class DictionaryBindings
-    {
-        public partial struct ValueWrapper<TKey, TValue>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, NetFabric.Hyperlinq.FunctionWrapper<System.Collections.Generic.KeyValuePair<TKey, TValue>, bool>> Where(System.Func<System.Collections.Generic.KeyValuePair<TKey, TValue>, bool> predicate)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, TPredicate> Where<TPredicate>(TPredicate predicate = default)
-            where TPredicate : struct, NetFabric.Hyperlinq.IFunction<System.Collections.Generic.KeyValuePair<TKey, TValue>, bool>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.DictionaryBindings.ValueWrapper<TKey, TValue>, System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator, System.Collections.Generic.KeyValuePair<TKey, TValue>, TPredicate>(this, predicate);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Distinct.ValueEnumerable.Where.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Distinct.ValueEnumerable.Where.cs
deleted file mode 100644
index 85119f091..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Distinct.ValueEnumerable.Where.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct DistinctEnumerable<TEnumerable, TEnumerator, TSource>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>, NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator, TSource, NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>> Where(System.Func<TSource, bool> predicate)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>, NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator, TSource>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>, NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator, TSource, TPredicate> Where<TPredicate>(TPredicate predicate = default)
-            where TPredicate : struct, NetFabric.Hyperlinq.IFunction<TSource, bool>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>, NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator, TSource, TPredicate>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>, NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator, TSource> Distinct()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Distinct<NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>, NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator, TSource>(this);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Count.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Count.cs
deleted file mode 100644
index cad14e728..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Count.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerable
-    {
-
-        [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-        [DebuggerNonUserCode]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count(this NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable source)
-        => NetFabric.Hyperlinq.ValueEnumerableExtensions.Count<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int>(source);
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Select.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Select.cs
deleted file mode 100644
index 87cf749f7..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Select.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerable
-    {
-        public partial struct RangeEnumerable
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, TResult, NetFabric.Hyperlinq.FunctionWrapper<int, TResult>> Select<TResult>(System.Func<int, TResult> selector)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, TResult>(this, selector);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-            where TSelector : struct, NetFabric.Hyperlinq.IFunction<int, TResult>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, TResult, TSelector>(this, selector);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Where.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Where.cs
deleted file mode 100644
index 14219e17f..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Range.Where.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerable
-    {
-        public partial struct RangeEnumerable
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, NetFabric.Hyperlinq.FunctionWrapper<int, bool>> Where(System.Func<int, bool> predicate)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, TPredicate> Where<TPredicate>(TPredicate predicate = default)
-            where TPredicate : struct, NetFabric.Hyperlinq.IFunction<int, bool>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable, NetFabric.Hyperlinq.ValueEnumerable.RangeEnumerable.DisposableEnumerator, int, TPredicate>(this, predicate);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Repeat.Count.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Repeat.Count.cs
deleted file mode 100644
index 41ac35b3f..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Repeat.Count.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerable
-    {
-
-        [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-        [DebuggerNonUserCode]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this NetFabric.Hyperlinq.ValueEnumerable.RepeatEnumerable<TSource> source)
-        => NetFabric.Hyperlinq.ValueEnumerableExtensions.Count<NetFabric.Hyperlinq.ValueEnumerable.RepeatEnumerable<TSource>, NetFabric.Hyperlinq.ValueEnumerable.RepeatEnumerable<TSource>.DisposableEnumerator, TSource>(source);
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ArraySegment.Any.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ArraySegment.Any.cs
deleted file mode 100644
index f44a33abe..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ArraySegment.Any.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-        public partial struct ArraySegmentSelectEnumerable<TSource, TResult, TSelector>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly bool Any(System.Func<TResult, bool> predicate)
-            => NetFabric.Hyperlinq.ValueReadOnlyListExtensions.Any<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, TResult>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly bool Any<TPredicate>(TPredicate predicate = default)
-            where TPredicate : struct, NetFabric.Hyperlinq.IFunction<TResult, bool>
-            => NetFabric.Hyperlinq.ValueReadOnlyListExtensions.Any<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentSelectEnumerable<TSource, TResult, TSelector>, TResult, TPredicate>(this, predicate);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.Any.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.Any.cs
deleted file mode 100644
index 76ba1132a..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.Any.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly bool Any()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Any<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult>(this);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly bool Any(System.Func<TResult, bool> predicate)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Any<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly bool Any<TPredicate>(TPredicate predicate = default)
-            where TPredicate : struct, NetFabric.Hyperlinq.IFunction<TResult, bool>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Any<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult, TPredicate>(this, predicate);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.First.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.First.cs
deleted file mode 100644
index 77c913be7..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.First.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.Option<TResult> First()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.First<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult>(this);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.Where.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.Where.cs
deleted file mode 100644
index 6c9ed4726..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Select.ValueEnumerable.Where.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult, NetFabric.Hyperlinq.FunctionWrapper<TResult, bool>> Where(System.Func<TResult, bool> predicate)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult>(this, predicate);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult, TPredicate> Where<TPredicate>(TPredicate predicate = default)
-            where TPredicate : struct, NetFabric.Hyperlinq.IFunction<TResult, bool>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Where<NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>, NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator, TResult, TPredicate>(this, predicate);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ArraySegment.Count.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ArraySegment.Count.cs
deleted file mode 100644
index 444845022..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ArraySegment.Count.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-        public partial struct ArraySegmentWhereEnumerable<TSource, TPredicate>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly int Count()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Count<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentWhereEnumerable<TSource, TPredicate>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentWhereEnumerable<TSource, TPredicate>.DisposableEnumerator, TSource>(this);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Count.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Count.cs
deleted file mode 100644
index a68c8d6da..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Count.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly int Count()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Count<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource>(this);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Distinct.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Distinct.cs
deleted file mode 100644
index 6f5f15c16..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Distinct.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.DistinctEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource> Distinct()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Distinct<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource>(this);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.First.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.First.cs
deleted file mode 100644
index 8b13b25f7..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.First.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.Option<TSource> First()
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.First<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource>(this);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Select.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Select.cs
deleted file mode 100644
index c9b3e7b9b..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Results/Where.ValueEnumerable.Select.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-#nullable enable
-
-using System;
-using System.CodeDom.Compiler;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public partial struct WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>
-        {
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource, TResult, NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>> Select<TResult>(System.Func<TSource, TResult> selector)
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource, TResult>(this, selector);
-
-            [GeneratedCode("NetFabric.Hyperlinq.SourceGenerator", "1.0.0")]
-            [DebuggerNonUserCode]
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly NetFabric.Hyperlinq.ValueEnumerableExtensions.SelectEnumerable<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-            where TSelector : struct, NetFabric.Hyperlinq.IFunction<TSource, TResult>
-            => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>, NetFabric.Hyperlinq.ValueEnumerableExtensions.WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator, TSource, TResult, TSelector>(this, selector);
-
-        }
-
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ArraySegment.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ArraySegment.cs
deleted file mode 100644
index fb6d8bcbb..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ArraySegment.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-
-        public static bool Any<TSource>(this in ArraySegment<TSource> source)
-            => source.Count != 0;
-
-        public static bool Any<TSource>(this in ArraySegment<TSource> source, Func<TSource, bool> predicate)
-            => source.Any(new FunctionWrapper<TSource, bool>(predicate));
-
-        public static bool Any<TSource, TPredicate>(this in ArraySegment<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, bool>
-            => default;
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueEnumerable.cs
deleted file mode 100644
index 2c79e1b31..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueEnumerable.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => default;
-
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Any<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-
-        public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => default;
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueReadOnlyList.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueReadOnlyList.cs
deleted file mode 100644
index 085c79a11..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ValueReadOnlyList.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueReadOnlyListExtensions
-    {
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TList, TSource>(this TList source)
-            where TList : struct, IReadOnlyList<TSource>
-            => source.Count is not 0;
-
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TList, TSource>(this TList source, Func<TSource, bool> predicate)
-            where TList : struct, IReadOnlyList<TSource>
-            => source.Any<TList, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TList, TSource, TPredicate>(this TList source, TPredicate predicate = default)
-            where TList : struct, IReadOnlyList<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => default;
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IFunction.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IFunction.cs
deleted file mode 100644
index 719dbb63a..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IFunction.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace NetFabric.Hyperlinq
-{
-    public interface IFunction<in T, out TResult>
-    {
-        TResult Invoke(T arg);
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IFunctionWrapper.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IFunctionWrapper.cs
deleted file mode 100644
index ce38a1db7..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IFunctionWrapper.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using System;
-
-namespace NetFabric.Hyperlinq
-{
-    public readonly struct FunctionWrapper<T, TResult>
-        : IFunction<T, TResult>
-    {
-        readonly Func<T, TResult> function;
-
-        public FunctionWrapper(Func<T, TResult> function)
-            => this.function = function;
-
-        public TResult Invoke(T arg)
-            => function(arg);
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IValueEnumerable.cs
deleted file mode 100644
index d4efc695c..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/IValueEnumerable.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public interface IValueEnumerable<out T, TEnumerator>
-        : IEnumerable<T>
-        where TEnumerator
-            : struct
-            , IEnumerator<T>
-    {
-        new TEnumerator GetEnumerator();
-    }
-
-    public interface IValueReadOnlyCollection<out T, TEnumerator>
-        : IReadOnlyCollection<T>
-        , IValueEnumerable<T, TEnumerator>
-        where TEnumerator
-            : struct
-            , IEnumerator<T>
-    {
-    }
-
-    public interface IValueReadOnlyList<out T, TEnumerator>
-        : IReadOnlyList<T>
-        , IValueReadOnlyCollection<T, TEnumerator>
-        where TEnumerator
-            : struct
-            , IEnumerator<T>
-    {
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/Option.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/Option.cs
deleted file mode 100644
index 4c68b37b2..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/Option.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public readonly struct Option<TValue>
-    {
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/PredicateCombination.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/PredicateCombination.cs
deleted file mode 100644
index 27b56347f..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/PredicateCombination.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-namespace NetFabric.Hyperlinq
-{
-    public struct PredicateCombination<TPredicate1, TPredicate2, TSource>
-        : IFunction<TSource, bool>
-        where TPredicate1 : struct, IFunction<TSource, bool>
-        where TPredicate2 : struct, IFunction<TSource, bool>
-    {
-        TPredicate1 first;
-        TPredicate2 second;
-
-        public PredicateCombination(TPredicate1 first, TPredicate2 second)
-            => (this.first, this.second) = (first, second);
-
-        public bool Invoke(TSource item)
-            => first.Invoke(item) && second.Invoke(item);
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/SelectorCombination.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/SelectorCombination.cs
deleted file mode 100644
index f7dfe9134..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Common/SelectorCombination.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-namespace NetFabric.Hyperlinq
-{
-    public readonly struct SelectorCombination<TSelector1, TSelector2, TSource, TMiddle, TResult>
-        : IFunction<TSource, TResult>
-        where TSelector1 : struct, IFunction<TSource, TMiddle>
-        where TSelector2 : struct, IFunction<TMiddle, TResult>
-    {
-        readonly TSelector1 first;
-        readonly TSelector2 second;
-
-        public SelectorCombination(TSelector1 first, TSelector2 second)
-            => (this.first, this.second) = (first, second);
-
-        public TResult Invoke(TSource item)
-            => second.Invoke(first.Invoke(item));
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Contains.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Contains.ValueEnumerable.cs
deleted file mode 100644
index 7de29c2c4..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Contains.ValueEnumerable.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public static bool Contains<TEnumerable, TEnumerator, TSource>(this TEnumerable source, TSource value)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => default;
-
-        public static bool Contains<TEnumerable, TEnumerator, TSource>(this TEnumerable source, TSource value, IEqualityComparer<TSource>? comparer)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => default;
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Count.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Count.ValueEnumerable.cs
deleted file mode 100644
index 897fe92b1..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Count.ValueEnumerable.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable _)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => 0;
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Dictionary.Bindings.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Dictionary.Bindings.cs
deleted file mode 100644
index 68137e488..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Dictionary.Bindings.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class DictionaryBindings
-    {
-        [GeneratorMapping("TSource", "System.Collections.Generic.KeyValuePair<TKey, TValue>", true)]
-        public readonly partial struct ValueWrapper<TKey, TValue>
-            : IValueReadOnlyCollection<KeyValuePair<TKey, TValue>, Dictionary<TKey, TValue>.Enumerator>
-            , ICollection<KeyValuePair<TKey, TValue>>
-            where TKey : notnull
-        {
-            readonly Dictionary<TKey, TValue> source;
-
-            public ValueWrapper(Dictionary<TKey, TValue> source) 
-                => this.source = source;
-
-            public int Count
-                => source.Count;
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TValue>.Enumerator GetEnumerator() 
-                => source.GetEnumerator();
-
-            IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => GetEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => GetEnumerator();
-
-            bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly  
-                => true;
-
-            void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) 
-                => ((ICollection<KeyValuePair<TKey, TValue>>)source).CopyTo(array, arrayIndex);
-
-            void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) 
-                => throw new NotSupportedException();
-            void ICollection<KeyValuePair<TKey, TValue>>.Clear() 
-                => throw new NotSupportedException();
-            bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) 
-                => throw new NotSupportedException();
-            bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) 
-                => throw new NotSupportedException();        
-        }
-
-        public static int Count<TKey, TValue>(this ValueWrapper<TKey, TValue> source)
-            where TKey : notnull
-            => source.Count;
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Distinct.ArraySegment.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Distinct.ArraySegment.cs
deleted file mode 100644
index a950046e1..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Distinct.ArraySegment.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-        public static ArraySegmentDistinctEnumerable<TSource> Distinct<TSource>(this in ArraySegment<TSource> source)
-            => new(source);
-
-        public readonly partial struct ArraySegmentDistinctEnumerable<TSource>
-            : IValueEnumerable<TSource, ArraySegmentDistinctEnumerable<TSource>.DisposableEnumerator>
-        {
-            readonly ArraySegment<TSource> source;
-
-            internal ArraySegmentDistinctEnumerable(in ArraySegment<TSource> source)
-                => this.source = source;
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<TSource>
-            {
-                public readonly TSource Current => default!;
-                readonly TSource IEnumerator<TSource>.Current => default!;
-                readonly object IEnumerator.Current => default!;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-        }
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Distinct.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Distinct.ValueEnumerable.cs
deleted file mode 100644
index 493f1a6f3..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Distinct.ValueEnumerable.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        public static DistinctEnumerable<TEnumerable, TEnumerator, TSource> Distinct<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => new(source);
-
-        public readonly partial struct DistinctEnumerable<TEnumerable, TEnumerator, TSource>
-            : IValueEnumerable<TSource, DistinctEnumerable<TEnumerable, TEnumerator, TSource>.DisposableEnumerator>
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-        {
-            readonly TEnumerable source;
-
-            internal DistinctEnumerable(TEnumerable source)
-                => this.source = source;
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<TSource>
-            {
-                public readonly TSource Current => default!;
-                readonly TSource IEnumerator<TSource>.Current => default!;
-                readonly object? IEnumerator.Current => default;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-        }
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/ExtensionMethods.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/ExtensionMethods.cs
deleted file mode 100644
index 629a8d4f2..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/ExtensionMethods.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ExtensionMethods
-    {
-        public static void NotConstrainedExtensionMethod(this ArraySegment<int> _) { }
-
-        static void NotIgnoredExtensionMethod<TEnumerable, TEnumerator, TSource>(this TEnumerable _)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-        { }
-
-        public static void PublicExtensionMethod<TEnumerable, TEnumerator, TSource>(this TEnumerable _)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-        { }
-    }
-
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/First.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/First.ValueEnumerable.cs
deleted file mode 100644
index 967f11668..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/First.ValueEnumerable.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-
-        public static Option<TSource> First<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => default;
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/NoExtensionMethods.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/NoExtensionMethods.cs
deleted file mode 100644
index 9b7e6861a..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/NoExtensionMethods.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    //public class NotStaticClass
-    //{
-    //    public void Method<TEnumerable, TEnumerator, TSource>(TEnumerable _)
-    //        where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-    //        where TEnumerator : struct, IEnumerator<TSource>
-    //    { }
-    //}
-
-    //static class NotPublicStaticClass
-    //{
-    //    public static void ExtensionMethod<TEnumerable, TEnumerator, TSource>(this TEnumerable _)
-    //        where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-    //        where TEnumerator : struct, IEnumerator<TSource>
-    //    { }
-    //}
-
-    public static class NoExtensionMethods
-    {
-        //public static void NotExtensionMethod<TEnumerable, TEnumerator, TSource>(TEnumerable _)
-        //    where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-        //    where TEnumerator : struct, IEnumerator<TSource>
-        //{ }
-        
-        //static void NotPublicExtensionMethod<TEnumerable, TEnumerator, TSource>(this TEnumerable _)
-        //    where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-        //    where TEnumerator : struct, IEnumerator<TSource>
-        //{ }
-
-        [GeneratorIgnore]
-        public static void IgnoredExtensionMethod<TEnumerable, TEnumerator, TSource>(this TEnumerable _)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-        { }
-    }
-
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Range.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Range.cs
deleted file mode 100644
index c2659d429..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Range.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerable
-    {
-        public static RangeEnumerable Range(int start, int count)
-            => new(start, count);
-
-        [GeneratorMapping("TSource", "int", true)]
-        public readonly partial struct RangeEnumerable
-            : IValueReadOnlyCollection<int, RangeEnumerable.DisposableEnumerator>
-            , ICollection<int>
-        {
-            readonly int start;
-            readonly int end;
-
-            internal RangeEnumerable(int start, int count)
-            {
-                this.start = start;
-                Count = count;
-                end = checked(start + count);
-            }
-
-            public int Count { get; }
-
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<int, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<int> IEnumerable<int>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            bool ICollection<int>.IsReadOnly
-                => true;
-
-            public void CopyTo(int[] array, int arrayIndex)
-            {
-            }
-
-            public bool Contains(int value)
-                => value >= start && value < end;
-
-            void ICollection<int>.Add(int item)
-                => throw new NotSupportedException();
-            void ICollection<int>.Clear()
-                => throw new NotSupportedException();
-            bool ICollection<int>.Remove(int item)
-                => throw new NotSupportedException();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<int>
-            {
-                public readonly int Current => 0;
-                readonly int IEnumerator<int>.Current => 0;
-                readonly object IEnumerator.Current => 0;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-
-            public bool Contains(int value, IEqualityComparer<int>? comparer)
-                => default;
-
-            public RangeEnumerable Skip(int count)
-                => default;
-        }
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Repeat.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Repeat.cs
deleted file mode 100644
index 4a343102c..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Repeat.cs
+++ /dev/null
@@ -1,139 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerable
-    {
-        
-        public static RepeatEnumerable<TSource> Repeat<TSource>(TSource value, int count)
-        {
-            if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
-
-            return new RepeatEnumerable<TSource>(value, count);
-        }
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct RepeatEnumerable<TSource>
-            : IValueReadOnlyCollection<TSource, RepeatEnumerable<TSource>.DisposableEnumerator>
-            , ICollection<TSource>
-        {
-            readonly TSource value;
-            readonly int count;
-
-            internal RepeatEnumerable(TSource value, int count)
-            {
-                this.value = value;
-                this.count = count;
-            }
-
-            public int Count 
-                => count;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Enumerator GetEnumerator() 
-                => new(in this);
-
-            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator() 
-                => new(in this);
-
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator(in this);
-
-            IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator(in this);
-
-            bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public void CopyTo(Span<TSource> span) 
-            {
-
-            }
-
-            public void CopyTo(TSource[] array, int arrayIndex)
-            {
-
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Contains(TSource item)
-                => count is not 0 && EqualityComparer<TSource>.Default.Equals(value, item);
-
-            public int IndexOf(TSource item)
-                => count is not 0 && EqualityComparer<TSource>.Default.Equals(value, item)
-                    ? 0
-                    : -1;
-
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Add(TSource item) 
-                => throw new NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Clear() 
-                => throw new NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            bool ICollection<TSource>.Remove(TSource item) 
-                => throw new NotSupportedException();
-
-            [StructLayout(LayoutKind.Sequential)]
-            public struct Enumerator
-            {
-                int counter;
-                readonly int end;
-
-                internal Enumerator(in RepeatEnumerable<TSource> enumerable)
-                {
-                    Current = enumerable.value;
-                    counter = -1;
-                    end = counter + enumerable.Count;
-                }
-
-                public TSource Current { get; }
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public bool MoveNext() 
-                    => ++counter <= end;
-            }
-
-            [StructLayout(LayoutKind.Sequential)]
-            public struct DisposableEnumerator
-                : IEnumerator<TSource>
-            {
-                int counter;
-                readonly int end;
-
-                internal DisposableEnumerator(in RepeatEnumerable<TSource> enumerable)
-                {
-                    Current = enumerable.value;
-                    counter = -1;
-                    end = counter + enumerable.Count;
-                }
-
-                public TSource Current { get; }
-                readonly TSource IEnumerator<TSource>.Current 
-                    => Current;
-                readonly object? IEnumerator.Current
-                    // ReSharper disable once HeapView.PossibleBoxingAllocation
-                    => Current;
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public bool MoveNext() 
-                    => ++counter <= end;
-
-                [ExcludeFromCodeCoverage]
-                public readonly void Reset() 
-                    => throw new NotSupportedException();
-
-                public readonly void Dispose() { }
-            }
-        }
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Select.ArraySegment.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Select.ArraySegment.cs
deleted file mode 100644
index b943fa420..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Select.ArraySegment.cs
+++ /dev/null
@@ -1,115 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
-        static ArraySegmentSelectEnumerable<TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TSource, TResult>(this in ArraySegment<TSource> source, Func<TSource, TResult> selector)
-            => Select<TSource, TResult, FunctionWrapper<TSource, TResult>>(source, new FunctionWrapper<TSource, TResult>(selector));
-
-        static ArraySegmentSelectEnumerable<TSource, TResult, TSelector> Select<TSource, TResult, TSelector>(this in ArraySegment<TSource> source, TSelector selector = default)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => new(source, selector);
-
-        [GeneratorMapping("TSource", "TResult")]
-        public readonly partial struct ArraySegmentSelectEnumerable<TSource, TResult, TSelector>
-            : IValueReadOnlyList<TResult, ArraySegmentSelectEnumerable<TSource, TResult, TSelector>.DisposableEnumerator>
-            , IList<TResult>
-            where TSelector : struct, IFunction<TSource, TResult>
-        {
-            readonly ArraySegment<TSource> source;
-            readonly TSelector selector;
-
-            internal ArraySegmentSelectEnumerable(in ArraySegment<TSource> source, TSelector selector)
-                => (this.source, this.selector) = (source, selector);
-
-            public int Count
-                => 0;
-
-            bool ICollection<TResult>.IsReadOnly
-                => true;
-
-            void ICollection<TResult>.CopyTo(TResult[] array, int arrayIndex) 
-            { }
-            void ICollection<TResult>.Add(TResult item)
-                => throw new NotSupportedException();
-            void ICollection<TResult>.Clear()
-                => throw new NotSupportedException();
-            public bool Contains(TResult item)
-                => default;
-            bool ICollection<TResult>.Remove(TResult item)
-                => throw new NotSupportedException();
-            int IList<TResult>.IndexOf(TResult item)
-                => default;
-            void IList<TResult>.Insert(int index, TResult item)
-                => throw new NotSupportedException();
-            void IList<TResult>.RemoveAt(int index)
-                => throw new NotSupportedException();
-
-            public TResult this[int index] 
-                => default!;
-            TResult IReadOnlyList<TResult>.this[int index]
-                => this[index];
-            TResult IList<TResult>.this[int index]
-            {
-                get => this[index]!;
-                set => throw new NotSupportedException();
-            }
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<TResult, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<TResult> IEnumerable<TResult>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<TResult>
-            {
-                public readonly TResult Current => default!;
-                readonly object IEnumerator.Current => default!;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-
-            public bool Any()
-                => source.Count is not 0;
-
-            public bool Contains(TResult value, IEqualityComparer<TResult>? comparer = default)
-                => default;
-
-            public ArraySegmentSelectEnumerable<TSource, TResult2, SelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<FunctionWrapper<TResult, TResult2>, TResult2>(new FunctionWrapper<TResult, TResult2>(selector));
-
-            public ArraySegmentSelectEnumerable<TSource, TResult2, SelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TSelector2, TResult2>(TSelector2 selector = default)
-                where TSelector2 : struct, IFunction<TResult, TResult2>
-                => Select<TSource, TResult2, SelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
-        }
-
-        public static int Count<TSource, TResult, TSelector>(this ArraySegmentSelectEnumerable<TSource, TResult, TSelector> source)
-            where TSelector : struct, IFunction<TSource, TResult>
-            => 0;
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Select.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Select.ValueEnumerable.cs
deleted file mode 100644
index 022d483f3..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Select.ValueEnumerable.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        [GeneratorMapping("TSelector", "NetFabric.Hyperlinq.FunctionWrapper<TSource, TResult>")]
-        public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Func<TSource, TResult> selector)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => Select<TEnumerable, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>>(source, new FunctionWrapper<TSource, TResult>(selector));
-
-        public static SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector> Select<TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-            => new(source, selector);
-
-        [GeneratorMapping("TSource", "TResult")]
-        public readonly partial struct SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>
-            : IValueEnumerable<TResult, SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult, TSelector>.DisposableEnumerator>
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TSelector : struct, IFunction<TSource, TResult>
-        {
-            readonly TEnumerable source;
-            readonly TSelector selector;
-
-            internal SelectEnumerable(TEnumerable source, TSelector selector)
-                => (this.source, this.selector) = (source, selector);
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<TResult, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<TResult> IEnumerable<TResult>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<TResult>
-            {
-                public readonly TResult Current => default!;
-                readonly object IEnumerator.Current => default!;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-
-            public int Count()
-                => source.Count<TEnumerable, TEnumerator, TSource>();
-
-            public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorCombination<TSelector, FunctionWrapper<TResult, TResult2>, TSource, TResult, TResult2>> Select<TResult2>(Func<TResult, TResult2> selector)
-                => Select<FunctionWrapper<TResult, TResult2>, TResult2>(new FunctionWrapper<TResult, TResult2>(selector));
-
-            public SelectEnumerable<TEnumerable, TEnumerator, TSource, TResult2, SelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>> Select<TSelector2, TResult2>(TSelector2 selector = default)
-                where TSelector2 : struct, IFunction<TResult, TResult2>
-                => Select<TEnumerable, TEnumerator, TSource, TResult2, SelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>>(source, new SelectorCombination<TSelector, TSelector2, TSource, TResult, TResult2>(this.selector, selector));
-        }
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/ToDictionary.ArraySegment.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/ToDictionary.ArraySegment.cs
deleted file mode 100644
index da24d7b1b..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/ToDictionary.ArraySegment.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this in ArraySegment<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-            where TKey : notnull
-        {
-            if (keySelector is null) throw new ArgumentNullException(nameof(keySelector));
-
-            return ToDictionary<TSource, TKey, FunctionWrapper<TSource, TKey>>(source, new FunctionWrapper<TSource, TKey>(keySelector), comparer);
-        }
-
-        public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey, TKeySelector>(this in ArraySegment<TSource> source, TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
-            where TKey : notnull
-            where TKeySelector : struct, IFunction<TSource, TKey>
-        {
-            var dictionary = new Dictionary<TKey, TSource>(source.Count, comparer);
-            return dictionary;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector>(this in ArraySegment<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-            where TKey : notnull
-        {
-            if (keySelector is null) throw new ArgumentNullException(nameof(keySelector));
-            if (elementSelector is null) throw new ArgumentNullException(nameof(elementSelector));
-
-            return ToDictionary<TSource, TKey, TElement, FunctionWrapper<TSource, TKey>, FunctionWrapper<TSource, TElement>>(source, new FunctionWrapper<TSource, TKey>(keySelector), new FunctionWrapper<TSource, TElement>(elementSelector), comparer);
-        }
-
-        public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector>(this in ArraySegment<TSource> source, TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
-            where TKey : notnull
-            where TKeySelector : struct, IFunction<TSource, TKey>
-            where TElementSelector : struct, IFunction<TSource, TElement>
-        {
-            var dictionary = new Dictionary<TKey, TElement>(source.Count, comparer);
-            return dictionary;
-        }
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Where.ArraySegment.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Where.ArraySegment.cs
deleted file mode 100644
index 9b5686549..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Where.ArraySegment.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
-        static ArraySegmentWhereEnumerable<TSource, FunctionWrapper<TSource, bool>> Where<TSource>(this in ArraySegment<TSource> source, Func<TSource, bool> predicate)
-            => Where(source, new FunctionWrapper<TSource, bool>(predicate));
-
-        static ArraySegmentWhereEnumerable<TSource, TPredicate> Where<TSource, TPredicate>(this in ArraySegment<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, bool>
-            => new(source, predicate);
-
-        public readonly partial struct ArraySegmentWhereEnumerable<TSource, TPredicate>
-            : IValueEnumerable<TSource, ArraySegmentWhereEnumerable<TSource, TPredicate>.DisposableEnumerator>
-            where TPredicate : struct, IFunction<TSource, bool>
-        {
-            readonly ArraySegment<TSource> source;
-            readonly TPredicate predicate;
-
-            internal ArraySegmentWhereEnumerable(in ArraySegment<TSource> source, TPredicate predicate)
-                => (this.source, this.predicate) = (source, predicate);
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<TSource>
-            {
-                public readonly TSource Current => default!;
-                readonly TSource IEnumerator<TSource>.Current => default!;
-                readonly object? IEnumerator.Current => default;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-
-            public bool Any()
-                => source.Any(predicate);
-
-            public static bool Any(Func<TSource, bool> predicate)
-                => default;
-
-            public static bool Any<TPredicate2>(TPredicate2 predicate = default)
-                where TPredicate2 : struct, IFunction<TSource, bool>
-                => default;
-
-            public ArraySegmentWhereEnumerable<TSource, PredicateCombination<TPredicate, FunctionWrapper<TSource, bool>, TSource>> Where(Func<TSource, bool> predicate)
-                => Where(new FunctionWrapper<TSource, bool>(predicate));
-
-            public ArraySegmentWhereEnumerable<TSource, PredicateCombination<TPredicate, TPredicate2, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
-                where TPredicate2 : struct, IFunction<TSource, bool>
-                => Where<TSource, PredicateCombination<TPredicate, TPredicate2, TSource>>(source, new PredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
-        }
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Where.ValueEnumerable.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Where.ValueEnumerable.cs
deleted file mode 100644
index 6d5a8dcc0..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Where.ValueEnumerable.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        [GeneratorMapping("TPredicate", "NetFabric.Hyperlinq.FunctionWrapper<TSource, bool>")]
-        public static WhereEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>> Where<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => Where<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(source, new FunctionWrapper<TSource, bool>(predicate));
-
-        public static WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate> Where<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => new(source, predicate);
-
-        public readonly partial struct WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>
-            : IValueEnumerable<TSource, WhereEnumerable<TEnumerable, TEnumerator, TSource, TPredicate>.DisposableEnumerator>
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-        {
-            readonly TEnumerable source;
-            readonly TPredicate predicate;
-
-            internal WhereEnumerable(TEnumerable source, TPredicate predicate)
-                => (this.source, this.predicate) = (source, predicate);
-
-            public Enumerator GetEnumerator()
-                => new();
-
-            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator()
-                => new();
-
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator();
-
-            public struct Enumerator
-            {
-            }
-
-            public struct DisposableEnumerator
-                : IEnumerator<TSource>
-            {
-                public readonly TSource Current => default!;
-                readonly TSource IEnumerator<TSource>.Current => default!;
-                readonly object? IEnumerator.Current => default;
-
-                public bool MoveNext()
-                    => false;
-
-                public readonly void Reset()
-                    => throw new NotSupportedException();
-
-                public void Dispose() { }
-            }
-
-            public bool Any()
-                => source.Any<TEnumerable, TEnumerator, TSource, TPredicate>(predicate);
-
-            public bool Any(Func<TSource, bool> predicate)
-                => Any(new FunctionWrapper<TSource, bool>(predicate));
-
-            public bool Any<TPredicate2>(TPredicate2 predicate = default)
-                where TPredicate2 : struct, IFunction<TSource, bool>
-                => source.Any<TEnumerable, TEnumerator, TSource, PredicateCombination<TPredicate, TPredicate2, TSource>>(new PredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
-
-            public WhereEnumerable<TEnumerable, TEnumerator, TSource, PredicateCombination<TPredicate, FunctionWrapper<TSource, bool>, TSource>> Where(Func<TSource, bool> predicate)
-                => Where(new FunctionWrapper<TSource, bool>(predicate));
-
-            public WhereEnumerable<TEnumerable, TEnumerator, TSource, PredicateCombination<TPredicate, TPredicate2, TSource>> Where<TPredicate2>(TPredicate2 predicate = default)
-                where TPredicate2 : struct, IFunction<TSource, bool>
-                => Where<TEnumerable, TEnumerator, TSource, PredicateCombination<TPredicate, TPredicate2, TSource>>(source, new PredicateCombination<TPredicate, TPredicate2, TSource>(this.predicate, predicate));
-        }
-    }
-}
-
diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/Verifier.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/Verifier.cs
deleted file mode 100644
index a22381d28..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/Verifier.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Text;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace NetFabric.Hyperlinq.SourceGenerator.UnitTests
-{
-    sealed class Verifier
-    {
-        static readonly MetadataReference corlibReference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
-        static readonly MetadataReference systemCoreReference = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location);
-        static readonly MetadataReference cSharpSymbolsReference = MetadataReference.CreateFromFile(typeof(CSharpCompilation).Assembly.Location);
-        static readonly MetadataReference codeAnalysisReference = MetadataReference.CreateFromFile(typeof(Compilation).Assembly.Location);
-
-        static readonly string defaultFilePathPrefix = "Test";
-        static readonly string testProjectName = "TestProject";
-
-        public static Project CreateProject(IEnumerable<string> sources)
-        {
-            var projectId = ProjectId.CreateNewId(debugName: testProjectName);
-
-            var solution = new AdhocWorkspace()
-                .CurrentSolution
-                .AddProject(projectId, testProjectName, testProjectName, LanguageNames.CSharp)
-                .AddMetadataReference(projectId, corlibReference)
-                .AddMetadataReference(projectId, systemCoreReference)
-                .AddMetadataReference(projectId, cSharpSymbolsReference)
-                .AddMetadataReference(projectId, codeAnalysisReference);
-
-            var count = 0;
-            foreach (var source in sources)
-            {
-                var newFileName = defaultFilePathPrefix + count + ".cs";
-                var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
-                solution = solution.AddDocument(documentId, newFileName, SourceText.From(source));
-                count++;
-            }
-            return solution.GetProject(projectId)!;
-        }
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator/NetFabric.Hyperlinq.SourceGenerator.csproj b/NetFabric.Hyperlinq.SourceGenerator/NetFabric.Hyperlinq.SourceGenerator.csproj
deleted file mode 100644
index 538195793..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator/NetFabric.Hyperlinq.SourceGenerator.csproj
+++ /dev/null
@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <RestoreAdditionalProjectSources>https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json ;$(RestoreAdditionalProjectSources)</RestoreAdditionalProjectSources>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.10.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" PrivateAssets="all" />
-    <PackageReference Include="Nullable" Version="1.3.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
-</Project>
diff --git a/NetFabric.Hyperlinq.SourceGenerator/OverloadsGenerator.cs b/NetFabric.Hyperlinq.SourceGenerator/OverloadsGenerator.cs
deleted file mode 100644
index 1852dbec3..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator/OverloadsGenerator.cs
+++ /dev/null
@@ -1,409 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-
-namespace NetFabric.Hyperlinq.SourceGenerator
-{
-    [Generator]
-    public class OverloadsGenerator
-        : ISourceGenerator
-    {
-        static readonly DiagnosticDescriptor unhandledExceptionError = new(
-            id: "HPLG001",
-            title: "Unhandled exception while generating overloads",
-            messageFormat: "Unhandled exception while generating overloads: {0}",
-            category: "OverloadsGenerator",
-            DiagnosticSeverity.Error,
-            isEnabledByDefault: true);
-
-
-        public void Initialize(GeneratorInitializationContext context)
-        {
-        }
-
-        public void Execute(GeneratorExecutionContext context)
-        {
-            //_ = Debugger.Launch(); // uncomment to debug this source generator
-
-            var compilationContext = new CompilationContext(context.Compilation);
-
-            try
-            {
-                var collectedExtensionMethods = CollectExtensionMethods(compilationContext);
-
-                var generatedSources = GenerateSource(collectedExtensionMethods, compilationContext);
-                foreach (var (containerClass, extendingType, generatedSource) in generatedSources)
-                {
-                    var hitName = $"{containerClass.OriginalDefinition.MetadataName}.{extendingType.OriginalDefinition.MetadataName}.g.cs";
-                    hitName = hitName.Replace('`', '.');
-                    context.AddSource(hitName, SourceText.From(generatedSource, Encoding.UTF8));
-                }
-
-            }
-            catch (Exception ex)
-            {
-                context.ReportDiagnostic(Diagnostic.Create(unhandledExceptionError, Location.None, ex.Message));
-            }
-        }
-
-        /// <summary>
-        /// Collects all the extension methods defined
-        /// </summary>
-        /// <param name="context"></param>
-        /// <returns>A dictionary containing collections of the extension methods per type extended.</returns>
-        internal DictionarySet<string, MethodInfo> CollectExtensionMethods(CompilationContext context)
-        {
-            var collectedExtensionMethods = new DictionarySet<string, MethodInfo>();
-            
-            // go through all implemented static types and get all the extension methods implemented
-            var extensionMethods = context.Compilation.SourceModule.GlobalNamespace
-                .GetAllTypes()
-                .Where(typeSymbol =>
-                    typeSymbol.IsStatic
-                    && typeSymbol.IsPublic()
-                )
-                .SelectMany(typeSymbol =>
-                    typeSymbol.GetMembers()
-                        .OfType<IMethodSymbol>()
-                        .Where(methodSymbol =>
-                            methodSymbol.IsExtensionMethod
-                            //&& methodSymbol.IsPublic()
-                            && !methodSymbol.ShouldIgnore(context)
-                        )
-                );
-
-            // go through all extension methods
-            foreach (var extensionMethod in extensionMethods)
-            {
-                var extensionType = extensionMethod.Parameters[0].Type;
-                var generic = extensionMethod.TypeParameters
-                    .FirstOrDefault(typeParameter 
-                        => typeParameter.ConstraintTypes.Length > 0
-                        && typeParameter.Name == extensionType.Name);
-                if (generic is null)
-                {
-                    var name = extensionMethod.Parameters[0].Type.OriginalDefinition.MetadataName;
-                    switch (name)
-                    {
-                        case "ArraySegment`1":
-                        case "ReadOnlySpan`1":
-                        case "ReadOnlyMemory`1":
-                            collectedExtensionMethods.Add(name, extensionMethod.GetInfo(context, 1));
-                            break;
-                    }
-                }
-                else
-                {
-                    // the extended type is a constrained generic parameter
-                    var extendingType = generic.ConstraintTypes[0];
-                    var name = extendingType.OriginalDefinition.MetadataName;
-                    switch (name)
-                    {
-                        case "IValueEnumerable`2":
-                        case "IValueReadOnlyCollection`2":
-                        case "IValueReadOnlyList`2":
-                        case "IReadOnlyList`1":
-                        case "IAsyncValueEnumerable`2":
-                            collectedExtensionMethods.Add(name, extensionMethod.GetInfo(context, 1));
-                            break;
-                    }
-                }
-            }
-
-            return collectedExtensionMethods;
-        }
-
-        /// <summary>
-        /// Generates the source for the overloads based on the defined extension methods.
-        /// </summary>
-        /// <param name="context"></param>
-        /// <param name="collectedExtensionMethods">A dictionary containing the defined extension methods.</param>
-        /// <param name="generatedPath">The path where to serialize the generated code for debugging.</param>
-        internal IEnumerable<(INamedTypeSymbol ContainerClass, INamedTypeSymbol ExtendedType, string Source)> GenerateSource(DictionarySet<string, MethodInfo> collectedExtensionMethods, CompilationContext context)
-        {
-            // go through all candidate types to be extended
-            // these are inner types of a public static class that are not static and not interfaces
-            foreach (var extendingType in context.Compilation.SourceModule.GlobalNamespace
-                .GetAllTypes()
-                .Where(type => type.IsStatic && type.IsReferenceType && type.IsPublic() && !type.ShouldIgnore(context))
-                .SelectMany(containerType => containerType.GetTypeMembers().OfType<INamedTypeSymbol>()
-                    .Where(type => !(type.IsStatic || type.IsInterface() || type.ShouldIgnore(context)))))
-            {
-                var bindingAttribute = extendingType.GetBindingsAttribute(context);
-                foreach (var source in GenerateSource(collectedExtensionMethods, context, extendingType, bindingAttribute))
-                    yield return source;
-            }
-        }
-
-        IEnumerable<(INamedTypeSymbol ContainerClass, INamedTypeSymbol ExtendedType, string Source)> GenerateSource(DictionarySet<string, MethodInfo> collectedExtensionMethods, CompilationContext context, INamedTypeSymbol extendingType, GeneratorBindingsAttribute? bindingsAttribute)
-        {
-            // check if it's a value enumerable and keep a reference to the implemented interface
-            var valueEnumerableInterface = extendingType.GetAllInterfaces()
-                .FirstOrDefault(@interface => @interface.Name is "IValueEnumerable" or "IAsyncValueEnumerable");
-            if (valueEnumerableInterface is not null || bindingsAttribute is not null)
-            {
-                // get the types of the enumerable, enumerator and source from the generic parameters declaration
-                var enumerableType = extendingType;
-                var enumeratorType = valueEnumerableInterface?.TypeArguments[1];
-                var sourceType = valueEnumerableInterface?.TypeArguments[0];
-
-                // get the type mappings from the GeneratorMappingsAttribute, if found.
-                var typeGenericsMapping = extendingType.GetGenericsMappings(context);
-
-                // get the info of all the instance methods declared in the type to be extended
-                var implementedInstanceMethods = extendingType.GetMembers().OfType<IMethodSymbol>()
-                    .Where(method => method.Name is not ".ctor") // ignore the constructors
-                    .Select(method => method.GetInfo(context))
-                    .ToArray();
-
-                // get the extension methods for this type declared in the outter static type
-                var implementedExtensionMethods = extendingType.ContainingType.GetMembers().OfType<IMethodSymbol>()
-                    .Where(method
-                        => method.IsExtensionMethod
-                        && method.Parameters[0].Type.ToDisplayString() == extendingType.ToDisplayString())
-                    .Select(method => method.GetInfo(context, 1))
-                    .ToArray();
-
-                // join the two lists together as these are the implemented methods for this type
-                var implementedMethods = implementedInstanceMethods.Concat(implementedExtensionMethods)
-                    .ToList();
-
-                // lists of methods to be generated
-                var instanceMethodsToBeGenerated = new List<MethodInfo>();
-                var extensionMethodsToBeGenerated = new List<MethodInfo>();
-
-                // go through all the implemented interfaces so that 
-                // the overloads are generated based on the extension methods defined for these
-                var implementedTypes = 
-                    bindingsAttribute?.SourceImplements?.Split(',')
-                    ?? extendingType.AllInterfaces.Select(type => type.OriginalDefinition.MetadataName);
-
-                foreach (var implementedType in implementedTypes)
-                {
-                    // get the extension methods collected for this interface
-                    if (!collectedExtensionMethods.TryGetValue(implementedType, out var overloadingMethods))
-                        continue;
-
-                    // check which ones should be generated
-                    // the method can be already defined by a more performant custom implementation
-                    for (var methodIndex = 0; methodIndex < overloadingMethods.Count; methodIndex++)
-                    {
-                        var overloadingMethod = overloadingMethods[methodIndex];
-
-                        // check if already implemented
-                        var mappedOverloadingMethods = overloadingMethod.ApplyMappings(typeGenericsMapping);
-                        if (!implementedMethods.Any(method => method.IsOverload(mappedOverloadingMethods))
-                            && !((mappedOverloadingMethods.Name is "Select" || mappedOverloadingMethods.Name is "SelectAt") && (extendingType.Name.EndsWith("SelectEnumerable") || extendingType.Name.EndsWith("SelectAtEnumerable")))) // these cases are hard to fix other way
-                        {
-                            // check if there's a collision with a property
-                            if (extendingType.GetMembers().OfType<IPropertySymbol>()
-                                .Any(property => property.Name == mappedOverloadingMethods.Name))
-                            {
-                                // this method will be generated as an extension method
-                                extensionMethodsToBeGenerated.Add(mappedOverloadingMethods);
-                            }
-                            else
-                            {
-                                // this method will generated as an instance method
-                                instanceMethodsToBeGenerated.Add(mappedOverloadingMethods);
-                            }
-
-                            implementedMethods.Add(mappedOverloadingMethods);
-                        }
-                    }
-                }
-
-                // generate the code for the instance methods and extension methods, if any...
-                if (instanceMethodsToBeGenerated.Count is not 0 || extensionMethodsToBeGenerated.Count is not 0)
-                {
-                    var builder = new CodeBuilder();
-                    _ = builder
-                        .AppendLine("#nullable enable")
-                        .AppendLine()
-                        .AppendLine("using System;")
-                        .AppendLine("using System.CodeDom.Compiler;")
-                        .AppendLine("using System.Diagnostics;")
-                        .AppendLine("using System.Runtime.CompilerServices;")
-                        .AppendLine();
-
-                    using (builder.AppendBlock($"namespace NetFabric.Hyperlinq"))
-                    {
-                        // the generator extends the types by adding partial types
-                        // both the outter and the inner types have to be declared as partial
-                        using (builder.AppendBlock($"public static partial class {extendingType.ContainingType.Name}"))
-                        {
-                            // generate the instance methods in the inner type
-                            if (instanceMethodsToBeGenerated.Count is not 0)
-                            {
-                                var extendingTypeGenericParameters = string.Empty;
-                                if (extendingType.IsGenericType)
-                                {
-                                    var parametersDefinition = new StringBuilder();
-                                    _ = parametersDefinition.Append($"<{extendingType.TypeParameters.Select(parameter => parameter.ToDisplayString()).ToCommaSeparated()}>");
-                                    // foreach (var typeParameter in extendingType.TypeParameters.Where(typeParameter => typeParameter.ConstraintTypes.Length is not 0))
-                                    //     _ = parametersDefinition.Append($" where {typeParameter.Name} : {typeParameter.AsConstraintsStrings().ToCommaSeparated()}");
-                                    extendingTypeGenericParameters = parametersDefinition.ToString();
-                                }
-
-                                var entity = extendingType.IsValueType
-                                    ? "struct"
-                                    : "class";
-                                using (builder.AppendBlock($"public partial {entity} {extendingType.Name}{extendingTypeGenericParameters}"))
-                                {
-                                    foreach (var instanceMethod in instanceMethodsToBeGenerated)
-                                    {
-                                        var methodGenericsMapping = typeGenericsMapping.AddRange(instanceMethod.GenericsMapping);
-                                        GenerateMethodSource(builder, context, extendingType, instanceMethod, enumerableType, enumeratorType, sourceType, methodGenericsMapping, false, bindingsAttribute);
-                                    }
-                                }
-                            }
-                            _ = builder.AppendLine();
-
-                            // generate the extension methods in the outter type
-                            foreach (var extensionMethod in extensionMethodsToBeGenerated)
-                            {
-                                var methodGenericsMapping = typeGenericsMapping.AddRange(extensionMethod.GenericsMapping);
-                                GenerateMethodSource(builder, context, extendingType, extensionMethod, enumerableType, enumeratorType, sourceType, methodGenericsMapping, true, bindingsAttribute);
-                            }
-                        }
-                    }
-
-                    var source = builder.ToString().Replace("TResult, TResult", "TSource, TResult");
-                    yield return (extendingType.ContainingType, extendingType, source);
-                }
-            }
-        }
-
-        void GenerateMethodSource(CodeBuilder builder, CompilationContext context, INamedTypeSymbol extendingType, MethodInfo methodToGenerate, ITypeSymbol? enumerableType, ITypeSymbol? enumeratorType, ITypeSymbol sourceType, ImmutableArray<GeneratorMappingAttribute> genericsMapping, bool isExtensionMethod, GeneratorBindingsAttribute? bindingsAttribute)
-        {
-            var extendingTypeTypeArguments = extendingType.MappedTypeArguments(genericsMapping)
-                .ToArray();
-            var typeParameters = isExtensionMethod
-                ? methodToGenerate.TypeParameters
-                    .Where(typeParameter =>
-                        !typeParameter.IsConcreteType
-                        && typeParameter.Name is not "TEnumerable" and not "TEnumerator" and not "TList")
-                    .ToArray()
-                : methodToGenerate.TypeParameters
-                    .Where(typeParameter =>
-                        !typeParameter.IsConcreteType
-                        && typeParameter.Name is not "TEnumerable" and not "TEnumerator" and not "TList"
-                        && !extendingTypeTypeArguments.Any(argument => argument.Name == typeParameter.Name))
-                    .ToArray();
-
-            var methodReturnType = methodToGenerate.ReturnType.ToDisplayString();
-            var genericsIndex = methodReturnType.IndexOf('<');
-            if (genericsIndex >= 0)
-            {
-                methodReturnType = methodReturnType.Substring(0, genericsIndex);
-                if (methodToGenerate.ReturnType is INamedTypeSymbol namedMethodReturnType)
-                {
-                    if (bindingsAttribute is null)
-                        methodReturnType += MapTypeProperties(namedMethodReturnType.TypeArguments.Select(argument => argument.ToDisplayString()), enumerableType!, enumeratorType!, sourceType, genericsMapping);
-                    else
-                        methodReturnType += MapTypeProperties(namedMethodReturnType.TypeArguments.Select(argument => argument.ToDisplayString()), bindingsAttribute);
-                }
-            }
-            if (methodReturnType is "TEnumerable")
-                methodReturnType = extendingType.ToDisplayString();
-
-            var methodName = methodToGenerate.Name;
-            var methodExtensionType = extendingType.ToDisplayString();
-            var methodParameters = methodToGenerate.Parameters
-                .Select(parameter => parameter.DefaultValue is null
-                    ? $"{parameter.Type} {parameter.Name}"
-                    : $"{parameter.Type} {parameter.Name} = {parameter.DefaultValue}")
-                .ToCommaSeparated();
-            var methodGenericParameters = typeParameters
-                .Select(typeParameter => typeParameter.Name)
-                .ToCommaSeparated();
-            var methodGenericParametersString = methodGenericParameters.Any()
-                ? $"<{methodGenericParameters}>"
-                : string.Empty;
-
-            var returnKeyword = string.Empty;
-            var callContainingType = methodToGenerate.ContainingType;
-            var callTypeParameters = bindingsAttribute is null
-                ? MapTypeProperties(methodToGenerate.TypeParameters.Select(parameter => parameter.Name), enumerableType!, enumeratorType!, sourceType, genericsMapping)
-                : MapTypeProperties(methodToGenerate.TypeParameters.Select(parameter => parameter.Name), bindingsAttribute);
-            var callParameters = methodToGenerate.Parameters.Select(parameter => parameter.Name).ToCommaSeparated();
-
-            // generate the source
-            _ = builder
-                .AppendLine(context.GeneratedCodeAttribute)
-                .AppendLine("[DebuggerNonUserCode]")
-                .AppendLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]");
-
-            var firstCallParameter = bindingsAttribute?.Source ?? "this";
-
-            if (isExtensionMethod)
-            {
-                var extraMethodParameter = methodParameters is { Length: 0 }
-                    ? string.Empty
-                    : $", {methodParameters}";
-                _ = builder.AppendLine($"public static {methodReturnType} {methodName}{methodGenericParametersString}(this {methodExtensionType} source{extraMethodParameter})");
-
-                firstCallParameter = bindingsAttribute is null 
-                    ? "source"
-                    : $"source.{bindingsAttribute.Source}";
-            }
-            else
-            {
-                var methodReadonly = extendingType.IsValueType ? "readonly" : string.Empty;
-                _ = builder.AppendLine($"public {methodReadonly} {methodReturnType} {methodName}{methodGenericParametersString}({methodParameters})");
-            }
-            foreach (var (name, constraints, _) in typeParameters.Where(typeParameter => typeParameter.Constraints.Any()))
-                _ = builder.AppendLine($"where {name} : {constraints}");
-
-            callParameters = StringExtensions.CommaSeparateIfNotNullOrEmpty(firstCallParameter, callParameters, bindingsAttribute?.ExtraParameters); 
-
-            _ = builder
-                .AppendLine($"=> {callContainingType}.{methodName}{callTypeParameters}({callParameters});")
-                .AppendLine();
-        }
-
-        string MapTypeProperties(IEnumerable<string> typePropertyNames, ITypeSymbol enumerableType, ITypeSymbol enumeratorType, ITypeSymbol sourceType, ImmutableArray<GeneratorMappingAttribute> genericsMapping)
-        {
-            var str = typePropertyNames.Select(typePropertyName => typePropertyName switch
-            {
-                "TEnumerable" or "TList" => enumerableType.ToDisplayString(genericsMapping),
-                "TEnumerator" => enumeratorType.ToDisplayString(genericsMapping),
-                "TSource" => sourceType.ToDisplayString(genericsMapping),
-                _ => typePropertyName.ApplyMappings(genericsMapping, out _),
-            })
-            .ToCommaSeparated();
-
-            return str switch
-            {
-                { Length: 0 } => string.Empty,
-                _ => $"<{str}>"
-            };
-        }
-
-        string MapTypeProperties(IEnumerable<string> typePropertyNames, GeneratorBindingsAttribute? bindingsAttribute)
-        {
-            var str = typePropertyNames.Select(typePropertyName => typePropertyName switch
-                {
-                    "TEnumerable" or "TList" => bindingsAttribute?.EnumerableType ?? typePropertyName,
-                    "TEnumerator" => bindingsAttribute?.EnumeratorType ?? typePropertyName,
-                    "TSource" => bindingsAttribute?.ElementType ?? typePropertyName,
-                    _ => typePropertyName,
-                })
-                .ToCommaSeparated();
-
-            str = StringExtensions.CommaSeparateIfNotNullOrEmpty(str, bindingsAttribute?.ExtraTypeParameters);
-
-            return str switch
-            {
-                { Length: 0 } => string.Empty,
-                _ => $"<{str}>"
-            };
-        }
-    }
-}
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Properties/AssemblyInfo.cs b/NetFabric.Hyperlinq.SourceGenerator/Properties/AssemblyInfo.cs
deleted file mode 100644
index 423b8e090..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,3 +0,0 @@
-using System.Runtime.CompilerServices;
-
-[assembly: InternalsVisibleTo("NetFabric.Hyperlinq.SourceGenerator.UnitTests")]
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/CodeBuilder.cs b/NetFabric.Hyperlinq.SourceGenerator/Utils/CodeBuilder.cs
deleted file mode 100644
index 1c57c05b2..000000000
--- a/NetFabric.Hyperlinq.SourceGenerator/Utils/CodeBuilder.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System;
-using System.Text;
-
-namespace NetFabric.Hyperlinq.SourceGenerator
-{
-    class CodeBuilder
-    {
-        static readonly string tab = "    ";
-
-        readonly StringBuilder builder = new();
-        int currentLevel = 0;
-
-        StringBuilder AppendIndentation()
-        {
-            for (var level = 0; level < currentLevel; level++)
-                _ = builder.Append(tab);
-
-            return builder;
-        }
-
-        public CodeBuilder AppendLine()
-        {
-            _ = builder.AppendLine();
-            return this;
-        }
-
-        public CodeBuilder AppendLine(char line)
-        {
-            _ = AppendIndentation().Append(line).AppendLine();
-            return this;
-        }
-
-        public CodeBuilder AppendLine(string line)
-        {
-            _ = AppendIndentation().AppendLine(line);
-            return this;
-        }
-
-        public CodeBuilder AppendLine(Action<StringBuilder> line)
-        {
-            _ = AppendIndentation();
-            line(builder);
-            _ = AppendLine();
-            return this;
-        }
-
-        public IDisposable AppendBlock(string line) 
-        {
-            _ = AppendLine(line).AppendLine('{');
-            currentLevel++;
-            return new CloseBlock(this);
-        }
-
-        class CloseBlock : IDisposable
-        {
-            readonly CodeBuilder builder;
-
-            public CloseBlock(CodeBuilder builder) 
-                => this.builder = builder;
-
-            public void Dispose()
-            {
-                builder.currentLevel--;
-                _ = builder.AppendLine('}');
-            }
-        }
-
-        public override string ToString() 
-            => builder.ToString();
-    }
-}
diff --git a/NetFabric.Hyperlinq.UnitTests/GenerateSourceTests.cs b/NetFabric.Hyperlinq.UnitTests/GenerateSourceTests.cs
new file mode 100644
index 000000000..5d0ee0543
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/GenerateSourceTests.cs
@@ -0,0 +1,148 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using NetFabric.Assertive;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetFabric.Hyperlinq.SourceGenerator.UnitTests
+{
+    public class GenerateSourceTests
+    {
+        public static TheoryData<string[], string> GeneratorSources
+            => new()
+            {
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.Empty.cs" },
+                    "TestData/Results/Empty.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.Empty2.cs" },
+                    "TestData/Results/Empty.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.Empty3.cs" },
+                    "TestData/Results/Empty.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.Repeat.cs" },
+                    "TestData/Results/AsValueEnumerable.Repeat.cs"
+                },
+
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs" },
+                    "TestData/Results/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs" },
+                    "TestData/Results/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs" },
+                    "TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs" },
+                    "TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs" },
+                    "TestData/Results/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestCollection.cs" },
+                    "TestData/Results/AsValueEnumerable.TestCollection.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestReadOnlyCollection.cs" },
+                    "TestData/Results/AsValueEnumerable.TestReadOnlyCollection.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestList.cs" },
+                    "TestData/Results/AsValueEnumerable.TestList.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.IReadOnlyList.cs" },
+                    "TestData/Results/AsValueEnumerable.IReadOnlyList.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestListWithExplicitInterfaces.cs" },
+                    "TestData/Results/AsValueEnumerable.TestListWithExplicitInterfaces.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestReadOnlyList.cs" },
+                    "TestData/Results/AsValueEnumerable.TestReadOnlyList.cs"
+                },
+                {
+                    new[] { "TestData/Source/AsValueEnumerable.TestValueEnumerable.cs" },
+                    "TestData/Results/AsValueEnumerable.TestValueEnumerable.cs"
+                },
+                {
+                    new[] { "TestData/Source/Count.Array.cs" },
+                    "TestData/Results/Count.Array.cs"
+                },
+                {
+                    new[] { "TestData/Source/Select.Array.cs" },
+                    "TestData/Results/Select.Array.cs"
+                },
+                {
+                    new[] { "TestData/Source/Where.Array.cs" },
+                    "TestData/Results/Where.Array.cs"
+                },
+                {
+                    new[] { "TestData/Source/Skip.Take.Array.cs" },
+                    "TestData/Results/Skip.Take.Array.cs"
+                },
+                //{
+                //    new[] { "TestData/Source/Count.Span.cs" },
+                //    "TestData/Results/Count.Span.cs"
+                //},
+                {
+                    new[] { "TestData/Source/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs" },
+                    "TestData/Results/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs"
+                },
+                {
+                    new[] { "TestData/Source/Select.TestEnumerableWithValueTypeEnumerator.cs" },
+                    "TestData/Results/Select.TestEnumerableWithValueTypeEnumerator.cs"
+                },
+            };
+
+        [Theory]
+        [MemberData(nameof(GeneratorSources))]
+        public async Task GenerateSourceShouldGenerate(string[] paths, string expected)
+        {
+            // Arrange
+            var sources = paths
+                .Concat(Directory.EnumerateFiles("TestData/Source/Common", "*.cs", SearchOption.AllDirectories))
+                .Select(path => File.ReadAllText(path));
+            var project = Verifier.CreateProject(sources);
+            var compilation = await project.GetCompilationAsync().ConfigureAwait(false) 
+                ?? throw new System.Exception("Error getting compilation!");
+            //var errors = compilation
+            //    .GetDiagnostics()
+            //    .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
+            //    .ToArray();
+            //_ = errors.Must().BeEqualTo(Array.Empty<Diagnostic>());
+            var typeSymbolsCache = new TypeSymbolsCache(compilation);
+            var memberAccessExpressions = compilation.SyntaxTrees
+                .SelectMany(tree => tree.GetRoot().DescendantNodes().OfType<MemberAccessExpressionSyntax>())
+                .Where(memberAccess => Generator.methods.Contains(memberAccess.Name.Identifier.ValueText))
+                .ToList();
+
+            // Act
+            var builder = new CodeBuilder { IsUnitTest = true };
+            Generator.GenerateSource(compilation, typeSymbolsCache, memberAccessExpressions, builder, CancellationToken.None);
+            var result = builder.ToString();
+
+            // Assert
+#if NET5_0_OR_GREATER            
+            _ = result.Must()
+                .BeEqualTo(await File.ReadAllTextAsync(expected));
+#else
+            _ = result.Must()
+                .BeEqualTo(File.ReadAllText(expected));
+#endif
+        }
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj b/NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj
index 0158308fc..39ba44d1e 100644
--- a/NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj
+++ b/NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj
@@ -1,32 +1,32 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp2.1;netcoreapp3.1;net6.0</TargetFrameworks>
+    <TargetFramework>net6.0</TargetFramework>
+
     <IsPackable>false</IsPackable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
-  
+
+  <PropertyGroup>
+    <DefineConstants>NOT_TESTING</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
+    <PackageReference Include="Ben.TypeDictionary" Version="0.1.4" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="3.11.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.11.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
-    <PackageReference Include="NetFabric.Assertive" Version="3.0.1" />
-    <PackageReference Include="NetFabric.Hyperlinq.Analyzer" Version="2.0.3">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="System.Interactive" Version="5.0.0" />
+    <PackageReference Include="NetFabric.Assertive" Version="4.0.0" />
+    <PackageReference Include="NetFabric.CodeAnalysis" Version="4.0.2" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.0.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net48' Or '$(TargetFramework)'=='netcoreapp2.1'">
-    <ProjectReference Include="..\NetFabric.Hyperlinq.Immutable\NetFabric.Hyperlinq.Immutable.csproj" />
-    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -34,7 +34,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <DotNetCliToolReference Include="dotnet-reportgenerator-cli" Version="4.3.8" />
+    <Compile Update="TestData\**">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Compile>
   </ItemGroup>
 
 </Project>
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs
new file mode 100644
index 000000000..c5d1c5ad6
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs
@@ -0,0 +1,43 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+    //public static AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_<TestEnumerableWithValueTypeEnumerator<TestValueType>> AsValueEnumerable(this TestEnumerableWithValueTypeEnumerator<TestValueType> source)
+    //    => new(source, source);
+
+    //public readonly struct AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_<TEnumerable>
+    //    : IValueEnumerable<TestValueType, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator>
+    //    where TEnumerable : IEnumerable<TestValueType>
+    //{
+    //    readonly TestEnumerableWithValueTypeEnumerator<TestValueType> source;
+    //    readonly TEnumerable source2;
+
+    //    internal AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_(TestEnumerableWithValueTypeEnumerator<TestValueType> source, TEnumerable source2)
+    //        => (this.source, this.source2) = (source, source2);
+
+    //    // Implement IValueEnumerable<TestValueType, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator>
+
+    //    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    //    public TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+    //    IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => source2.GetEnumerator();
+
+    //    IEnumerator IEnumerable.GetEnumerator() => source2.GetEnumerator();
+    //}
+
+    public static GeneratedExtensionMethods.AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_ AsEnumerable(this GeneratedExtensionMethods.AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_ source)
+        => NetFabric.Hyperlinq.ValueEnumerableExtensions.AsEnumerable<GeneratedExtensionMethods.AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator, TestValueType>(source);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.IReadOnlyList.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.IReadOnlyList.cs
new file mode 100644
index 000000000..fc53886f4
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.IReadOnlyList.cs
@@ -0,0 +1,133 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_System_Collections_Generic_IReadOnlyList_TestValueType_ AsValueEnumerable(this System.Collections.Generic.IReadOnlyList<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_System_Collections_Generic_IReadOnlyList_TestValueType_
+        : IValueReadOnlyList<TestValueType, ValueEnumerator<TestValueType>>, IList<TestValueType>
+    {
+        readonly System.Collections.Generic.IReadOnlyList<TestValueType> source;
+
+        internal AsValueEnumerable_System_Collections_Generic_IReadOnlyList_TestValueType_(System.Collections.Generic.IReadOnlyList<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, ValueEnumerator<TestValueType>>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueEnumerator<TestValueType> GetEnumerator() => new(source.GetEnumerator());
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();
+
+        // Implement ICollection<TestValueType>
+
+        public int Count => source.Count;
+
+        public bool IsReadOnly => true;
+
+        void ICollection<TestValueType>.Add(TestValueType item) => throw new NotSupportedException();
+
+        bool ICollection<TestValueType>.Remove(TestValueType item) => throw new NotSupportedException();
+
+        void ICollection<TestValueType>.Clear() => throw new NotSupportedException();
+
+        public bool Contains(TestValueType item)
+        {
+            if (Count is 0)
+                return false;
+
+            if (source is ICollection<TestValueType> collection)
+                return collection.Contains(item);
+
+            using var enumerator = GetEnumerator();
+            while (enumerator.MoveNext())
+            {
+                if (EqualityComparer<TestValueType>.Default.Equals(enumerator.Current, item))
+                    return true;
+            }
+            return false;
+        }
+
+        public void CopyTo(TestValueType[] array, int arrayIndex)
+        {
+            if (Count is 0)
+                return;
+
+            if (array.Length - arrayIndex < Count)
+                throw new ArgumentException("Destination array was not long enough. Check the destination index, length, and the array's lower bounds.", nameof(array));
+
+            if (source is ICollection<TestValueType> collection)
+            {
+                collection.CopyTo(array, arrayIndex);
+                return;
+            }
+
+            using var enumerator = GetEnumerator();
+            if (arrayIndex is 0 && array.Length == Count)
+            {
+                for (var index = 0; index < array.Length && enumerator.MoveNext(); index++)
+                    array[index] = enumerator.Current;
+            }
+            else
+            {
+                checked
+                {
+                    for (var index = arrayIndex; enumerator.MoveNext(); index++)
+                        array[index] = enumerator.Current;
+                }
+            }
+        }
+
+        // Implement IList<TestValueType>
+
+        public TestValueType this[int index] => source[index];
+
+        TestValueType IList<TestValueType>.this[int index]
+        {
+            get => source[index];
+            set => throw new NotSupportedException();
+        }
+
+        void IList<TestValueType>.Insert(int index, TestValueType item) => throw new NotSupportedException();
+
+        void IList<TestValueType>.RemoveAt(int index) => throw new NotSupportedException();
+
+        public int IndexOf(TestValueType item)
+        {
+            if (Count is not 0)
+            {
+                if (source is IList<TestValueType> list)
+                    return list.IndexOf(item);
+
+                checked
+                {
+                    var index = 0;
+                    foreach (var current in source)
+                    {
+                        if (EqualityComparer<TestValueType>.Default.Equals(current, item))
+                            return index;
+
+                        index++;
+                    }
+                }
+            }
+            return -1;
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.Repeat.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.Repeat.cs
new file mode 100644
index 000000000..0c28f1d9f
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.Repeat.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NetFabric.Hyperlinq.ValueEnumerable.RepeatEnumerable<int> AsValueEnumerable(this NetFabric.Hyperlinq.ValueEnumerable.RepeatEnumerable<int> source)
+        => source;
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestCollection.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestCollection.cs
new file mode 100644
index 000000000..b7dd4b562
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestCollection.cs
@@ -0,0 +1,56 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestCollection_TestValueType_ AsValueEnumerable(this TestCollection<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestCollection_TestValueType_
+        : IValueReadOnlyCollection<TestValueType, TestCollection<TestValueType>.Enumerator>, ICollection<TestValueType>
+    {
+        readonly TestCollection<TestValueType> source;
+
+        internal AsValueEnumerable_TestCollection_TestValueType_(TestCollection<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, TestCollection<TestValueType>.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TestCollection<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // Implement ICollection<TestValueType>
+
+        public int Count => source.Count;
+
+        public bool IsReadOnly => true;
+
+        void ICollection<TestValueType>.Add(TestValueType item) => throw new NotSupportedException();
+
+        bool ICollection<TestValueType>.Remove(TestValueType item) => throw new NotSupportedException();
+
+        void ICollection<TestValueType>.Clear() => throw new NotSupportedException();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Contains(TestValueType item) => source.Contains(item);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTo(TestValueType[] array, int arrayIndex) => source.CopyTo(array, arrayIndex);
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs
new file mode 100644
index 000000000..8b7764809
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs
@@ -0,0 +1,62 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestEnumerableWithInterfacelessPublicEnumerator_TestValueType_ AsValueEnumerable(this TestEnumerableWithInterfacelessPublicEnumerator<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestEnumerableWithInterfacelessPublicEnumerator_TestValueType_
+        : IValueEnumerable<TestValueType, AsValueEnumerable_TestEnumerableWithInterfacelessPublicEnumerator_TestValueType_.Enumerator>
+    {
+        readonly TestEnumerableWithInterfacelessPublicEnumerator<TestValueType> source;
+
+        internal AsValueEnumerable_TestEnumerableWithInterfacelessPublicEnumerator_TestValueType_(TestEnumerableWithInterfacelessPublicEnumerator<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, AsValueEnumerable_TestEnumerableWithInterfacelessPublicEnumerator_TestValueType_.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Enumerator GetEnumerator() => new(source.GetEnumerator());
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public struct Enumerator : IEnumerator<TestValueType>
+        {
+            readonly TestEnumerableWithInterfacelessPublicEnumerator<TestValueType>.Enumerator source;
+
+            internal Enumerator(TestEnumerableWithInterfacelessPublicEnumerator<TestValueType>.Enumerator source)
+                => this.source = source;
+
+            public TestValueType Current
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => source.Current;
+            }
+
+            object? IEnumerator.Current => source.Current;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool MoveNext() => source.MoveNext();
+
+            public void Reset() => throw new NotSupportedException();
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Dispose() { }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs
new file mode 100644
index 000000000..ac52dc301
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs
@@ -0,0 +1,62 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestEnumerableWithNoInterfaces_TestValueType_ AsValueEnumerable(this TestEnumerableWithNoInterfaces<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestEnumerableWithNoInterfaces_TestValueType_
+        : IValueEnumerable<TestValueType, AsValueEnumerable_TestEnumerableWithNoInterfaces_TestValueType_.Enumerator>
+    {
+        readonly TestEnumerableWithNoInterfaces<TestValueType> source;
+
+        internal AsValueEnumerable_TestEnumerableWithNoInterfaces_TestValueType_(TestEnumerableWithNoInterfaces<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, AsValueEnumerable_TestEnumerableWithNoInterfaces_TestValueType_.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Enumerator GetEnumerator() => new(source.GetEnumerator());
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public struct Enumerator : IEnumerator<TestValueType>
+        {
+            readonly TestEnumerableWithNoInterfaces<TestValueType>.Enumerator source;
+
+            internal Enumerator(TestEnumerableWithNoInterfaces<TestValueType>.Enumerator source)
+                => this.source = source;
+
+            public TestValueType Current
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => source.Current;
+            }
+
+            object? IEnumerator.Current => source.Current;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool MoveNext() => source.MoveNext();
+
+            public void Reset() => throw new NotSupportedException();
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Dispose() { }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs
new file mode 100644
index 000000000..13eca99d5
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs
@@ -0,0 +1,63 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose_TestValueType_ AsValueEnumerable(this TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose_TestValueType_
+        : IValueEnumerable<TestValueType, AsValueEnumerable_TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose_TestValueType_.Enumerator>
+    {
+        readonly TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<TestValueType> source;
+
+        internal AsValueEnumerable_TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose_TestValueType_(TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, AsValueEnumerable_TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose_TestValueType_.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Enumerator GetEnumerator() => new(source.GetEnumerator());
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public struct Enumerator : IEnumerator<TestValueType>
+        {
+            readonly TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<TestValueType>.Enumerator source;
+
+            internal Enumerator(TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<TestValueType>.Enumerator source)
+                => this.source = source;
+
+            public TestValueType Current
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => source.Current;
+            }
+
+            object? IEnumerator.Current => source.Current;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool MoveNext() => source.MoveNext();
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Reset() => source.Reset();
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Dispose() => source.Dispose();
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs
new file mode 100644
index 000000000..407d1fa67
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs
@@ -0,0 +1,38 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestEnumerableWithReferenceTypeEnumerator_TestValueType_ AsValueEnumerable(this TestEnumerableWithReferenceTypeEnumerator<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestEnumerableWithReferenceTypeEnumerator_TestValueType_
+        : IValueEnumerable<TestValueType, ValueEnumerator<TestValueType>>
+    {
+        readonly TestEnumerableWithReferenceTypeEnumerator<TestValueType> source;
+
+        internal AsValueEnumerable_TestEnumerableWithReferenceTypeEnumerator_TestValueType_(TestEnumerableWithReferenceTypeEnumerator<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, ValueEnumerator<TestValueType>>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueEnumerator<TestValueType> GetEnumerator() => new(source.GetEnumerator());
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs
new file mode 100644
index 000000000..2e787b696
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs
@@ -0,0 +1,38 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_ AsValueEnumerable(this TestEnumerableWithValueTypeEnumerator<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_
+        : IValueEnumerable<TestValueType, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator>
+    {
+        readonly TestEnumerableWithValueTypeEnumerator<TestValueType> source;
+
+        internal AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_(TestEnumerableWithValueTypeEnumerator<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestList.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestList.cs
new file mode 100644
index 000000000..fcbae6d1f
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestList.cs
@@ -0,0 +1,73 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestList_TestValueType_ AsValueEnumerable(this TestList<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestList_TestValueType_
+        : IValueReadOnlyList<TestValueType, TestList<TestValueType>.Enumerator>, IList<TestValueType>
+    {
+        readonly TestList<TestValueType> source;
+
+        internal AsValueEnumerable_TestList_TestValueType_(TestList<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, TestList<TestValueType>.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TestList<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // Implement ICollection<TestValueType>
+
+        public int Count => source.Count;
+
+        public bool IsReadOnly => true;
+
+        void ICollection<TestValueType>.Add(TestValueType item) => throw new NotSupportedException();
+
+        bool ICollection<TestValueType>.Remove(TestValueType item) => throw new NotSupportedException();
+
+        void ICollection<TestValueType>.Clear() => throw new NotSupportedException();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Contains(TestValueType item) => source.Contains(item);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTo(TestValueType[] array, int arrayIndex) => source.CopyTo(array, arrayIndex);
+
+        // Implement IList<TestValueType>
+
+        public TestValueType this[int index] => source[index];
+
+        TestValueType IList<TestValueType>.this[int index]
+        {
+            get => source[index];
+            set => throw new NotSupportedException();
+        }
+
+        void IList<TestValueType>.Insert(int index, TestValueType item) => throw new NotSupportedException();
+
+        void IList<TestValueType>.RemoveAt(int index) => throw new NotSupportedException();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int IndexOf(TestValueType item) => source.IndexOf(item);
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestListWithExplicitInterfaces.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestListWithExplicitInterfaces.cs
new file mode 100644
index 000000000..c1a97176e
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestListWithExplicitInterfaces.cs
@@ -0,0 +1,87 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestListWithExplicitInterfaces_TestValueType_<TestListWithExplicitInterfaces<TestValueType>> AsValueEnumerable(this TestListWithExplicitInterfaces<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestListWithExplicitInterfaces_TestValueType_<TEnumerable>
+        : IValueReadOnlyList<TestValueType, ValueEnumerator<TestValueType>>, IList<TestValueType>
+        where TEnumerable : IList<TestValueType>
+    {
+        readonly TEnumerable source;
+
+        internal AsValueEnumerable_TestListWithExplicitInterfaces_TestValueType_(TEnumerable source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, ValueEnumerator<TestValueType>>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueEnumerator<TestValueType> GetEnumerator() => new(source.GetEnumerator());
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();
+
+        // Implement ICollection<TestValueType>
+
+        public int Count => source.Count;
+
+        public bool IsReadOnly => true;
+
+        void ICollection<TestValueType>.Add(TestValueType item) => throw new NotSupportedException();
+
+        bool ICollection<TestValueType>.Remove(TestValueType item) => throw new NotSupportedException();
+
+        void ICollection<TestValueType>.Clear() => throw new NotSupportedException();
+
+        public void CopyTo(Span<TestValueType> span)
+        {
+            if (Count is 0) return;
+            if (span.Length < Count) throw new ArgumentException("Destination span was not long enough.", nameof(span));
+
+            var index = 0;
+            foreach (var current in this)
+            {
+                span[index] = current;
+                checked { index++; }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Contains(TestValueType item) => source.Contains(item);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTo(TestValueType[] array, int arrayIndex) => source.CopyTo(array, arrayIndex);
+
+        // Implement IList<TestValueType>
+
+        public TestValueType this[int index] => source[index];
+
+        TestValueType IList<TestValueType>.this[int index]
+        {
+            get => source[index];
+            set => throw new NotSupportedException();
+        }
+
+        void IList<TestValueType>.Insert(int index, TestValueType item) => throw new NotSupportedException();
+
+        void IList<TestValueType>.RemoveAt(int index) => throw new NotSupportedException();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int IndexOf(TestValueType item) => source.IndexOf(item);
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestReadOnlyCollection.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestReadOnlyCollection.cs
new file mode 100644
index 000000000..a1e9b7b6c
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestReadOnlyCollection.cs
@@ -0,0 +1,88 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestReadOnlyCollection_TestValueType_ AsValueEnumerable(this TestReadOnlyCollection<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestReadOnlyCollection_TestValueType_
+        : IValueReadOnlyCollection<TestValueType, TestReadOnlyCollection<TestValueType>.Enumerator>, ICollection<TestValueType>
+    {
+        readonly TestReadOnlyCollection<TestValueType> source;
+
+        internal AsValueEnumerable_TestReadOnlyCollection_TestValueType_(TestReadOnlyCollection<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, TestReadOnlyCollection<TestValueType>.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TestReadOnlyCollection<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // Implement ICollection<TestValueType>
+
+        public int Count => source.Count;
+
+        public bool IsReadOnly => true;
+
+        void ICollection<TestValueType>.Add(TestValueType item) => throw new NotSupportedException();
+
+        bool ICollection<TestValueType>.Remove(TestValueType item) => throw new NotSupportedException();
+
+        void ICollection<TestValueType>.Clear() => throw new NotSupportedException();
+
+        public bool Contains(TestValueType item)
+        {
+            if (Count is 0)
+                return false;
+
+            using var enumerator = GetEnumerator();
+            while (enumerator.MoveNext())
+            {
+                if (EqualityComparer<TestValueType>.Default.Equals(enumerator.Current, item))
+                    return true;
+            }
+            return false;
+        }
+
+        public void CopyTo(TestValueType[] array, int arrayIndex)
+        {
+            if (Count is 0)
+                return;
+
+            if (array.Length - arrayIndex < Count)
+                throw new ArgumentException("Destination array was not long enough. Check the destination index, length, and the array's lower bounds.", nameof(array));
+
+            using var enumerator = GetEnumerator();
+            if (arrayIndex is 0 && array.Length == Count)
+            {
+                for (var index = 0; index < array.Length && enumerator.MoveNext(); index++)
+                    array[index] = enumerator.Current;
+            }
+            else
+            {
+                checked
+                {
+                    for (var index = arrayIndex; enumerator.MoveNext(); index++)
+                        array[index] = enumerator.Current;
+                }
+            }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestReadOnlyList.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestReadOnlyList.cs
new file mode 100644
index 000000000..2aa13a609
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestReadOnlyList.cs
@@ -0,0 +1,121 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static AsValueEnumerable_TestReadOnlyList_TestValueType_ AsValueEnumerable(this TestReadOnlyList<TestValueType> source)
+        => new(source);
+
+    public readonly struct AsValueEnumerable_TestReadOnlyList_TestValueType_
+        : IValueReadOnlyList<TestValueType, TestReadOnlyList<TestValueType>.Enumerator>, IList<TestValueType>
+    {
+        readonly TestReadOnlyList<TestValueType> source;
+
+        internal AsValueEnumerable_TestReadOnlyList_TestValueType_(TestReadOnlyList<TestValueType> source)
+            => this.source = source;
+
+        // Implement IValueEnumerable<TestValueType, TestReadOnlyList<TestValueType>.Enumerator>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TestReadOnlyList<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+        IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        // Implement ICollection<TestValueType>
+
+        public int Count => source.Count;
+
+        public bool IsReadOnly => true;
+
+        void ICollection<TestValueType>.Add(TestValueType item) => throw new NotSupportedException();
+
+        bool ICollection<TestValueType>.Remove(TestValueType item) => throw new NotSupportedException();
+
+        void ICollection<TestValueType>.Clear() => throw new NotSupportedException();
+
+        public bool Contains(TestValueType item)
+        {
+            if (Count is 0)
+                return false;
+
+            using var enumerator = GetEnumerator();
+            while (enumerator.MoveNext())
+            {
+                if (EqualityComparer<TestValueType>.Default.Equals(enumerator.Current, item))
+                    return true;
+            }
+            return false;
+        }
+
+        public void CopyTo(TestValueType[] array, int arrayIndex)
+        {
+            if (Count is 0)
+                return;
+
+            if (array.Length - arrayIndex < Count)
+                throw new ArgumentException("Destination array was not long enough. Check the destination index, length, and the array's lower bounds.", nameof(array));
+
+            using var enumerator = GetEnumerator();
+            if (arrayIndex is 0 && array.Length == Count)
+            {
+                for (var index = 0; index < array.Length && enumerator.MoveNext(); index++)
+                    array[index] = enumerator.Current;
+            }
+            else
+            {
+                checked
+                {
+                    for (var index = arrayIndex; enumerator.MoveNext(); index++)
+                        array[index] = enumerator.Current;
+                }
+            }
+        }
+
+        // Implement IList<TestValueType>
+
+        public TestValueType this[int index] => source[index];
+
+        TestValueType IList<TestValueType>.this[int index]
+        {
+            get => source[index];
+            set => throw new NotSupportedException();
+        }
+
+        void IList<TestValueType>.Insert(int index, TestValueType item) => throw new NotSupportedException();
+
+        void IList<TestValueType>.RemoveAt(int index) => throw new NotSupportedException();
+
+        public int IndexOf(TestValueType item)
+        {
+            if (Count is not 0)
+            {
+                checked
+                {
+                    var index = 0;
+                    foreach (var current in source)
+                    {
+                        if (EqualityComparer<TestValueType>.Default.Equals(current, item))
+                            return index;
+
+                        index++;
+                    }
+                }
+            }
+            return -1;
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestValueEnumerable.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestValueEnumerable.cs
new file mode 100644
index 000000000..c3f0ec230
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/AsValueEnumerable.TestValueEnumerable.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TestValueEnumerable<TestValueType> AsValueEnumerable(this TestValueEnumerable<TestValueType> source)
+        => source;
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Count.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Count.Array.cs
new file mode 100644
index 000000000..a640141f5
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Count.Array.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Count(this NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType> source, System.Func<TestValueType, bool> predicate)
+        => NetFabric.Hyperlinq.ValueReadOnlyListExtensions.Count<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType, NetFabric.Hyperlinq.FunctionWrapper<TestValueType, bool>>(source, predicate);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Count.Span.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Count.Span.cs
new file mode 100644
index 000000000..53c5b7c63
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Count.Span.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Count(this NetFabric.Hyperlinq.ArrayExtensions.SpanValueEnumerable<int> source, Func<int, bool> predicate) 
+        => NetFabric.Hyperlinq.ArrayExtensions.Count(source.Span, predicate);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Empty.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Empty.cs
new file mode 100644
index 000000000..dbe7e1354
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Empty.cs
@@ -0,0 +1,16 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Select.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Select.Array.cs
new file mode 100644
index 000000000..af70ff565
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Select.Array.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NetFabric.Hyperlinq.ValueReadOnlyListExtensions.SelectEnumerable<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType, TestReferenceType, NetFabric.Hyperlinq.FunctionWrapper<TestValueType, TestReferenceType>> Select(this NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType> source, System.Func<TestValueType, TestReferenceType> selector)
+        => NetFabric.Hyperlinq.ValueReadOnlyListExtensions.Select<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType, TestReferenceType>(source, selector);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Select.TestEnumerableWithValueTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Select.TestEnumerableWithValueTypeEnumerator.cs
new file mode 100644
index 000000000..2410968fe
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Select.TestEnumerableWithValueTypeEnumerator.cs
@@ -0,0 +1,45 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+    //public static AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_<TestEnumerableWithValueTypeEnumerator<TestValueType>> AsValueEnumerable(this TestEnumerableWithValueTypeEnumerator<TestValueType> source)
+    //    => new(source, source);
+
+    //public readonly struct AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_<TEnumerable>
+    //    : IValueEnumerable<TestValueType, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator>
+    //    where TEnumerable : IEnumerable<TestValueType>
+    //{
+    //    readonly TestEnumerableWithValueTypeEnumerator<TestValueType> source;
+    //    readonly TEnumerable source2;
+
+    //    internal AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_(TestEnumerableWithValueTypeEnumerator<TestValueType> source, TEnumerable source2)
+    //        => (this.source, this.source2) = (source, source2);
+
+    //    // Implement IValueEnumerable<TestValueType, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator>
+
+    //    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    //    public TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator GetEnumerator() => source.GetEnumerator();
+
+    //    IEnumerator<TestValueType> IEnumerable<TestValueType>.GetEnumerator() => source2.GetEnumerator();
+
+    //    IEnumerator IEnumerable.GetEnumerator() => source2.GetEnumerator();
+    //}
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ValueEnumerableExtensions.SelectEnumerable<GeneratedExtensionMethods.AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator, TestValueType, TestReferenceType, NetFabric.Hyperlinq.FunctionWrapper<TestValueType, TestReferenceType>> Select(this GeneratedExtensionMethods.AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_ source, System.Func<TestValueType, TestReferenceType> selector)
+        => NetFabric.Hyperlinq.ValueEnumerableExtensions.Select<GeneratedExtensionMethods.AsValueEnumerable_TestEnumerableWithValueTypeEnumerator_TestValueType_, TestEnumerableWithValueTypeEnumerator<TestValueType>.Enumerator, TestValueType, TestReferenceType, NetFabric.Hyperlinq.FunctionWrapper<TestValueType, TestReferenceType>>(source, selector);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Skip.Take.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Skip.Take.Array.cs
new file mode 100644
index 000000000..b26994268
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Skip.Take.Array.cs
@@ -0,0 +1,24 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NetFabric.Hyperlinq.ValueReadOnlyCollectionExtensions.SkipTakeEnumerable<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType> Skip(this NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType> source, int count)
+        => NetFabric.Hyperlinq.ValueReadOnlyListExtensions.Skip<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType>(source, count);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NetFabric.Hyperlinq.ValueReadOnlyCollectionExtensions.SkipTakeEnumerable<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType> Take(this NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType> source, int count)
+        => NetFabric.Hyperlinq.ValueReadOnlyCollectionExtensions.Take<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType>(source, count);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Results/Where.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Where.Array.cs
new file mode 100644
index 000000000..e3626ae0d
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Results/Where.Array.cs
@@ -0,0 +1,20 @@
+#nullable enable
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace NetFabric.Hyperlinq;
+
+static partial class GeneratedExtensionMethods
+{
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static NetFabric.Hyperlinq.ValueReadOnlyCollectionExtensions.WhereEnumerable<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType, NetFabric.Hyperlinq.FunctionWrapper<TestValueType, bool>> Where(this NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType> source, System.Func<TestValueType, bool> selector)
+        => NetFabric.Hyperlinq.ValueReadOnlyListExtensions.Where<NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>, NetFabric.Hyperlinq.ArrayExtensions.ArraySegmentValueEnumerable<TestValueType>.DisposableEnumerator, TestValueType, NetFabric.Hyperlinq.FunctionWrapper<TestValueType, bool>>(source, selector);
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs
new file mode 100644
index 000000000..c95d5f829
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsEnumerable.TestEnumerableWithValueTypeEnumerator.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Count_TestEnumerableWithValueTypeEnumerator()
+    {
+        _ = new TestEnumerableWithValueTypeEnumerator<TestValueType>()
+            .AsValueEnumerable()
+            .AsEnumerable();
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty.cs
new file mode 100644
index 000000000..0b0b74e93
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty.cs
@@ -0,0 +1,28 @@
+using System;
+//using NetFabric.Hyperlinq; => DO NOT UNCOMMENT
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_Empty()
+    {
+        // test calling AsValueEnumerable() for types that don't need source generation
+        // with NetFabric.Hyperlinq namespace NOT in a using clause 
+
+#if !NOT_TESTING
+        var array = Array.Empty<int>();
+
+        _ = array.AsValueEnumerable();
+        _ = new ArraySegment<int>(array).AsValueEnumerable();
+
+        _ = array.AsMemory().AsValueEnumerable();
+        _ = ((ReadOnlyMemory<int>)array.AsMemory()).AsValueEnumerable();
+
+        _ = array.AsSpan().AsValueEnumerable();
+        _ = ((ReadOnlySpan<int>)array.AsSpan()).AsValueEnumerable();
+
+        var list = new List<int>();
+        _ = list.AsValueEnumerable();
+#endif
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty2.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty2.cs
new file mode 100644
index 000000000..6c0371f60
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty2.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using NetFabric.Hyperlinq; // namespace is known at compile time 
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_Empty2()
+    {
+        // test calling AsValueEnumerable() for types that don't need source generation
+
+        var array = Array.Empty<int>();
+
+        _ = array.AsValueEnumerable();
+        _ = ArrayExtensions.AsValueEnumerable(array);
+        _ = new ArraySegment<int>(array).AsValueEnumerable();
+
+        _ = array.AsMemory().AsValueEnumerable();
+        _ = ((ReadOnlyMemory<int>)array.AsMemory()).AsValueEnumerable();
+
+        _ = array.AsSpan().AsValueEnumerable();
+        _ = ((ReadOnlySpan<int>)array.AsSpan()).AsValueEnumerable();
+
+        var list = new List<int>();
+        _ = list.AsValueEnumerable();
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty3.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty3.cs
new file mode 100644
index 000000000..d7d379d2c
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Empty3.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq; // namespace is known at compile time 
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_Empty3()
+    {
+        var valueEnumerable = Array
+            .Empty<int>()
+            .AsValueEnumerable();
+
+        _ = Enumerable.Count(valueEnumerable);
+        _ = Enumerable.Count(valueEnumerable, _ => true);
+        _ = Enumerable.Take(Enumerable.Skip(valueEnumerable, 1), 2);
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.IReadOnlyList.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.IReadOnlyList.cs
new file mode 100644
index 000000000..33b500a91
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.IReadOnlyList.cs
@@ -0,0 +1,17 @@
+using NetFabric.Hyperlinq;
+using System.Collections.Generic;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_IReadOnlyList()
+    {
+        // test calling AsValueEnumerable() on an IReadOnlyList<>
+        IReadOnlyList<TestValueType> list = new TestReadOnlyList<TestValueType>();
+        _ = list.AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Repeat.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Repeat.cs
new file mode 100644
index 000000000..834978c04
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.Repeat.cs
@@ -0,0 +1,13 @@
+using System;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_Repeat()
+    {
+        // test calling AsValueEnumerable() for types that implement IValueEnumerable<,>
+
+        _ = ValueEnumerable.Repeat(0, 100).AsValueEnumerable();
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestCollection.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestCollection.cs
new file mode 100644
index 000000000..c66f27f10
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestCollection.cs
@@ -0,0 +1,15 @@
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_Collection()
+    {
+        // test calling AsValueEnumerable() on an implementation of ICollection<>
+        _ = new TestCollection<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs
new file mode 100644
index 000000000..d9734c3b4
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithInterfacelessPublicEnumerator.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_TestEnumerableWithInterfacelessPublicEnumerator()
+    {
+        // test calling AsValueEnumerable() for types that implement IEnumerable<>
+        // but the public GetEnumerator() returns a type that doesn't implement IEnumerator<>
+
+        _ = new TestEnumerableWithInterfacelessPublicEnumerator<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs
new file mode 100644
index 000000000..12071aee1
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfaces.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_TestEnumerableWithNoInterfaces()
+    {
+        // test calling AsValueEnumerable() for types that do not implement IEnumerable<>
+        // but the public GetEnumerator() returns a type that doesn't implement IEnumerator<>
+
+        _ = new TestEnumerableWithNoInterfaces<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs
new file mode 100644
index 000000000..7554e76fe
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose()
+    {
+        // test calling AsValueEnumerable() for types that do not implement IEnumerable<>
+        // and the public GetEnumerator() returns a type that implement IDisposable and has a Reset() method
+
+        _ = new TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs
new file mode 100644
index 000000000..304df9a9d
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithReferenceTypeEnumerator.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_TestEnumerableWithReferenceTypeEnumerator()
+    {
+        // test calling AsValueEnumerable() for types that implement IEnumerable<> and the enumerator is not a value type
+
+        _ = new TestEnumerableWithReferenceTypeEnumerator<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs
new file mode 100644
index 000000000..1ff2412ec
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestEnumerableWithValueTypeEnumerator.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_EnumerableWithValueTypeEnumerator()
+    {
+        // test calling AsValueEnumerable() for types that implement IEnumerable<> and the enumerator is a value type
+
+        _ = new TestEnumerableWithValueTypeEnumerator<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestList.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestList.cs
new file mode 100644
index 000000000..f1421d0ab
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestList.cs
@@ -0,0 +1,15 @@
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_List()
+    {
+        // test calling AsValueEnumerable() on an implementation of IList<>
+        _ = new TestList<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestListWithExplicitInterfaces.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestListWithExplicitInterfaces.cs
new file mode 100644
index 000000000..72d84d63f
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestListWithExplicitInterfaces.cs
@@ -0,0 +1,15 @@
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_ReadOnlyListWithExplicitInterfaces()
+    {
+        // test calling AsValueEnumerable() on an IValueEnumerable
+        _ = new TestListWithExplicitInterfaces<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestReadOnlyCollection.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestReadOnlyCollection.cs
new file mode 100644
index 000000000..15c9cce44
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestReadOnlyCollection.cs
@@ -0,0 +1,15 @@
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_ReadOnlyCollection()
+    {
+        // test calling AsValueEnumerable() on an IValueEnumerable
+        _ = new TestReadOnlyCollection<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestReadOnlyList.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestReadOnlyList.cs
new file mode 100644
index 000000000..cb02ca0d8
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestReadOnlyList.cs
@@ -0,0 +1,15 @@
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_ReadOnlyList()
+    {
+        // test calling AsValueEnumerable() on an IValueEnumerable
+        _ = new TestReadOnlyList<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestValueEnumerable.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestValueEnumerable.cs
new file mode 100644
index 000000000..fbb432ef8
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/AsValueEnumerable.TestValueEnumerable.cs
@@ -0,0 +1,15 @@
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void AsValueEnumerable_ValueEnumerable()
+    {
+        // test calling AsValueEnumerable() on an IValueEnumerable
+        _ = new TestValueEnumerable<TestValueType>().AsValueEnumerable();
+    }
+}
+
+
+
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/Enumerables.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/Enumerables.cs
new file mode 100644
index 000000000..283f0f9df
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/Enumerables.cs
@@ -0,0 +1,327 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+public class TestEnumerableWithNoInterfaces<T>
+{
+    public Enumerator GetEnumerator()
+        => new();
+
+    public readonly struct Enumerator
+    {
+        public T Current
+            => default!;
+
+        public bool MoveNext()
+            => false;
+    }
+}
+
+public class TestEnumerableWithNoInterfacesButEnumeratorWithResetAndDispose<T>
+{
+    public Enumerator GetEnumerator()
+        => new();
+
+    public readonly struct Enumerator
+        : IDisposable
+    {
+        public T Current
+            => default!;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+
+        public void Dispose()
+        { }
+    }
+}
+
+public readonly struct TestEnumerableWithInterfacelessPublicEnumerator<T>
+    : IEnumerable<T>
+{
+    public Enumerator GetEnumerator()
+        => new();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new DisposableEnumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new DisposableEnumerator();
+
+    public struct Enumerator
+    {
+        public T Current
+            => default!;
+
+        public bool MoveNext()
+            => false;
+    }
+
+    class DisposableEnumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+public readonly struct TestEnumerableWithValueTypeEnumerator<T>
+    : IEnumerable<T>
+{
+    public Enumerator GetEnumerator()
+        => new();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    public readonly struct Enumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+
+public readonly struct TestEnumerableWithReferenceTypeEnumerator<T>
+    : IEnumerable<T>
+{
+    public IEnumerator<T> GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    class Enumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+public readonly struct TestReadOnlyCollection<T>
+    : IReadOnlyCollection<T>
+{
+    public int Count => default;
+
+    public Enumerator GetEnumerator()
+        => new();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    public readonly struct Enumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+public readonly struct TestCollection<T>
+    : ICollection<T>
+{
+    public int Count => default;
+
+    public bool IsReadOnly => true;
+    public bool Contains(T item) => default;
+    public void CopyTo(T[] array, int arrayIndex) { }
+    void ICollection<T>.Add(T item) => throw new NotSupportedException();
+    bool ICollection<T>.Remove(T item) => throw new NotSupportedException();
+    void ICollection<T>.Clear() => throw new NotSupportedException();
+
+    public Enumerator GetEnumerator()
+        => new();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    public readonly struct Enumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+public readonly struct TestReadOnlyList<T>
+    : IReadOnlyList<T>
+{
+    public int Count => default;
+
+    public T this[int index] => default!;
+
+    public Enumerator GetEnumerator()
+        => new();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    public readonly struct Enumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+public readonly struct TestList<T>
+    : IList<T>
+{
+    public int Count => default;
+
+    public bool IsReadOnly => true;
+
+    public T this[int index] 
+    { 
+        get => default!; 
+        set => throw new NotSupportedException(); 
+    }
+
+    public bool Contains(T item) => default;
+    public void CopyTo(T[] array, int arrayIndex) { }
+    void ICollection<T>.Add(T item) => throw new NotSupportedException();
+    bool ICollection<T>.Remove(T item) => throw new NotSupportedException();
+    void ICollection<T>.Clear() => throw new NotSupportedException();
+
+    public int IndexOf(T item) => -1;
+    void IList<T>.Insert(int index, T item) => throw new NotSupportedException();
+    void IList<T>.RemoveAt(int index) => throw new NotSupportedException();
+
+    public Enumerator GetEnumerator()
+        => new();
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    public readonly struct Enumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
+
+
+public readonly struct TestListWithExplicitInterfaces<T>
+    : IList<T>
+{
+    int ICollection<T>.Count => default;
+
+    bool ICollection<T>.IsReadOnly => true;
+
+    T IList<T>.this[int index]
+    {
+        get => default!;
+        set => throw new NotSupportedException();
+    }
+
+    bool ICollection<T>.Contains(T item) => default;
+    void ICollection<T>.CopyTo(T[] array, int arrayIndex) { }
+    void ICollection<T>.Add(T item) => throw new NotSupportedException();
+    bool ICollection<T>.Remove(T item) => throw new NotSupportedException();
+    void ICollection<T>.Clear() => throw new NotSupportedException();
+
+    int IList<T>.IndexOf(T item) => -1;
+    void IList<T>.Insert(int index, T item) => throw new NotSupportedException();
+    void IList<T>.RemoveAt(int index) => throw new NotSupportedException();
+
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new Enumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+        => new Enumerator();
+
+    class Enumerator
+        : IEnumerator<T>
+    {
+        T IEnumerator<T>.Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        bool IEnumerator.MoveNext()
+            => false;
+
+        void IEnumerator.Reset()
+        { }
+        void IDisposable.Dispose()
+        { }
+    }
+}
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/ItemTypes.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/ItemTypes.cs
new file mode 100644
index 000000000..1249d551d
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/ItemTypes.cs
@@ -0,0 +1,7 @@
+public struct TestValueType
+{
+}
+
+public class TestReferenceType
+{
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/ValueEnumerables.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/ValueEnumerables.cs
new file mode 100644
index 000000000..0819feb46
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Common/ValueEnumerables.cs
@@ -0,0 +1,45 @@
+using NetFabric.Hyperlinq;
+using System.Collections;
+using System.Collections.Generic;
+
+public class TestValueEnumerable<T>
+    : IValueEnumerable<T, TestValueEnumerable<T>.DisposableEnumerator>
+{
+    public Enumerator GetEnumerator()
+        => new();
+
+    DisposableEnumerator IValueEnumerable<T, DisposableEnumerator>.GetEnumerator()
+        => new();
+
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        => new DisposableEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator()
+        => new DisposableEnumerator();
+
+    public readonly struct Enumerator
+    {
+        public T Current
+            => default!;
+
+        public bool MoveNext()
+            => false;
+    }
+
+    public readonly struct DisposableEnumerator
+        : IEnumerator<T>
+    {
+        public T Current
+            => default!;
+        object? IEnumerator.Current
+            => default;
+
+        public bool MoveNext()
+            => false;
+
+        public void Reset()
+        { }
+        public void Dispose()
+        { }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Count.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Count.Array.cs
new file mode 100644
index 000000000..59af328dd
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Count.Array.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Count_ArraySegmentValueEnumerable()
+    {
+        _ = Array.Empty<TestValueType>()
+            .AsValueEnumerable()
+            .Count(_ => true);
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Count.Span.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Count.Span.cs
new file mode 100644
index 000000000..fc14b2aab
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Count.Span.cs
@@ -0,0 +1,16 @@
+using System;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Count_SpanValueEnumerable()
+    {
+#if !NOT_TESTING
+        _ = Array.Empty<int>().AsSpan()
+            .AsValueEnumerable()
+            .Count(_ => true);
+#endif
+    }
+}
+
+
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Select.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Select.Array.cs
new file mode 100644
index 000000000..3fd1cfea8
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Select.Array.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Select_ArraySegmentValueEnumerable()
+    {
+        _ = Array.Empty<TestValueType>()
+            .AsValueEnumerable()
+            .Select(_ => new TestReferenceType());
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Select.TestEnumerableWithValueTypeEnumerator.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Select.TestEnumerableWithValueTypeEnumerator.cs
new file mode 100644
index 000000000..32fd6358f
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Select.TestEnumerableWithValueTypeEnumerator.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Select_TestEnumerableWithValueTypeEnumerator()
+    {
+        _ = new TestEnumerableWithValueTypeEnumerator<TestValueType>()
+            .AsValueEnumerable()
+            .Select(_ => new TestReferenceType());
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Skip.Take.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Skip.Take.Array.cs
new file mode 100644
index 000000000..346966ae9
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Skip.Take.Array.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Skip_Take_ArraySegmentValueEnumerable()
+    {
+        _ = Array.Empty<TestValueType>()
+            .AsValueEnumerable()
+            .Skip(1)
+            .Take(2);
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/TestData/Source/Where.Array.cs b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Where.Array.cs
new file mode 100644
index 000000000..3062e609b
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/TestData/Source/Where.Array.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+using NetFabric.Hyperlinq;
+
+partial class TestsSource
+{
+    static void Where_ArraySegmentValueEnumerable()
+    {
+        _ = Array.Empty<TestValueType>()
+            .AsValueEnumerable()
+            .Where(_ => true);
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/Verifier.cs b/NetFabric.Hyperlinq.UnitTests/Verifier.cs
new file mode 100644
index 000000000..102ea391c
--- /dev/null
+++ b/NetFabric.Hyperlinq.UnitTests/Verifier.cs
@@ -0,0 +1,49 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+
+namespace NetFabric.Hyperlinq.SourceGenerator.UnitTests
+{
+    sealed class Verifier
+    {
+        static readonly string defaultFilePathPrefix = "Test";
+        static readonly string testProjectName = "TestProject";
+
+        public static Project CreateProject(IEnumerable<string> sources)
+        {
+            var projectId = ProjectId.CreateNewId(debugName: testProjectName);
+
+            var coreLibPath = typeof(object).Assembly.Location;
+            var coreLibDirectory = Path.GetDirectoryName(coreLibPath)!;
+            var references = new[] {
+                    MetadataReference.CreateFromFile(coreLibPath),
+                    MetadataReference.CreateFromFile(Path.Combine(coreLibDirectory, "netstandard.dll")),
+                    MetadataReference.CreateFromFile(Path.Combine(coreLibDirectory, "System.Runtime.dll")),
+                    MetadataReference.CreateFromFile(Path.Combine(coreLibDirectory, "System.Collections.dll")),
+                    MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
+                    MetadataReference.CreateFromFile(typeof(ImmutableArray<>).Assembly.Location),
+                    MetadataReference.CreateFromFile(typeof(IValueEnumerable<,>).Assembly.Location),
+                    MetadataReference.CreateFromFile(typeof(ValueEnumerableExtensions).Assembly.Location),
+                };
+            var solution = new AdhocWorkspace()
+                .CurrentSolution
+                .AddProject(projectId, testProjectName, testProjectName, LanguageNames.CSharp)
+                .AddMetadataReferences(projectId, references)
+                .WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+            var count = 0;
+            foreach (var source in sources)
+            {
+                var newFileName = defaultFilePathPrefix + count + ".cs";
+                var documentId = DocumentId.CreateNewId(projectId, debugName: newFileName);
+                solution = solution.AddDocument(documentId, newFileName, SourceText.From(source));
+                count++;
+            }
+            return solution.GetProject(projectId)!;
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.sln b/NetFabric.Hyperlinq.sln
index 77877123b..ee9b89340 100644
--- a/NetFabric.Hyperlinq.sln
+++ b/NetFabric.Hyperlinq.sln
@@ -1,12 +1,10 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.28516.95
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31423.177
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq", "NetFabric.Hyperlinq\NetFabric.Hyperlinq.csproj", "{EEEAA31B-434E-4849-A3E5-FA9664F5CE9B}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.UnitTests", "NetFabric.Hyperlinq.UnitTests\NetFabric.Hyperlinq.UnitTests.csproj", "{FE0CFD9E-7685-4595-8691-5364228722E9}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{2C452DA5-FE07-451C-BFE1-AD14A57F7B09}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
@@ -24,13 +22,13 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.Benchmarks", "NetFabric.Hyperlinq.Benchmarks\NetFabric.Hyperlinq.Benchmarks.csproj", "{02EE275F-6E2D-444A-AB1F-9BCD02DEA204}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.SourceGenerator", "NetFabric.Hyperlinq.SourceGenerator\NetFabric.Hyperlinq.SourceGenerator.csproj", "{B8C004E3-F59E-4017-8781-C0F99B61BDEF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.Abstractions", "NetFabric.Hyperlinq.Abstractions\NetFabric.Hyperlinq.Abstractions.csproj", "{6981E761-E698-437D-AF63-0E80844B7D41}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.SourceGenerator.UnitTests", "NetFabric.Hyperlinq.SourceGenerator.UnitTests\NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj", "{12F96462-A2F8-4FBE-B4F5-29BA6A6DB4D9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.Core", "NetFabric.Hyperlinq.Core\NetFabric.Hyperlinq.Core.csproj", "{9EA4EA87-7656-48BA-BE7F-E5CC1B48512D}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.Abstractions", "NetFabric.Hyperlinq.Abstractions\NetFabric.Hyperlinq.Abstractions.csproj", "{6981E761-E698-437D-AF63-0E80844B7D41}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.Core.UnitTests", "NetFabric.Hyperlinq.Core.UnitTests\NetFabric.Hyperlinq.Core.UnitTests.csproj", "{794C4984-BB46-4A50-9BC1-53831B5C8002}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.Immutable", "NetFabric.Hyperlinq.Immutable\NetFabric.Hyperlinq.Immutable.csproj", "{6CB7E269-91CB-47CC-BF9F-67956D5E0F7E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetFabric.Hyperlinq.UnitTests", "NetFabric.Hyperlinq.UnitTests\NetFabric.Hyperlinq.UnitTests.csproj", "{F0A7B925-30F2-4FAA-97E6-7848B3E104B6}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -42,30 +40,26 @@ Global
 		{EEEAA31B-434E-4849-A3E5-FA9664F5CE9B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{EEEAA31B-434E-4849-A3E5-FA9664F5CE9B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{EEEAA31B-434E-4849-A3E5-FA9664F5CE9B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FE0CFD9E-7685-4595-8691-5364228722E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FE0CFD9E-7685-4595-8691-5364228722E9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FE0CFD9E-7685-4595-8691-5364228722E9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FE0CFD9E-7685-4595-8691-5364228722E9}.Release|Any CPU.Build.0 = Release|Any CPU
 		{02EE275F-6E2D-444A-AB1F-9BCD02DEA204}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{02EE275F-6E2D-444A-AB1F-9BCD02DEA204}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{02EE275F-6E2D-444A-AB1F-9BCD02DEA204}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{02EE275F-6E2D-444A-AB1F-9BCD02DEA204}.Release|Any CPU.Build.0 = Release|Any CPU
-		{B8C004E3-F59E-4017-8781-C0F99B61BDEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B8C004E3-F59E-4017-8781-C0F99B61BDEF}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B8C004E3-F59E-4017-8781-C0F99B61BDEF}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{B8C004E3-F59E-4017-8781-C0F99B61BDEF}.Release|Any CPU.Build.0 = Release|Any CPU
-		{12F96462-A2F8-4FBE-B4F5-29BA6A6DB4D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{12F96462-A2F8-4FBE-B4F5-29BA6A6DB4D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{12F96462-A2F8-4FBE-B4F5-29BA6A6DB4D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{12F96462-A2F8-4FBE-B4F5-29BA6A6DB4D9}.Release|Any CPU.Build.0 = Release|Any CPU
 		{6981E761-E698-437D-AF63-0E80844B7D41}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{6981E761-E698-437D-AF63-0E80844B7D41}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6981E761-E698-437D-AF63-0E80844B7D41}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6981E761-E698-437D-AF63-0E80844B7D41}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6CB7E269-91CB-47CC-BF9F-67956D5E0F7E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6CB7E269-91CB-47CC-BF9F-67956D5E0F7E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6CB7E269-91CB-47CC-BF9F-67956D5E0F7E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6CB7E269-91CB-47CC-BF9F-67956D5E0F7E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9EA4EA87-7656-48BA-BE7F-E5CC1B48512D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9EA4EA87-7656-48BA-BE7F-E5CC1B48512D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9EA4EA87-7656-48BA-BE7F-E5CC1B48512D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9EA4EA87-7656-48BA-BE7F-E5CC1B48512D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{794C4984-BB46-4A50-9BC1-53831B5C8002}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{794C4984-BB46-4A50-9BC1-53831B5C8002}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{794C4984-BB46-4A50-9BC1-53831B5C8002}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{794C4984-BB46-4A50-9BC1-53831B5C8002}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F0A7B925-30F2-4FAA-97E6-7848B3E104B6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F0A7B925-30F2-4FAA-97E6-7848B3E104B6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F0A7B925-30F2-4FAA-97E6-7848B3E104B6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F0A7B925-30F2-4FAA-97E6-7848B3E104B6}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Attributes/GeneratorBindingsAttribute.cs b/NetFabric.Hyperlinq/Attributes/GeneratorBindingsAttribute.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Attributes/GeneratorBindingsAttribute.cs
rename to NetFabric.Hyperlinq/Attributes/GeneratorBindingsAttribute.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Attributes/GeneratorIgnoreAttribute.cs b/NetFabric.Hyperlinq/Attributes/GeneratorIgnoreAttribute.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Attributes/GeneratorIgnoreAttribute.cs
rename to NetFabric.Hyperlinq/Attributes/GeneratorIgnoreAttribute.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Attributes/GeneratorMappingAttribute.cs b/NetFabric.Hyperlinq/Attributes/GeneratorMappingAttribute.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Attributes/GeneratorMappingAttribute.cs
rename to NetFabric.Hyperlinq/Attributes/GeneratorMappingAttribute.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/CompilationContext.cs b/NetFabric.Hyperlinq/CompilationContext.cs
similarity index 98%
rename from NetFabric.Hyperlinq.SourceGenerator/CompilationContext.cs
rename to NetFabric.Hyperlinq/CompilationContext.cs
index 7dedf96f5..a2a169618 100644
--- a/NetFabric.Hyperlinq.SourceGenerator/CompilationContext.cs
+++ b/NetFabric.Hyperlinq/CompilationContext.cs
@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis;
+using NetFabric.CodeAnalysis;
 using System;
 
 namespace NetFabric.Hyperlinq.SourceGenerator
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.cs
deleted file mode 100644
index b9af7e02e..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.Enumerable.cs
+++ /dev/null
@@ -1,155 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class EnumerableExtensions
-    {
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TSource> AsValueEnumerable<TSource>(this IEnumerable<TSource> source)
-            => new(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct ValueEnumerable<TSource>
-            : IValueEnumerable<TSource, ValueEnumerator<TSource>>
-        {
-            readonly IEnumerable<TSource> source;
-
-            internal ValueEnumerable(IEnumerable<TSource> source) 
-                => this.source = source;
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerator<TSource> GetEnumerator() 
-                => new(source.GetEnumerator());
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                => source.GetEnumerator();
-            IEnumerator IEnumerable.GetEnumerator() 
-                => source.GetEnumerator();
-            
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerable<TSource> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public IEnumerable<TSource> AsEnumerable()
-                => source;
-
-            public TSource[] ToArray()
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Array.Empty<TSource>();
-
-                    var result = Utils.AllocateUninitializedArray<TSource>(collection.Count);
-                    collection.CopyTo(result, 0);
-                    return result;
-                }
-                
-                using var arrayBuilder = ValueEnumerableExtensions.ToArrayBuilder<ValueEnumerable<TSource>, ValueEnumerator<TSource>, TSource>(this, ArrayPool<TSource>.Shared, false);
-                return arrayBuilder.ToArray();
-            }
-
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Lease.Empty<TSource>();
-                
-                    var result = pool.Lease(collection.Count, clearOnDispose);
-                    collection.CopyTo(result.Rented, 0);
-                    return result;                
-                }
-
-                using var arrayBuilder = ValueEnumerableExtensions.ToArrayBuilder<ValueEnumerable<TSource>, ValueEnumerator<TSource>, TSource>(this, pool, clearOnDispose);
-                return arrayBuilder.ToArray(pool, clearOnDispose);
-            }
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Quantifier
-
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return this.Contains<ValueEnumerable<TSource>, ValueEnumerator<TSource>, TSource>(value, comparer);
-            }
-
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ValueEnumerable<int> source)
-            => source.Sum<ValueEnumerable<int>, ValueEnumerator<int>, int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ValueEnumerable<int?> source)
-            => source.Sum<ValueEnumerable<int?>, ValueEnumerator<int?>, int?, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ValueEnumerable<nint> source)
-            => source.Sum<ValueEnumerable<nint>, ValueEnumerator<nint>, nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ValueEnumerable<nint?> source)
-            => source.Sum<ValueEnumerable<nint?>, ValueEnumerator<nint?>, nint?, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ValueEnumerable<nuint> source)
-            => source.Sum<ValueEnumerable<nuint>, ValueEnumerator<nuint>, nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ValueEnumerable<nuint?> source)
-            => source.Sum<ValueEnumerable<nuint?>, ValueEnumerator<nuint?>, nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ValueEnumerable<long> source)
-            => source.Sum<ValueEnumerable<long>, ValueEnumerator<long>, long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ValueEnumerable<long?> source)
-            => source.Sum<ValueEnumerable<long?>, ValueEnumerator<long?>, long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ValueEnumerable<float> source)
-            => source.Sum<ValueEnumerable<float>, ValueEnumerator<float>, float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ValueEnumerable<float?> source)
-            => source.Sum<ValueEnumerable<float?>, ValueEnumerator<float?>, float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ValueEnumerable<double> source)
-            => source.Sum<ValueEnumerable<double>, ValueEnumerator<double>, double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ValueEnumerable<double?> source)
-            => source.Sum<ValueEnumerable<double?>, ValueEnumerator<double?>, double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ValueEnumerable<decimal> source)
-            => source.Sum<ValueEnumerable<decimal>, ValueEnumerator<decimal>, decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ValueEnumerable<decimal?> source)
-            => source.Sum<ValueEnumerable<decimal?>, ValueEnumerator<decimal?>, decimal?, decimal>();
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.cs
deleted file mode 100644
index a8be25625..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.cs
+++ /dev/null
@@ -1,214 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ReadOnlyCollectionExtensions
-    {
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TSource> AsValueEnumerable<TSource>(this IReadOnlyCollection<TSource> source)
-            => new(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct ValueEnumerable<TSource>
-            : IValueReadOnlyCollection<TSource, ValueEnumerator<TSource>>
-            , ICollection<TSource>
-        {
-            readonly IReadOnlyCollection<TSource> source;
-
-            internal ValueEnumerable(IReadOnlyCollection<TSource> source) 
-                => this.source = source;
-
-            public int Count
-                => source.Count;
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerator<TSource> GetEnumerator() 
-                => new(source.GetEnumerator());
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                => source.GetEnumerator();
-            IEnumerator IEnumerable.GetEnumerator() 
-                => source.GetEnumerator();
-
-            bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public void CopyTo(TSource[] array, int arrayIndex)
-            {
-                if (Count is 0)
-                    return;
-                
-                if (array.Length - arrayIndex < Count)
-                    Throw.ArgumentException(Resource.DestinationNotLongEnough, nameof(array));
-
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    collection.CopyTo(array, arrayIndex);
-                }
-                else
-                {
-                    using var enumerator = GetEnumerator();
-                    if (arrayIndex is 0 && array.Length == Count) // to enable range check elimination
-                    {
-                        for (var index = 0; index < array.Length; index++)
-                        {
-                            _ = enumerator.MoveNext();
-                            array[index] = enumerator.Current;
-                        }                        
-                    }
-                    else
-                    {
-                        checked
-                        {
-                            for (var index = arrayIndex; enumerator.MoveNext(); index++)
-                                array[index] = enumerator.Current;
-                        }
-                    }
-                }
-            }
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            bool ICollection<TSource>.Contains(TSource item)
-                => Contains(item, default);
-
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Add(TSource item) 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Clear() 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            bool ICollection<TSource>.Remove(TSource item) 
-                => Throw.NotSupportedException<bool>();
-            
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerable<TSource> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public IReadOnlyCollection<TSource> AsEnumerable()
-                => source;
-
-            public TSource[] ToArray()
-            {
-                if (source.Count is 0)
-                    return Array.Empty<TSource>();
-
-                var result = Utils.AllocateUninitializedArray<TSource>(source.Count);
-                CopyTo(result, 0);
-                return result;
-            }
-            
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                if (source.Count is 0)
-                    return Lease.Empty<TSource>();
-
-                var result = pool.Lease(source.Count, clearOnDispose);
-                CopyTo(result.Rented, 0);
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            #region Quantifier
-
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-                => Count is not 0 && source.Contains(value, comparer);
-            
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this ValueEnumerable<TSource> source)
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this ValueEnumerable<TSource> source, Func<TSource, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TPredicate>(this ValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this ValueEnumerable<TSource> source, Func<TSource, int, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TSource, TPredicate>(this ValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ValueEnumerable<int> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<int>, ValueEnumerator<int>, int, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ValueEnumerable<int?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<int?>, ValueEnumerator<int?>, int?, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ValueEnumerable<nint> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<nint>, ValueEnumerator<nint>, nint, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ValueEnumerable<nint?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<nint?>, ValueEnumerator<nint?>, nint?, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ValueEnumerable<nuint> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<nuint>, ValueEnumerator<nuint>, nuint, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ValueEnumerable<nuint?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<nuint?>, ValueEnumerator<nuint?>, nuint?, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ValueEnumerable<long> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<long>, ValueEnumerator<long>, long, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ValueEnumerable<long?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<long?>, ValueEnumerator<long?>, long?, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ValueEnumerable<float> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<float>, ValueEnumerator<float>, float, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ValueEnumerable<float?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<float?>, ValueEnumerator<float?>, float?, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ValueEnumerable<double> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<double>, ValueEnumerator<double>, double, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ValueEnumerable<double?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<double?>, ValueEnumerator<double?>, double?, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ValueEnumerable<decimal> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<decimal>, ValueEnumerator<decimal>, decimal, decimal>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ValueEnumerable<decimal?> source)
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<decimal?>, ValueEnumerator<decimal?>, decimal?, decimal>(source);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyList.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyList.cs
deleted file mode 100644
index c6646af20..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyList.cs
+++ /dev/null
@@ -1,320 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ReadOnlyListExtensions
-    {
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<IReadOnlyList<TSource>, TSource> AsValueEnumerable<TSource>(this IReadOnlyList<TSource> source)
-            => new(source);
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TList, TSource> AsValueEnumerable<TList, TSource>(this TList source)
-            where TList : IReadOnlyList<TSource>
-            => new(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct ValueEnumerable<TList, TSource>
-            : IValueReadOnlyList<TSource, ValueEnumerator<TSource>>
-            , IList<TSource>
-            where TList : IReadOnlyList<TSource>
-        {
-            readonly TList source;
-
-            internal ValueEnumerable(TList source) 
-                => this.source = source;
-
-            public TSource this[int index]
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => source[index];
-            }
-
-            TSource IList<TSource>.this[int index]
-            {
-                get => source[index];
-                [DoesNotReturn]
-                // ReSharper disable once ValueParameterNotUsed
-                set => Throw.NotSupportedException();
-            }
-
-            public int Count
-                => source.Count;
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerator<TSource> GetEnumerator() 
-                => new(source.GetEnumerator());
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                => source.GetEnumerator();
-            IEnumerator IEnumerable.GetEnumerator() 
-                => source.GetEnumerator();
-
-            bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public void CopyTo(TSource[] array, int arrayIndex)
-            {
-                if (Count is 0)
-                    return;
-                
-                if (array.Length - arrayIndex < Count)
-                    Throw.ArgumentException(Resource.DestinationNotLongEnough, nameof(array));
-
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    collection.CopyTo(array, arrayIndex);
-                }
-                else
-                {
-                    using var enumerator = GetEnumerator();
-                    if (arrayIndex is 0 && array.Length == Count) // to enable range check elimination
-                    {
-                        for (var index = 0; index < array.Length; index++)
-                        {
-                            _ = enumerator.MoveNext();
-                            array[index] = enumerator.Current;
-                        }
-                    }
-                    else
-                    {
-                        checked
-                        {
-                            for (var index = arrayIndex; enumerator.MoveNext(); index++)
-                                array[index] = enumerator.Current;
-                        }
-                    }
-                }
-            }
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            bool ICollection<TSource>.Contains(TSource item)
-                => Contains(item, default);
-
-            public int IndexOf(TSource item)
-            {
-                return source switch
-                {
-                    // ReSharper disable once HeapView.PossibleBoxingAllocation
-                    IList<TSource> list => list.IndexOf(item),
-                    
-                    _ => IndexOfEnumerable(this, item),
-                };
-
-                static int IndexOfEnumerable(ValueEnumerable<TList, TSource> source, TSource item)
-                {
-                    using var enumerator = source.GetEnumerator();
-                    for (var index = 0; enumerator.MoveNext(); index++)
-                    {
-                        if (EqualityComparer<TSource>.Default.Equals(enumerator.Current, item))
-                            return index;
-                    }
-                    return -1;
-                }
-            }
-
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Add(TSource item) 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Clear() 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            bool ICollection<TSource>.Remove(TSource item) 
-                => Throw.NotSupportedException<bool>();
-
-            [ExcludeFromCodeCoverage]
-            void IList<TSource>.Insert(int index, TSource item) 
-                => Throw.NotSupportedException<bool>();
-            [ExcludeFromCodeCoverage]
-            void IList<TSource>.RemoveAt(int index) 
-                => Throw.NotSupportedException<bool>();
-
-            #region Partitioning
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SkipTakeEnumerable<ValueEnumerable<TList, TSource>, TSource> Skip(int count)
-                => this.Skip<ValueEnumerable<TList, TSource>, TSource>(count);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SkipTakeEnumerable<ValueEnumerable<TList, TSource>, TSource> Take(int count)
-                => this.Take<ValueEnumerable<TList, TSource>, TSource>(count);
-
-            #endregion
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerable<TList, TSource> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public IReadOnlyCollection<TSource> AsEnumerable()
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                => source;
-
-            public TSource[] ToArray()
-            {
-                if (source.Count is 0)
-                    return Array.Empty<TSource>();
-
-                var result = Utils.AllocateUninitializedArray<TSource>(source.Count);
-                CopyTo(result, 0);
-                return result;
-            }
-            
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                if (source.Count is 0)
-                    return Lease.Empty<TSource>();
-
-                var result = pool.Lease(source.Count, clearOnDispose);
-                CopyTo(result.Rented, 0);
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.SelectEnumerable<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, TResult> selector)
-                => ValueReadOnlyListExtensions.Select<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult>(this, selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.SelectEnumerable<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, TResult>
-                => ValueReadOnlyListExtensions.Select<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult, TSelector>(this, selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.SelectAtEnumerable<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TResult>(Func<TSource, int, TResult> selector)
-                => ValueReadOnlyListExtensions.Select<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult>(this, selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.SelectAtEnumerable<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult, TSelector> SelectAt<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, int, TResult>
-                => ValueReadOnlyListExtensions.SelectAt<ValueEnumerable<TList, TSource>, ValueEnumerator<TSource>, TSource, TResult, TSelector>(this, selector);
-
-            #endregion
-            
-            #region Quantifier
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-                => Count is not 0 && source.Contains(value);
-            
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource>(this ValueEnumerable<TList, TSource> source)
-            where TList : IReadOnlyList<TSource>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource>(this ValueEnumerable<TList, TSource> source, Func<TSource, bool> predicate)
-            where TList : IReadOnlyList<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource, TPredicate>(this ValueEnumerable<TList, TSource> source, TPredicate predicate = default)
-            where TList : IReadOnlyList<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TList, TSource>(this ValueEnumerable<TList, TSource> source, Func<TSource, int, bool> predicate)
-            where TList : IReadOnlyList<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TList, TSource, TPredicate>(this ValueEnumerable<TList, TSource> source, TPredicate predicate = default)
-            where TList : IReadOnlyList<TSource>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TList>(this ValueEnumerable<TList, int> source)
-            where TList : IReadOnlyList<int>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, int>, ValueEnumerator<int>, int, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TList>(this ValueEnumerable<TList, int?> source)
-            where TList : IReadOnlyList<int?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, int?>, ValueEnumerator<int?>, int?, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TList>(this ValueEnumerable<TList, nint> source)
-            where TList : IReadOnlyList<nint>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, nint>, ValueEnumerator<nint>, nint, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TList>(this ValueEnumerable<TList, nint?> source)
-            where TList : IReadOnlyList<nint?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, nint?>, ValueEnumerator<nint?>, nint?, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TList>(this ValueEnumerable<TList, nuint> source)
-            where TList : IReadOnlyList<nuint>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, nuint>, ValueEnumerator<nuint>, nuint, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TList>(this ValueEnumerable<TList, nuint?> source)
-            where TList : IReadOnlyList<nuint?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, nuint?>, ValueEnumerator<nuint?>, nuint?, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TList>(this ValueEnumerable<TList, long> source)
-            where TList : IReadOnlyList<long>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, long>, ValueEnumerator<long>, long, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TList>(this ValueEnumerable<TList, long?> source)
-            where TList : IReadOnlyList<long?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, long?>, ValueEnumerator<long?>, long?, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TList>(this ValueEnumerable<TList, float> source)
-            where TList : IReadOnlyList<float>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, float>, ValueEnumerator<float>, float, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TList>(this ValueEnumerable<TList, float?> source)
-            where TList : IReadOnlyList<float?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, float?>, ValueEnumerator<float?>, float?, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TList>(this ValueEnumerable<TList, double> source)
-            where TList : IReadOnlyList<double>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, double>, ValueEnumerator<double>, double, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TList>(this ValueEnumerable<TList, double?> source)
-            where TList : IReadOnlyList<double?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, double?>, ValueEnumerator<double?>, double?, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TList>(this ValueEnumerable<TList, decimal> source)
-            where TList : IReadOnlyList<decimal>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, decimal>, ValueEnumerator<decimal>, decimal, decimal>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TList>(this ValueEnumerable<TList, decimal?> source)
-            where TList : IReadOnlyList<decimal?>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TList, decimal?>, ValueEnumerator<decimal?>, decimal?, decimal>(source);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.cs
deleted file mode 100644
index ac02b2263..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueEnumerable.cs
+++ /dev/null
@@ -1,174 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerator, TSource> AsValueEnumerable<TEnumerator, TSource>(this IValueEnumerable<TSource, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<TSource>
-            => new(source);
-
-        [GeneratorBindings(source: "source", sourceImplements: "IValueEnumerable`2", enumerableType: "IValueEnumerable<TSource, TEnumerator>")]
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct ValueEnumerable<TEnumerator, TSource>
-            : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-        {
-            readonly IValueEnumerable<TSource, TEnumerator> source;
-
-            internal ValueEnumerable(IValueEnumerable<TSource, TEnumerator> source) 
-                => this.source = source;
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public TEnumerator GetEnumerator() 
-                => source.GetEnumerator();
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-            IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-            
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerable<TEnumerator, TSource> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public IEnumerable<TSource> AsEnumerable()
-                => source;
-
-            public TSource[] ToArray()
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Array.Empty<TSource>();
-
-                    var result = Utils.AllocateUninitializedArray<TSource>(collection.Count);
-                    collection.CopyTo(result, 0);
-                    return result;
-                }
-                
-                using var arrayBuilder = ToArrayBuilder<IValueEnumerable<TSource, TEnumerator>, TEnumerator, TSource>(source, ArrayPool<TSource>.Shared, false);
-                return arrayBuilder.ToArray();
-            }
-
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Lease.Empty<TSource>();
-                
-                    var result = pool.Lease(collection.Count, clearOnDispose);
-                    collection.CopyTo(result.Rented, 0);
-                    return result;                
-                }
-
-                using var arrayBuilder = ToArrayBuilder<IValueEnumerable<TSource, TEnumerator>, TEnumerator, TSource>(source, pool, clearOnDispose);
-                return arrayBuilder.ToArray(pool, clearOnDispose);
-            }
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Quantifier
-
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return source.Contains<IValueEnumerable<TSource, TEnumerator>, TEnumerator, TSource>(value, comparer);
-            }
-
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerator>(this ValueEnumerable<TEnumerator, int> source)
-            where TEnumerator : struct, IEnumerator<int>
-            => source.Sum<ValueEnumerable<TEnumerator, int>, TEnumerator, int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerator>(this ValueEnumerable<TEnumerator, int?> source)
-            where TEnumerator : struct, IEnumerator<int?>
-            => source.Sum<ValueEnumerable<TEnumerator, int?>, TEnumerator, int?, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerator>(this ValueEnumerable<TEnumerator, nint> source)
-            where TEnumerator : struct, IEnumerator<nint>
-            => source.Sum<ValueEnumerable<TEnumerator, nint>, TEnumerator, nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerator>(this ValueEnumerable<TEnumerator, nint?> source)
-            where TEnumerator : struct, IEnumerator<nint?>
-            => source.Sum<ValueEnumerable<TEnumerator, nint?>, TEnumerator, nint?, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerator>(this ValueEnumerable<TEnumerator, nuint> source)
-            where TEnumerator : struct, IEnumerator<nuint>
-            => source.Sum<ValueEnumerable<TEnumerator, nuint>, TEnumerator, nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerator>(this ValueEnumerable<TEnumerator, nuint?> source)
-            where TEnumerator : struct, IEnumerator<nuint?>
-            => source.Sum<ValueEnumerable<TEnumerator, nuint?>, TEnumerator, nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerator>(this ValueEnumerable<TEnumerator, long> source)
-            where TEnumerator : struct, IEnumerator<long>
-            => source.Sum<ValueEnumerable<TEnumerator, long>, TEnumerator, long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerator>(this ValueEnumerable<TEnumerator, long?> source)
-            where TEnumerator : struct, IEnumerator<long?>
-            => source.Sum<ValueEnumerable<TEnumerator, long?>, TEnumerator, long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerator>(this ValueEnumerable<TEnumerator, float> source)
-            where TEnumerator : struct, IEnumerator<float>
-            => source.Sum<ValueEnumerable<TEnumerator, float>, TEnumerator, float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerator>(this ValueEnumerable<TEnumerator, float?> source)
-            where TEnumerator : struct, IEnumerator<float?>
-            => source.Sum<ValueEnumerable<TEnumerator, float?>, TEnumerator, float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerator>(this ValueEnumerable<TEnumerator, double> source)
-            where TEnumerator : struct, IEnumerator<double>
-            => source.Sum<ValueEnumerable<TEnumerator, double>, TEnumerator, double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerator>(this ValueEnumerable<TEnumerator, double?> source)
-            where TEnumerator : struct, IEnumerator<double?>
-            => source.Sum<ValueEnumerable<TEnumerator, double?>, TEnumerator, double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerator>(this ValueEnumerable<TEnumerator, decimal> source)
-            where TEnumerator : struct, IEnumerator<decimal>
-            => source.Sum<ValueEnumerable<TEnumerator, decimal>, TEnumerator, decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerator>(this ValueEnumerable<TEnumerator, decimal?> source)
-            where TEnumerator : struct, IEnumerator<decimal?>
-            => source.Sum<ValueEnumerable<TEnumerator, decimal?>, TEnumerator, decimal?, decimal>();
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.cs
deleted file mode 100644
index e3eb7ce64..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.cs
+++ /dev/null
@@ -1,246 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueReadOnlyCollectionExtensions
-    {
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TSource, TEnumerator> AsValueEnumerable<TSource, TEnumerator>(this IValueReadOnlyCollection<TSource, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<TSource>
-            => new(source);
-
-        [GeneratorBindings(source: "source", sourceImplements: "IValueReadOnlyCollection`2,IValueEnumerable`2", enumerableType: "IValueReadOnlyCollection<TSource, TEnumerator>")]
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct ValueEnumerable<TSource, TEnumerator>
-            : IValueReadOnlyCollection<TSource, TEnumerator>
-            , ICollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-        {
-            readonly IValueReadOnlyCollection<TSource, TEnumerator> source;
-
-            internal ValueEnumerable(IValueReadOnlyCollection<TSource, TEnumerator> source) 
-                => this.source = source;
-
-            public int Count
-                => source.Count;
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public TEnumerator GetEnumerator() 
-                => source.GetEnumerator();
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-            IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-
-            bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public void CopyTo(TSource[] array, int arrayIndex)
-            { 
-                if (Count is 0)
-                    return;
-                
-                if (array.Length - arrayIndex < Count)
-                    Throw.ArgumentException(Resource.DestinationNotLongEnough, nameof(array));
-
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    collection.CopyTo(array, arrayIndex);
-                }
-                else
-                {
-                    using var enumerator = GetEnumerator();
-                    if (arrayIndex is 0 && array.Length == Count) // to enable range check elimination
-                    {
-                        for (var index = 0; index < array.Length; index++)
-                        {
-                            _ = enumerator.MoveNext();
-                            array[index] = enumerator.Current;
-                        }                        
-                    }
-                    else
-                    {
-                        checked
-                        {
-                            for (var index = arrayIndex; enumerator.MoveNext(); index++)
-                                array[index] = enumerator.Current;
-                        }
-                    }
-                }
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            bool ICollection<TSource>.Contains(TSource item)
-                => Contains(item, default);
-
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Add(TSource item) 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Clear() 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            bool ICollection<TSource>.Remove(TSource item) 
-                => Throw.NotSupportedException<bool>();
-            
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerable<TSource, TEnumerator> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public IReadOnlyCollection<TSource> AsEnumerable()
-                => source;
-            
-            public TSource[] ToArray()
-            {
-                if (source.Count is 0)
-                    return Array.Empty<TSource>();
-
-                var result = Utils.AllocateUninitializedArray<TSource>(source.Count);
-                CopyTo(result, 0);
-                return result;
-            }
-            
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                if (source.Count is 0)
-                    return Lease.Empty<TSource>();
-
-                var result = pool.Lease(source.Count, clearOnDispose);
-                CopyTo(result.Rented, 0);
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Quantifier
-
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                if (Count is 0)
-                    return false;
-                
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return source.Contains<IValueEnumerable<TSource, TEnumerator>, TEnumerator, TSource>(value, comparer);
-            }
-            #endregion        
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TEnumerator>(this ValueEnumerable<TSource, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TEnumerator>(this ValueEnumerable<TSource, TEnumerator> source, Func<TSource, bool> predicate)
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TEnumerator, TPredicate>(this ValueEnumerable<TSource, TEnumerator> source, TPredicate predicate = default)
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TEnumerator>(this ValueEnumerable<TSource, TEnumerator> source, Func<TSource, int, bool> predicate)
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TSource, TEnumerator, TPredicate>(this ValueEnumerable<TSource, TEnumerator> source, TPredicate predicate = default)
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerator>(this ValueEnumerable<int, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<int>
-            => Sum<ValueEnumerable<int, TEnumerator>, TEnumerator, int, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerator>(this ValueEnumerable<int?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<int?>
-            => Sum<ValueEnumerable<int?, TEnumerator>, TEnumerator, int?, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerator>(this ValueEnumerable<nint, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<nint>
-            => Sum<ValueEnumerable<nint, TEnumerator>, TEnumerator, nint, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerator>(this ValueEnumerable<nint?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<nint?>
-            => Sum<ValueEnumerable<nint?, TEnumerator>, TEnumerator, nint?, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerator>(this ValueEnumerable<nuint, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<nuint>
-            => Sum<ValueEnumerable<nuint, TEnumerator>, TEnumerator, nuint, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerator>(this ValueEnumerable<nuint?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<nuint?>
-            => Sum<ValueEnumerable<nuint?, TEnumerator>, TEnumerator, nuint?, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerator>(this ValueEnumerable<long, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<long>
-            => Sum<ValueEnumerable<long, TEnumerator>, TEnumerator, long, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerator>(this ValueEnumerable<long?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<long?>
-            => Sum<ValueEnumerable<long?, TEnumerator>, TEnumerator, long?, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerator>(this ValueEnumerable<float, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<float>
-            => Sum<ValueEnumerable<float, TEnumerator>, TEnumerator, float, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerator>(this ValueEnumerable<float?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<float?>
-            => Sum<ValueEnumerable<float?, TEnumerator>, TEnumerator, float?, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerator>(this ValueEnumerable<double, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<double>
-            => Sum<ValueEnumerable<double, TEnumerator>, TEnumerator, double, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerator>(this ValueEnumerable<double?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<double?>
-            => Sum<ValueEnumerable<double?, TEnumerator>, TEnumerator, double?, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerator>(this ValueEnumerable<decimal, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<decimal>
-            => Sum<ValueEnumerable<decimal, TEnumerator>, TEnumerator, decimal, decimal>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerator>(this ValueEnumerable<decimal?, TEnumerator> source)
-            where TEnumerator : struct, IEnumerator<decimal?>
-            => Sum<ValueEnumerable<decimal?, TEnumerator>, TEnumerator, decimal?, decimal>(source);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.cs
deleted file mode 100644
index f735067c5..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.Enumerable.cs
+++ /dev/null
@@ -1,264 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class EnumerableExtensions
-    {
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator>> AsValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator)
-            where TEnumerable : IEnumerable<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AsValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetEnumerator, TGetEnumerator> AsValueEnumerable<TEnumerable, TEnumerator, TSource, TGetEnumerator>(this TEnumerable source, TGetEnumerator getEnumerator = default)
-            where TEnumerable : IEnumerable<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            => new(source, getEnumerator, getEnumerator);
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator, Func<TEnumerable, TEnumerator2> getEnumerator2)
-            where TEnumerable : IEnumerable<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            => AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator), new FunctionWrapper<TEnumerable, TEnumerator2>(getEnumerator2));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this TEnumerable source, TGetEnumerator getEnumerator = default, TGetEnumerator2 getEnumerator2 = default)
-            where TEnumerable : IEnumerable<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => new(source, getEnumerator, getEnumerator2);
-
-        [StructLayout(LayoutKind.Auto)]
-        public partial struct ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>
-            : IValueEnumerable<TSource, TEnumerator> 
-            where TEnumerable : IEnumerable<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-        {
-            readonly TEnumerable source;
-            TGetEnumerator getEnumerator;
-            TGetEnumerator2 getEnumerator2;
-
-            internal ValueEnumerable(TEnumerable source, TGetEnumerator getEnumerator, TGetEnumerator2 getEnumerator2)
-                => (this.source, this.getEnumerator, this.getEnumerator2) = (source, getEnumerator, getEnumerator2);
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerator2 GetEnumerator() 
-                => getEnumerator2.Invoke(source);
-            readonly TEnumerator IValueEnumerable<TSource, TEnumerator>.GetEnumerator() 
-                => getEnumerator.Invoke(source);
-            readonly IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                => source.GetEnumerator();
-            readonly IEnumerator IEnumerable.GetEnumerator() 
-                => source.GetEnumerator();
-            
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerable AsEnumerable()
-                => source;
-
-            public readonly TSource[] ToArray()
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Array.Empty<TSource>();
-
-                    var result = Utils.AllocateUninitializedArray<TSource>(collection.Count);
-                    collection.CopyTo(result, 0);
-                    return result;
-                }
-                
-                using var arrayBuilder = ValueEnumerableExtensions.ToArrayBuilder<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource>(this, ArrayPool<TSource>.Shared, false);
-                return arrayBuilder.ToArray();
-            }
-
-            public readonly Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Lease.Empty<TSource>();
-
-                    var result = pool.Lease(collection.Count, clearOnDispose);
-                    collection.CopyTo(result.Rented, 0);
-                    return result;
-                }
-
-                using var arrayBuilder = ValueEnumerableExtensions.ToArrayBuilder<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource>(this, pool, clearOnDispose);
-                return arrayBuilder.ToArray(pool, clearOnDispose);
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Quantifier
-
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return this.Contains<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource>(value, comparer);
-            }
-
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<int>
-            where TEnumerator : struct, IEnumerator<int>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2>, TEnumerator, int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<int?>
-            where TEnumerator : struct, IEnumerator<int?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2>, TEnumerator, int?, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<nint>
-            where TEnumerator : struct, IEnumerator<nint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<nint?>
-            where TEnumerator : struct, IEnumerator<nint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint?, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<nuint>
-            where TEnumerator : struct, IEnumerator<nuint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<nuint?>
-            where TEnumerator : struct, IEnumerator<nuint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<long>
-            where TEnumerator : struct, IEnumerator<long>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2>, TEnumerator, long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<long?>
-            where TEnumerator : struct, IEnumerator<long?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2>, TEnumerator, long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<float>
-            where TEnumerator : struct, IEnumerator<float>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2>, TEnumerator, float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<float?>
-            where TEnumerator : struct, IEnumerator<float?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2>, TEnumerator, float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<double>
-            where TEnumerator : struct, IEnumerator<double>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2>, TEnumerator, double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<double?>
-            where TEnumerator : struct, IEnumerator<double?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2>, TEnumerator, double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<decimal>
-            where TEnumerator : struct, IEnumerator<decimal>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IEnumerable<decimal?>
-            where TEnumerator : struct, IEnumerator<decimal?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal?, decimal>();
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.cs
deleted file mode 100644
index d3ca7a55c..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ReadOnlyCollection.cs
+++ /dev/null
@@ -1,348 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ReadOnlyCollectionExtensions
-    {
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator>> AsValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AsValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetEnumerator, TGetEnumerator> AsValueEnumerable<TEnumerable, TEnumerator, TSource, TGetEnumerator>(this TEnumerable source, TGetEnumerator getEnumerator = default)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            => new(source, getEnumerator, getEnumerator);
-
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator, Func<TEnumerable, TEnumerator2> getEnumerator2)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            => AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator), new FunctionWrapper<TEnumerable, TEnumerator2>(getEnumerator2));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this TEnumerable source, TGetEnumerator getEnumerator = default, TGetEnumerator2 getEnumerator2 = default)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => new(source, getEnumerator, getEnumerator2);
-
-        [StructLayout(LayoutKind.Auto)]
-        public partial struct ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>
-            : IValueReadOnlyCollection<TSource, TEnumerator> 
-            , ICollection<TSource>
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-        {
-            readonly TEnumerable source;
-#pragma warning disable IDE0044 // Add readonly modifier
-            TGetEnumerator getEnumerator;
-            TGetEnumerator2 getEnumerator2;
-#pragma warning restore IDE0044 // Add readonly modifier
-
-            internal ValueEnumerable(TEnumerable source, TGetEnumerator getEnumerator, TGetEnumerator2 getEnumerator2)
-                => (this.source, this.getEnumerator, this.getEnumerator2) = (source, getEnumerator, getEnumerator2);
-            
-            public readonly int Count
-                => source.Count;
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerator2 GetEnumerator() 
-                => getEnumerator2.Invoke(source);
-            readonly TEnumerator IValueEnumerable<TSource, TEnumerator>.GetEnumerator() 
-                => getEnumerator.Invoke(source);
-            readonly IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                => source.GetEnumerator();
-            readonly IEnumerator IEnumerable.GetEnumerator() 
-                => source.GetEnumerator();
-
-            bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public readonly void CopyTo(TSource[] array, int arrayIndex)
-            {
-                if (Count is 0)
-                    return;
-                
-                if (array.Length - arrayIndex < Count)
-                    Throw.ArgumentException(Resource.DestinationNotLongEnough, nameof(array));
-
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    collection.CopyTo(array, arrayIndex);
-                }
-                else
-                {
-                    using var enumerator = getEnumerator.Invoke(source);
-                    if (arrayIndex is 0 && array.Length == Count) // to enable range check elimination
-                    {
-                        for (var index = 0; index < array.Length; index++)
-                        {
-                            _ = enumerator.MoveNext();
-                            array[index] = enumerator.Current;
-                        }                        
-                    }
-                    else
-                    {
-                        checked
-                        {
-                            for (var index = arrayIndex; enumerator.MoveNext(); index++)
-                                array[index] = enumerator.Current;
-                        }
-                    }
-                }
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            readonly bool ICollection<TSource>.Contains(TSource item)
-                => Contains(item, default);
-
-            [ExcludeFromCodeCoverage]
-            readonly void ICollection<TSource>.Add(TSource item) 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            readonly void ICollection<TSource>.Clear() 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            readonly bool ICollection<TSource>.Remove(TSource item) 
-                => Throw.NotSupportedException<bool>();
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerable AsEnumerable()
-                => source;
-
-            public readonly TSource[] ToArray()
-            {
-                if (source.Count is 0)
-                    return Array.Empty<TSource>();
-
-                var result = Utils.AllocateUninitializedArray<TSource>(source.Count);
-                CopyTo(result, 0);
-                return result;
-            }
-            
-            public readonly Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                if (source.Count is 0)
-                    return Lease.Empty<TSource>();
-
-                var result = pool.Lease(source.Count, clearOnDispose);
-                CopyTo(result.Rented, 0);
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            #region Quantifier
-
-            public readonly bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-                => Count is not 0 && source.Contains(value, comparer);
-            
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, Func<TSource, bool> predicate)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2, TPredicate>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, TPredicate predicate = default)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2, TPredicate>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, TPredicate predicate = default)
-            where TEnumerable : IReadOnlyCollection<TSource>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<int>
-            where TEnumerator : struct, IEnumerator<int>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2>, TEnumerator, int, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<int?>
-            where TEnumerator : struct, IEnumerator<int?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2>, TEnumerator, int?, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<nint>
-            where TEnumerator : struct, IEnumerator<nint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<nint?>
-            where TEnumerator : struct, IEnumerator<nint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint?, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<nuint>
-            where TEnumerator : struct, IEnumerator<nuint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<nuint?>
-            where TEnumerator : struct, IEnumerator<nuint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint?, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<long>
-            where TEnumerator : struct, IEnumerator<long>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2>, TEnumerator, long, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<long?>
-            where TEnumerator : struct, IEnumerator<long?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2>, TEnumerator, long?, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<float>
-            where TEnumerator : struct, IEnumerator<float>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2>, TEnumerator, float, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<float?>
-            where TEnumerator : struct, IEnumerator<float?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2>, TEnumerator, float?, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<double>
-            where TEnumerator : struct, IEnumerator<double>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2>, TEnumerator, double, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<double?>
-            where TEnumerator : struct, IEnumerator<double?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2>, TEnumerator, double?, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<decimal>
-            where TEnumerator : struct, IEnumerator<decimal>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal, decimal>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IReadOnlyCollection<decimal?>
-            where TEnumerator : struct, IEnumerator<decimal?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal?, decimal>(source);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.cs
deleted file mode 100644
index a3d066e5e..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueEnumerable.cs
+++ /dev/null
@@ -1,266 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueEnumerableExtensions
-    {
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator>> AsValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AsValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetEnumerator, TGetEnumerator> AsValueEnumerable<TEnumerable, TEnumerator, TSource, TGetEnumerator>(this TEnumerable source, TGetEnumerator getEnumerator = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            => new(source, getEnumerator, getEnumerator);
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator, Func<TEnumerable, TEnumerator2> getEnumerator2)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            => AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator), new FunctionWrapper<TEnumerable, TEnumerator2>(getEnumerator2));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this TEnumerable source, TGetEnumerator getEnumerator = default, TGetEnumerator2 getEnumerator2 = default)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => new(source, getEnumerator, getEnumerator2);
-
-        [GeneratorBindings(source: "source", sourceImplements: "IValueEnumerable`2")]
-        [StructLayout(LayoutKind.Auto)]
-        public partial struct ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>
-            : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-        {
-            internal readonly TEnumerable source;
-            internal TGetEnumerator getEnumerator;
-            internal TGetEnumerator2 getEnumerator2;
-
-            internal ValueEnumerable(TEnumerable source, TGetEnumerator getEnumerator, TGetEnumerator2 getEnumerator2)
-                => (this.source, this.getEnumerator, this.getEnumerator2) = (source, getEnumerator, getEnumerator2);
-
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerator2 GetEnumerator() 
-                => getEnumerator2.Invoke(source);
-            readonly TEnumerator IValueEnumerable<TSource, TEnumerator>.GetEnumerator() 
-                => getEnumerator.Invoke(source);
-            readonly IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                => source.GetEnumerator();
-            readonly IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                => source.GetEnumerator();
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerable AsEnumerable()
-                => source;
-
-            public TSource[] ToArray()
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Array.Empty<TSource>();
-
-                    var result = Utils.AllocateUninitializedArray<TSource>(collection.Count);
-                    collection.CopyTo(result, 0);
-                    return result;
-                }
-                
-                using var arrayBuilder = ToArrayBuilder<TEnumerable, TEnumerator, TSource>(source, ArrayPool<TSource>.Shared, false);
-                return arrayBuilder.ToArray();
-            }
-
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    if (collection.Count is 0)
-                        return Lease.Empty<TSource>();
-                
-                    var result = pool.Lease(collection.Count, clearOnDispose);
-                    collection.CopyTo(result.Rented, 0);
-                    return result;                
-                }
-
-                using var arrayBuilder = ToArrayBuilder<TEnumerable, TEnumerator, TSource>(source, pool, clearOnDispose);
-                return arrayBuilder.ToArray(pool, clearOnDispose);
-            }
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Quantifier
-            
-            public readonly bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return source.Contains<TEnumerable, TEnumerator, TSource>(value, comparer);
-            }
-            
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<int, TEnumerator>
-            where TEnumerator : struct, IEnumerator<int>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<int?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<int?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, int?, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<nint, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<nint?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, nint?, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<nuint, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nuint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<nuint?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nuint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<long, TEnumerator>
-            where TEnumerator : struct, IEnumerator<long>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<long?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<long?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<float, TEnumerator>
-            where TEnumerator : struct, IEnumerator<float>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<float?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<float?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<double, TEnumerator>
-            where TEnumerator : struct, IEnumerator<double>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<double?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<double?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<decimal, TEnumerator>
-            where TEnumerator : struct, IEnumerator<decimal>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueEnumerable<decimal?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<decimal?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.source.Sum<TEnumerable, TEnumerator, decimal?, decimal>();
-    }
-}
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.cs
deleted file mode 100644
index b5c96d2b9..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyCollection.cs
+++ /dev/null
@@ -1,361 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueReadOnlyCollectionExtensions
-    {
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator>> AsValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AsValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetEnumerator, TGetEnumerator> AsValueEnumerable<TEnumerable, TEnumerator, TSource, TGetEnumerator>(this TEnumerable source, TGetEnumerator getEnumerator = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            => new(source, getEnumerator, getEnumerator);
-
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator, Func<TEnumerable, TEnumerator2> getEnumerator2)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            => AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator), new FunctionWrapper<TEnumerable, TEnumerator2>(getEnumerator2));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this TEnumerable source, TGetEnumerator getEnumerator = default, TGetEnumerator2 getEnumerator2 = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => new(source, getEnumerator, getEnumerator2);
-
-        [GeneratorBindings(source: "source", sourceImplements: "IValueReadOnlyCollection`2,IValueEnumerable`2")]
-        [StructLayout(LayoutKind.Auto)]
-        public partial struct ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>
-            : IValueReadOnlyCollection<TSource, TEnumerator> 
-            , ICollection<TSource>
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-        {
-            readonly TEnumerable source;
-#pragma warning disable IDE0044 // Add readonly modifier
-            TGetEnumerator getEnumerator;
-            TGetEnumerator2 getEnumerator2;
-#pragma warning restore IDE0044 // Add readonly modifier
-
-            internal ValueEnumerable(TEnumerable source, TGetEnumerator getEnumerator, TGetEnumerator2 getEnumerator2)
-                => (this.source, this.getEnumerator, this.getEnumerator2) = (source, getEnumerator, getEnumerator2);
-            
-            public readonly int Count
-                => source.Count;
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerator2 GetEnumerator() 
-                => getEnumerator2.Invoke(source);
-            readonly TEnumerator IValueEnumerable<TSource, TEnumerator>.GetEnumerator() 
-                => getEnumerator.Invoke(source);
-            readonly IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-            readonly IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-
-            readonly bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public readonly void CopyTo(TSource[] array, int arrayIndex)
-            {
-                if (Count is 0)
-                    return;
-                
-                if (array.Length - arrayIndex < Count)
-                    Throw.ArgumentException(Resource.DestinationNotLongEnough, nameof(array));
-
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    collection.CopyTo(array, arrayIndex);
-                }
-                else
-                {
-                    using var enumerator = getEnumerator.Invoke(source);
-                    if (arrayIndex is 0 && array.Length == Count)
-                    {
-                        for (var index = 0; index < array.Length; index++) // to enable range check elimination
-                        {
-                            _ = enumerator.MoveNext();
-                            array[index] = enumerator.Current;
-                        }                        
-                    }
-                    else
-                    {
-                        checked
-                        {
-                            for (var index = arrayIndex; enumerator.MoveNext(); index++)
-                                array[index] = enumerator.Current;
-                        }
-                    }
-                }
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            readonly bool ICollection<TSource>.Contains(TSource item)
-                => Contains(item, default);
-
-            [ExcludeFromCodeCoverage]
-            readonly void ICollection<TSource>.Add(TSource item) 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            readonly void ICollection<TSource>.Clear() 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            readonly bool ICollection<TSource>.Remove(TSource item) 
-                => Throw.NotSupportedException<bool>();
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerable AsEnumerable()
-                => source;
-            
-            public readonly TSource[] ToArray()
-            {
-                if (source.Count is 0)
-                    return Array.Empty<TSource>();
-
-                var result = Utils.AllocateUninitializedArray<TSource>(source.Count);
-                CopyTo(result, 0);
-                return result;
-            }
-            
-            public readonly Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                if (source.Count is 0)
-                    return Lease.Empty<TSource>();
-
-                var result = pool.Lease(source.Count, clearOnDispose);
-                CopyTo(result.Rented, 0);
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-            
-            #region Quantifier
-            
-            public readonly bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                if (Count is 0)
-                    return false;
-                
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return ValueReadOnlyCollectionExtensions.Contains<TEnumerable, TEnumerator, TSource>(source, value, comparer);
-            }
-            
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2, TPredicate>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2, TPredicate>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<int, TEnumerator>
-            where TEnumerator : struct, IEnumerator<int>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2>, TEnumerator, int, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<int?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<int?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2>, TEnumerator, int?, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<nint, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<nint?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint?, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<nuint, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nuint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<nuint?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nuint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint?, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<long, TEnumerator>
-            where TEnumerator : struct, IEnumerator<long>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2>, TEnumerator, long, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<long?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<long?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2>, TEnumerator, long?, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<float, TEnumerator>
-            where TEnumerator : struct, IEnumerator<float>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2>, TEnumerator, float, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<float?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<float?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2>, TEnumerator, float?, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<double, TEnumerator>
-            where TEnumerator : struct, IEnumerator<double>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2>, TEnumerator, double, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<double?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<double?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2>, TEnumerator, double?, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<decimal, TEnumerator>
-            where TEnumerator : struct, IEnumerator<decimal>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal, decimal>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyCollection<decimal?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<decimal?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal?, decimal>(source);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.cs
deleted file mode 100644
index 50a3711f8..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'6.ValueReadOnlyList.cs
+++ /dev/null
@@ -1,428 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueReadOnlyListExtensions
-    {
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator>> AsValueEnumerable<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AsValueEnumerable<TEnumerable, TEnumerator, TSource, FunctionWrapper<TEnumerable, TEnumerator>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator, TSource, TGetEnumerator, TGetEnumerator> AsValueEnumerable<TEnumerable, TEnumerator, TSource, TGetEnumerator>(this TEnumerable source, TGetEnumerator getEnumerator = default)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            => new(source, getEnumerator, getEnumerator);
-
-        
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource>(this TEnumerable source, Func<TEnumerable, TEnumerator> getEnumerator, Func<TEnumerable, TEnumerator2> getEnumerator2)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            => AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, FunctionWrapper<TEnumerable, TEnumerator>, FunctionWrapper<TEnumerable, TEnumerator2>>(source, new FunctionWrapper<TEnumerable, TEnumerator>(getEnumerator), new FunctionWrapper<TEnumerable, TEnumerator2>(getEnumerator2));
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this TEnumerable source, TGetEnumerator getEnumerator = default, TGetEnumerator2 getEnumerator2 = default)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => new(source, getEnumerator, getEnumerator2);
-
-        [GeneratorBindings(source: "source", sourceImplements: "IValueReadOnlyList`2,IValueEnumerable`2")]
-        [StructLayout(LayoutKind.Auto)]
-        public partial struct ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>
-            : IValueReadOnlyList<TSource, TEnumerator> 
-            , IList<TSource>
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-        {
-            readonly TEnumerable source;
-#pragma warning disable IDE0044 // Add readonly modifier
-            TGetEnumerator getEnumerator;
-            TGetEnumerator2 getEnumerator2;
-#pragma warning restore IDE0044 // Add readonly modifier
-
-            internal ValueEnumerable(TEnumerable source, TGetEnumerator getEnumerator, TGetEnumerator2 getEnumerator2)
-                => (this.source, this.getEnumerator, this.getEnumerator2) = (source, getEnumerator, getEnumerator2);
-
-            public readonly TSource this[int index]
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => source[index];
-            }
-            readonly TSource IList<TSource>.this[int index]
-            {
-                get => source[index];
-                set => Throw.NotSupportedException();
-            }
-
-            public readonly int Count
-                => source.Count;
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerator2 GetEnumerator() 
-                => getEnumerator2.Invoke(source);
-            readonly TEnumerator IValueEnumerable<TSource, TEnumerator>.GetEnumerator() 
-                => getEnumerator.Invoke(source);
-            readonly IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-            readonly IEnumerator IEnumerable.GetEnumerator() 
-                // ReSharper disable once HeapView.BoxingAllocation
-                => source.GetEnumerator();
-
-            readonly bool ICollection<TSource>.IsReadOnly  
-                => true;
-
-            public readonly void CopyTo(TSource[] array, int arrayIndex)
-            {
-                if (Count is 0)
-                    return;
-                
-                if (array.Length - arrayIndex < Count)
-                    Throw.ArgumentException(Resource.DestinationNotLongEnough, nameof(array));
-
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is ICollection<TSource> collection)
-                {
-                    collection.CopyTo(array, arrayIndex);
-                }
-                else
-                {
-                    using var enumerator = getEnumerator.Invoke(source);
-                    if (arrayIndex is 0 && array.Length == Count) // to enable range check elimination
-                    {
-                        for (var index = 0; index < array.Length; index++)
-                        {
-                            _ = enumerator.MoveNext();
-                            array[index] = enumerator.Current;
-                        }                        
-                    }
-                    else
-                    {
-                        checked
-                        {
-                            for (var index = arrayIndex; enumerator.MoveNext(); index++)
-                                array[index] = enumerator.Current;
-                        }
-                    }
-                }
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            readonly bool ICollection<TSource>.Contains(TSource item)
-                => Contains(item, default);
-
-            public readonly int IndexOf(TSource item)
-            {
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (source is IList<TSource> list)
-                    return list.IndexOf(item);
-                
-                using var enumerator = getEnumerator.Invoke(source);
-                for (var index = 0; enumerator.MoveNext(); index++)
-                {
-                    if (EqualityComparer<TSource>.Default.Equals(enumerator.Current, item))
-                        return index;
-                }
-                return -1;
-            }
-
-            [ExcludeFromCodeCoverage]
-            readonly void ICollection<TSource>.Add(TSource item) 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            readonly void ICollection<TSource>.Clear() 
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            readonly bool ICollection<TSource>.Remove(TSource item) 
-                => Throw.NotSupportedException<bool>();
-
-            [ExcludeFromCodeCoverage]
-            readonly void IList<TSource>.Insert(int index, TSource item) 
-                => Throw.NotSupportedException<bool>();
-            [ExcludeFromCodeCoverage]
-            readonly void IList<TSource>.RemoveAt(int index) 
-                => Throw.NotSupportedException<bool>();
-
-            #region Partitioning
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ReadOnlyListExtensions.SkipTakeEnumerable<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TSource> Skip(int count)
-                => this.Skip<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TSource>(count);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ReadOnlyListExtensions.SkipTakeEnumerable<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TSource> Take(int count)
-                => this.Take<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TSource>(count);
-
-            #endregion
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly TEnumerable AsEnumerable()
-                => source;
-            
-            public readonly TSource[] ToArray()
-            {
-                if (source.Count is 0)
-                    return Array.Empty<TSource>();
-
-                var result = Utils.AllocateUninitializedArray<TSource>(source.Count);
-                CopyTo(result, 0);
-                return result;
-            }
-            
-            public readonly Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-            {
-                if (source.Count is 0)
-                    return Lease.Empty<TSource>();
-
-                var result = pool.Lease(source.Count, clearOnDispose);
-                CopyTo(result.Rented, 0);
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly List<TSource> ToList()
-                => ToArray().AsList();
-
-            #endregion
-
-            #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly SelectEnumerable<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, TResult> selector)
-                => Select<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult>(this, selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly SelectEnumerable<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, TResult>
-                => Select<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult, TSelector>(this, selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly SelectAtEnumerable<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TResult>(Func<TSource, int, TResult> selector)
-                => Select<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult>(this, selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public readonly SelectAtEnumerable<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult, TSelector> SelectAt<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, int, TResult>
-                => SelectAt<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>, TEnumerator, TSource, TResult, TSelector>(this, selector);
-
-            #endregion
-            
-            #region Quantifier
-            
-            public readonly bool Contains(TSource value, IEqualityComparer<TSource>? comparer = default)
-            {
-                if (Count is 0)
-                    return false;
-                
-                // ReSharper disable once HeapView.PossibleBoxingAllocation
-                if (comparer.UseDefaultComparer() && source is ICollection<TSource> collection)
-                    return collection.Contains(value);
-
-                return ValueReadOnlyCollectionExtensions.Contains<TEnumerable, TEnumerator, TSource>(source, value, comparer);
-            }
-            
-            #endregion        
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2, TPredicate>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2, TPredicate>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetEnumerator, TGetEnumerator2> source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyList<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<int, TEnumerator>
-            where TEnumerator : struct, IEnumerator<int>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int, TGetEnumerator, TGetEnumerator2>, TEnumerator, int, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<int?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<int?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, int?, TGetEnumerator, TGetEnumerator2>, TEnumerator, int?, int>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<nint, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<nint?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nint?, nint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<nuint, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nuint>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<nuint?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<nuint?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, nuint?, TGetEnumerator, TGetEnumerator2>, TEnumerator, nuint?, nuint>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<long, TEnumerator>
-            where TEnumerator : struct, IEnumerator<long>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long, TGetEnumerator, TGetEnumerator2>, TEnumerator, long, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<long?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<long?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, long?, TGetEnumerator, TGetEnumerator2>, TEnumerator, long?, long>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<float, TEnumerator>
-            where TEnumerator : struct, IEnumerator<float>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float, TGetEnumerator, TGetEnumerator2>, TEnumerator, float, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<float?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<float?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, float?, TGetEnumerator, TGetEnumerator2>, TEnumerator, float?, float>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<double, TEnumerator>
-            where TEnumerator : struct, IEnumerator<double>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double, TGetEnumerator, TGetEnumerator2>, TEnumerator, double, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<double?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<double?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, double?, TGetEnumerator, TGetEnumerator2>, TEnumerator, double?, double>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<decimal, TEnumerator>
-            where TEnumerator : struct, IEnumerator<decimal>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal, decimal>(source);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum<TEnumerable, TEnumerator, TEnumerator2, TGetEnumerator, TGetEnumerator2>(this ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2> source)
-            where TEnumerable : IValueReadOnlyList<decimal?, TEnumerator>
-            where TEnumerator : struct, IEnumerator<decimal?>
-            where TEnumerator2 : struct
-            where TGetEnumerator : struct, IFunction<TEnumerable, TEnumerator>
-            where TGetEnumerator2 : struct, IFunction<TEnumerable, TEnumerator2>
-            => ValueReadOnlyCollectionExtensions.Sum<ValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, decimal?, TGetEnumerator, TGetEnumerator2>, TEnumerator, decimal?, decimal>(source);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs
deleted file mode 100644
index fadda85ae..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs
+++ /dev/null
@@ -1,459 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ArrayExtensions
-    {
-
-        [GeneratorIgnore]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ArraySegmentValueEnumerable<TSource> AsValueEnumerable<TSource>(this ArraySegment<TSource> source)
-            => new(source);
-
-        [GeneratorBindings(source: "((ReadOnlySpan<TSource>)source.AsSpan())", sourceImplements: "ReadOnlySpan`1")]
-        [StructLayout(LayoutKind.Auto)]
-        public readonly partial struct ArraySegmentValueEnumerable<TSource>
-            : IValueReadOnlyList<TSource, ArraySegmentValueEnumerable<TSource>.DisposableEnumerator>
-            , IList<TSource>
-        {
-            internal readonly ArraySegment<TSource> source;
-
-            internal ArraySegmentValueEnumerable(ArraySegment<TSource> source)
-                => this.source = source;
-
-            public int Count
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => source.Count;
-            }
-
-            public TSource this[int index]
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get
-                {
-                    ThrowIfArgument.OutOfRange(index, Count, nameof(index));
-                    return source.Array![source.Offset + index];
-                }
-            }
-
-            TSource IList<TSource>.this[int index]
-            {
-                get => this[index];
-
-                [ExcludeFromCodeCoverage]
-                // ReSharper disable once ValueParameterNotUsed
-                set => Throw.NotSupportedException();
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SpanEnumerator<TSource> GetEnumerator()
-                => new(source);
-
-            DisposableEnumerator IValueEnumerable<TSource, DisposableEnumerator>.GetEnumerator()
-                => new(source);
-
-            IEnumerator<TSource> IEnumerable<TSource>.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator(source);
-
-            IEnumerator IEnumerable.GetEnumerator()
-                // ReSharper disable once HeapView.BoxingAllocation
-                => new DisposableEnumerator(source);
-
-
-            bool ICollection<TSource>.IsReadOnly
-                => true;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void CopyTo(TSource[] array, int arrayIndex)
-                => source.AsSpan().CopyTo(array.AsSpan(arrayIndex));
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Contains(TSource item)
-                => source.Contains(item);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int IndexOf(TSource item)
-            {
-                var index = Array.IndexOf(source.Array!, item, source.Offset, source.Count);
-                return index < 0 
-                    ? -1
-                    : index - source.Offset;
-            }
-            
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Add(TSource item)
-                => Throw.NotSupportedException();
-            [ExcludeFromCodeCoverage]
-            bool ICollection<TSource>.Remove(TSource item)
-                => Throw.NotSupportedException<bool>();
-            [ExcludeFromCodeCoverage]
-            void ICollection<TSource>.Clear()
-                => Throw.NotSupportedException();
-
-            [ExcludeFromCodeCoverage]
-            void IList<TSource>.Insert(int index, TSource item)
-                => Throw.NotSupportedException();
-
-            [ExcludeFromCodeCoverage]
-            void IList<TSource>.RemoveAt(int index)
-                => Throw.NotSupportedException();
-
-            [StructLayout(LayoutKind.Auto)]
-            public struct DisposableEnumerator
-                : IEnumerator<TSource>
-            {
-                readonly ArraySegment<TSource> source;
-                int index;
-
-                internal DisposableEnumerator(ArraySegment<TSource> source)
-                {
-                    this.source = source;
-                    index = -1;
-                }
-
-                public readonly TSource Current
-                {
-                    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    get => source.Array![source.Offset + index];
-                }
-                readonly object? IEnumerator.Current
-                    // ReSharper disable once HeapView.PossibleBoxingAllocation
-                    => Current;
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public bool MoveNext()
-                {
-                    if (index < source.Count)
-                    {
-                        index++;
-                        return index < source.Count;
-                    }
-                    return false;
-                }
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                [ExcludeFromCodeCoverage]
-                public void Reset()
-                    => index = -1;
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public readonly void Dispose() { }
-            }
-
-            #region Aggregation
-
-            #endregion
-
-            #region Conversion
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentValueEnumerable<TSource> AsValueEnumerable()
-                => this;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegment<TSource> AsEnumerable()
-                => source;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public TSource[] ToArray()
-                => source.AsSpan().ToArray();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Lease<TSource> ToArray(ArrayPool<TSource> pool, bool clearOnDispose = default)
-                => source.AsSpan().ToArray(pool, clearOnDispose);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public List<TSource> ToList()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToList();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey>(Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary(keySelector, comparer);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TSource> ToDictionary<TKey, TKeySelector>(TKeySelector keySelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                where TKeySelector : struct, IFunction<TSource, TKey>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary(keySelector, comparer);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement>(Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary(keySelector, elementSelector, comparer);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TKeySelector, TElementSelector>(TKeySelector keySelector, TElementSelector elementSelector, IEqualityComparer<TKey>? comparer = default)
-                where TKey : notnull
-                where TKeySelector : struct, IFunction<TSource, TKey>
-                where TElementSelector : struct, IFunction<TSource, TElement>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).ToDictionary<TSource, TKey, TElement, TKeySelector, TElementSelector>(keySelector, elementSelector, comparer);
-
-            #endregion
-
-            #region Element
-
-            public Option<TSource> ElementAt(int index)
-                => index < 0 || index >= source.Count 
-                    ? Option.None 
-                    : Option.Some(source.Array![source.Offset + index]);
-
-            public Option<TSource> First()
-                => source switch
-                {
-                    { Count: 0 } => Option.None,
-                    _ => Option.Some(source.Array![source.Offset])
-                };
-            
-            public Option<TSource> Single()
-                => source switch
-                {
-                    { Count: 1 } => Option.Some(source.Array![source.Offset]),
-                    _ => Option.None,
-                };
-            
-            #endregion
-
-            #region Filtering
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentWhereEnumerable<TSource, FunctionWrapper<TSource, bool>> Where(Func<TSource, bool> predicate)
-                => source.Where(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentWhereEnumerable<TSource, TPredicate> Where<TPredicate>(TPredicate predicate = default)
-                where TPredicate : struct, IFunction<TSource, bool>
-                => source.Where(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentWhereAtEnumerable<TSource, FunctionWrapper<TSource, int, bool>> Where(Func<TSource, int, bool> predicate)
-                => source.Where(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentWhereAtEnumerable<TSource, TPredicate> WhereAt<TPredicate>(TPredicate predicate = default)
-                where TPredicate : struct, IFunction<TSource, int, bool>
-                => source.WhereAt(predicate);
-
-            #endregion
-
-            #region Partitioning
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentValueEnumerable<TSource> Skip(int count)
-            {
-                var (newOffset, newCount) = Utils.Skip(source.Count, count);
-                return new ArraySegmentValueEnumerable<TSource>(new ArraySegment<TSource>(source.Array!, source.Offset + newOffset, newCount));
-            }
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentValueEnumerable<TSource> Take(int count)
-                => new(new ArraySegment<TSource>(source.Array!, source.Offset, Utils.Take(source.Count, count)));
-
-            #endregion
-
-            #region Projection
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentSelectEnumerable<TSource, TResult, FunctionWrapper<TSource, TResult>> Select<TResult>(Func<TSource, TResult> selector)
-                => source.Select(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentSelectEnumerable<TSource, TResult, TSelector> Select<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, TResult>
-                => source.Select<TSource, TResult, TSelector>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentSelectAtEnumerable<TSource, TResult, FunctionWrapper<TSource, int, TResult>> Select<TResult>(Func<TSource, int, TResult> selector)
-                => source.Select(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentSelectAtEnumerable<TSource, TResult, TSelector> SelectAt<TResult, TSelector>(TSelector selector = default)
-                where TSelector : struct, IFunction<TSource, int, TResult>
-                => source.SelectAt<TSource, TResult, TSelector>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, FunctionWrapper<TSource, TSubEnumerable>> SelectMany<TSubEnumerable, TSubEnumerator, TResult>(Func<TSource, TSubEnumerable> selector)
-                where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult>
-                => source.SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult>(selector);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentSelectManyEnumerable<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector> SelectMany<TSubEnumerable, TSubEnumerator, TResult, TSelector>(TSelector selector = default)
-                where TSubEnumerable : IValueEnumerable<TResult, TSubEnumerator>
-                where TSubEnumerator : struct, IEnumerator<TResult>
-                where TSelector : struct, IFunction<TSource, TSubEnumerable>
-                => source.SelectMany<TSource, TSubEnumerable, TSubEnumerator, TResult, TSelector>(selector);
-
-            #endregion
-
-            #region Quantifier
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, bool> predicate)
-                => All(new FunctionWrapper<TSource, bool>(predicate));
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All<TPredicate>(TPredicate predicate)
-                where TPredicate : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).All(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool All(Func<TSource, int, bool> predicate)
-                => AllAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool AllAt<TPredicate>(TPredicate predicate)
-                where TPredicate : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AllAt(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any()
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Any();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, bool> predicate)
-                => Any(new FunctionWrapper<TSource, bool>(predicate));
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any<TPredicate>(TPredicate predicate)
-                where TPredicate : struct, IFunction<TSource, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Any(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Any(Func<TSource, int, bool> predicate)
-                => AnyAt(new FunctionWrapper<TSource, int, bool>(predicate));
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool AnyAt<TPredicate>(TPredicate predicate)
-                where TPredicate : struct, IFunction<TSource, int, bool>
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).AnyAt(predicate);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Contains(TSource value, IEqualityComparer<TSource>? comparer)
-                => ((ReadOnlySpan<TSource>)source.AsSpan()).Contains(value, comparer);
-
-            #endregion
-
-            #region Set
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ArraySegmentDistinctEnumerable<TSource> Distinct(IEqualityComparer<TSource>? comparer = default)
-                => source.Distinct(comparer);
-
-            #endregion
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this ArraySegmentValueEnumerable<TSource> source)
-            => source.Count;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this ArraySegmentValueEnumerable<TSource> source, Func<TSource, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource, TPredicate>(this ArraySegmentValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TSource>(this ArraySegmentValueEnumerable<TSource> source, Func<TSource, int, bool> predicate)
-            => source.Count(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int CountAt<TSource, TPredicate>(this ArraySegmentValueEnumerable<TSource> source, TPredicate predicate = default)
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.CountAt(predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ArraySegmentValueEnumerable<int> source)
-            => ((ReadOnlySpan<int>)source.source.AsSpan()).SumVector<int, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Sum(this ArraySegmentValueEnumerable<int?> source)
-            => ((ReadOnlySpan<int?>)source.source.AsSpan()).Sum<int?, int>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ArraySegmentValueEnumerable<nint> source)
-            => ((ReadOnlySpan<nint>)source.source.AsSpan()).SumVector<nint, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint Sum(this ArraySegmentValueEnumerable<nint?> source)
-            => ((ReadOnlySpan<nint?>)source.source.AsSpan()).Sum<nint?, nint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ArraySegmentValueEnumerable<nuint> source)
-            => ((ReadOnlySpan<nuint>)source.source.AsSpan()).SumVector<nuint, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nuint Sum(this ArraySegmentValueEnumerable<nuint?> source)
-            => ((ReadOnlySpan<nuint?>)source.source.AsSpan()).Sum<nuint?, nuint>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ArraySegmentValueEnumerable<long> source)
-            => ((ReadOnlySpan<long>)source.source.AsSpan()).SumVector<long, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long Sum(this ArraySegmentValueEnumerable<long?> source)
-            => ((ReadOnlySpan<long?>)source.source.AsSpan()).Sum<long?, long>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ArraySegmentValueEnumerable<float> source)
-            => ((ReadOnlySpan<float>)source.source.AsSpan()).SumVector<float, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Sum(this ArraySegmentValueEnumerable<float?> source)
-            => ((ReadOnlySpan<float?>)source.source.AsSpan()).Sum<float?, float>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ArraySegmentValueEnumerable<double> source)
-            => ((ReadOnlySpan<double>)source.source.AsSpan()).SumVector<double, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double Sum(this ArraySegmentValueEnumerable<double?> source)
-            => ((ReadOnlySpan<double?>)source.source.AsSpan()).Sum<double?, double>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ArraySegmentValueEnumerable<decimal> source)
-            => ((ReadOnlySpan<decimal>)source.source.AsSpan()).Sum<decimal, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static decimal Sum(this ArraySegmentValueEnumerable<decimal?> source)
-            => ((ReadOnlySpan<decimal?>)source.source.AsSpan()).Sum<decimal?, decimal>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool ContainsVector<TSource>(this ArraySegmentValueEnumerable<TSource> source, TSource value)
-            where TSource : struct
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).ContainsVector(value);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanSelectVectorContext<TSource, TResult, FunctionWrapper<Vector<TSource>, Vector<TResult>>, FunctionWrapper<TSource, TResult>> SelectVector<TSource, TResult>(this ArraySegmentValueEnumerable<TSource> source, Func<Vector<TSource>, Vector<TResult>> vectorSelector, Func<TSource, TResult> selector)
-            where TSource : struct
-            where TResult : struct
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).SelectVector(vectorSelector, selector);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanSelectVectorContext<TSource, TResult, TSelector, TSelector> SelectVector<TSource, TResult, TSelector>(this ArraySegmentValueEnumerable<TSource> source, TSelector selector = default)
-            where TSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>, IFunction<TSource, TResult>
-            where TSource : struct
-            where TResult : struct
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).SelectVector<TSource, TResult, TSelector, TSelector>(selector, selector);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanSelectVectorContext<TSource, TResult, TVectorSelector, TSelector> SelectVector<TSource, TResult, TVectorSelector, TSelector>(this ArraySegmentValueEnumerable<TSource> source, TVectorSelector vectorSelector = default, TSelector selector = default)
-            where TVectorSelector : struct, IFunction<Vector<TSource>, Vector<TResult>>
-            where TSelector : struct, IFunction<TSource, TResult>
-            where TSource : struct
-            where TResult : struct
-            => ((ReadOnlySpan<TSource>)source.source.AsSpan()).SelectVector<TSource, TResult, TVectorSelector, TSelector>(vectorSelector, selector);
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/DictionaryExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/DictionaryExtensions.cs
deleted file mode 100644
index 404d18218..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/DictionaryExtensions.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class DictionaryExtensions
-    {
-        // Dictionary<TKey, TValue> is reference-type that implements IReadOnlyCollection<TKey, TValue> and has a value-type enumerator that implements IEnumerator<TKey, TValue>
-        // Same for Dictionary<TKey, TValue>.KeyCollection and Dictionary<TKey, TValue>.ValueCollection
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<Dictionary<TKey, TValue>, Dictionary<TKey, TValue>.Enumerator, Dictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this Dictionary<TKey, TValue> source)
-            where TKey : notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<Dictionary<TKey, TValue>, Dictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>>(source);
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<Dictionary<TKey, TValue>.KeyCollection, Dictionary<TKey, TValue>.KeyCollection.Enumerator, Dictionary<TKey, TValue>.KeyCollection.Enumerator, TKey, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this Dictionary<TKey, TValue>.KeyCollection source)
-            where TKey : notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<Dictionary<TKey, TValue>.KeyCollection, Dictionary<TKey, TValue>.KeyCollection.Enumerator, TKey, GetEnumerator<TKey, TValue>>(source);
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<Dictionary<TKey, TValue>.ValueCollection, Dictionary<TKey, TValue>.ValueCollection.Enumerator, Dictionary<TKey, TValue>.ValueCollection.Enumerator, TValue, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this Dictionary<TKey, TValue>.ValueCollection source)
-            where TKey : notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<Dictionary<TKey, TValue>.ValueCollection, Dictionary<TKey, TValue>.ValueCollection.Enumerator, TValue, GetEnumerator<TKey, TValue>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TKey, TValue>
-            : IFunction<Dictionary<TKey, TValue>, Dictionary<TKey, TValue>.Enumerator> 
-            , IFunction<Dictionary<TKey, TValue>.KeyCollection, Dictionary<TKey, TValue>.KeyCollection.Enumerator>
-            , IFunction<Dictionary<TKey, TValue>.ValueCollection, Dictionary<TKey, TValue>.ValueCollection.Enumerator>
-            where TKey : notnull
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TValue>.Enumerator Invoke(Dictionary<TKey, TValue> source) 
-                => source.GetEnumerator();
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TValue>.KeyCollection.Enumerator Invoke(Dictionary<TKey, TValue>.KeyCollection source) 
-                => source.GetEnumerator();
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Dictionary<TKey, TValue>.ValueCollection.Enumerator Invoke(Dictionary<TKey, TValue>.ValueCollection source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSetExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSetExtensions.cs
deleted file mode 100644
index 369e75988..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/HashSetExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class HashSetExtensions
-    {
-        // HashSet<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<HashSet<TSource>, HashSet<TSource>.Enumerator, HashSet<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this HashSet<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<HashSet<TSource>, HashSet<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<HashSet<TSource>, HashSet<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public HashSet<TSource>.Enumerator Invoke(HashSet<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedListExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedListExtensions.cs
deleted file mode 100644
index f14f1d7c7..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/LinkedListExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class LinkedListExtensions
-    {
-        // LinkedList<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<LinkedList<TSource>, LinkedList<TSource>.Enumerator, LinkedList<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this LinkedList<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<LinkedList<TSource>, LinkedList<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<LinkedList<TSource>, LinkedList<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public LinkedList<TSource>.Enumerator Invoke(LinkedList<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueueExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueueExtensions.cs
deleted file mode 100644
index 292eeb24d..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/PriorityQueueExtensions.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-#if NET6_0_OR_GREATER
-
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-
-    public static class PriorityQueueExtensions
-    {
-        // PriorityQueue<TElement, TPriority>.UnorderedItemsCollection is reference-type that implements IReadOnlyCollection<TElement> and has a value-type enumerator that implements IEnumerator<TElement>
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<PriorityQueue<TElement, TPriority>.UnorderedItemsCollection, PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator, PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator, (TElement Element, TPriority Priority), GetEnumerator<TElement, TPriority>, GetEnumerator<TElement, TPriority>> AsValueEnumerable<TElement, TPriority>(this PriorityQueue<TElement, TPriority>.UnorderedItemsCollection source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<PriorityQueue<TElement, TPriority>.UnorderedItemsCollection, PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator, (TElement Element, TPriority Priority), GetEnumerator<TElement, TPriority>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TElement, TPriority>
-            : IFunction<PriorityQueue<TElement, TPriority>.UnorderedItemsCollection, PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator Invoke(PriorityQueue<TElement, TPriority>.UnorderedItemsCollection source) 
-                => source.GetEnumerator();
-        }
-    }
-}
-
-#endif
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/QueueExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/QueueExtensions.cs
deleted file mode 100644
index 6080caba0..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/QueueExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class QueueExtensions
-    {
-        // Queue<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<Queue<TSource>, Queue<TSource>.Enumerator, Queue<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this Queue<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<Queue<TSource>, Queue<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<Queue<TSource>, Queue<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Queue<TSource>.Enumerator Invoke(Queue<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionaryExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionaryExtensions.cs
deleted file mode 100644
index ef820ddcc..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedDictionaryExtensions.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class SortedDictionaryExtensions
-    {
-        // SortedDictionary<TKey, TValue> is reference-type that implements IReadOnlyCollection<TKey, TValue> and has a value-type enumerator that implements IEnumerator<TKey, TValue>
-        // Same for SortedDictionary<TKey, TValue>.KeyCollection and SortedDictionary<TKey, TValue>.ValueCollection
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<SortedDictionary<TKey, TValue>, SortedDictionary<TKey, TValue>.Enumerator, SortedDictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this SortedDictionary<TKey, TValue> source)
-            where TKey : notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<SortedDictionary<TKey, TValue>, SortedDictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>>(source);
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<SortedDictionary<TKey, TValue>.KeyCollection, SortedDictionary<TKey, TValue>.KeyCollection.Enumerator, SortedDictionary<TKey, TValue>.KeyCollection.Enumerator, TKey, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this SortedDictionary<TKey, TValue>.KeyCollection source)
-            where TKey : notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<SortedDictionary<TKey, TValue>.KeyCollection, SortedDictionary<TKey, TValue>.KeyCollection.Enumerator, TKey, GetEnumerator<TKey, TValue>>(source);
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<SortedDictionary<TKey, TValue>.ValueCollection, SortedDictionary<TKey, TValue>.ValueCollection.Enumerator, SortedDictionary<TKey, TValue>.ValueCollection.Enumerator, TValue, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this SortedDictionary<TKey, TValue>.ValueCollection source)
-            where TKey : notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<SortedDictionary<TKey, TValue>.ValueCollection, SortedDictionary<TKey, TValue>.ValueCollection.Enumerator, TValue, GetEnumerator<TKey, TValue>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TKey, TValue>
-            : IFunction<SortedDictionary<TKey, TValue>, SortedDictionary<TKey, TValue>.Enumerator> 
-            , IFunction<SortedDictionary<TKey, TValue>.KeyCollection, SortedDictionary<TKey, TValue>.KeyCollection.Enumerator>
-            , IFunction<SortedDictionary<TKey, TValue>.ValueCollection, SortedDictionary<TKey, TValue>.ValueCollection.Enumerator>
-            where TKey : notnull
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SortedDictionary<TKey, TValue>.Enumerator Invoke(SortedDictionary<TKey, TValue> source) 
-                => source.GetEnumerator();
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SortedDictionary<TKey, TValue>.KeyCollection.Enumerator Invoke(SortedDictionary<TKey, TValue>.KeyCollection source) 
-                => source.GetEnumerator();
-            
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SortedDictionary<TKey, TValue>.ValueCollection.Enumerator Invoke(SortedDictionary<TKey, TValue>.ValueCollection source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSetExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSetExtensions.cs
deleted file mode 100644
index c5cedc01b..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/SortedSetExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class SortedSetExtensions
-    {
-        // SortedSet<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<SortedSet<TSource>, SortedSet<TSource>.Enumerator, SortedSet<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this SortedSet<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<SortedSet<TSource>, SortedSet<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<SortedSet<TSource>, SortedSet<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public SortedSet<TSource>.Enumerator Invoke(SortedSet<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/StackExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/StackExtensions.cs
deleted file mode 100644
index ad56d19c5..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Generic/StackExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class StackExtensions
-    {
-        // Stack<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<Stack<TSource>, Stack<TSource>.Enumerator, Stack<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this Stack<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<Stack<TSource>, Stack<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<Stack<TSource>, Stack<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Stack<TSource>.Enumerator Invoke(Stack<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionaryExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionaryExtensions.cs
deleted file mode 100644
index 2a51d9fa9..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableDictionaryExtensions.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ImmutableDictionaryExtensions
-    {
-        // ImmutableDictionary<TKey, TValue> is reference-type that implements IReadOnlyCollection<KeyValuePair<TKey, TValue>> and has a value-type enumerator that implements IEnumerator<TKey, TValue>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<ImmutableDictionary<TKey, TValue>, ImmutableDictionary<TKey, TValue>.Enumerator, ImmutableDictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this ImmutableDictionary<TKey, TValue> source)
-            where TKey: notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<ImmutableDictionary<TKey, TValue>, ImmutableDictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TKey, TValue>
-            : IFunction<ImmutableDictionary<TKey, TValue>, ImmutableDictionary<TKey, TValue>.Enumerator>
-            where TKey: notnull
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ImmutableDictionary<TKey, TValue>.Enumerator Invoke(ImmutableDictionary<TKey, TValue> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSetExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSetExtensions.cs
deleted file mode 100644
index 7f899c11c..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableHashSetExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ImmutableHashSetExtensions
-    {
-        // ImmutableHashSet<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<ImmutableHashSet<TSource>, ImmutableHashSet<TSource>.Enumerator, ImmutableHashSet<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this ImmutableHashSet<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<ImmutableHashSet<TSource>, ImmutableHashSet<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<ImmutableHashSet<TSource>, ImmutableHashSet<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ImmutableHashSet<TSource>.Enumerator Invoke(ImmutableHashSet<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableListExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableListExtensions.cs
deleted file mode 100644
index f759387ca..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableListExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ImmutableListExtensions
-    {
-        // ImmutableList<TSource> is reference-type that implements IReadOnlyCollection<TSource> and has a value-type enumerator that implements IEnumerator<TSource>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<ImmutableList<TSource>, ImmutableList<TSource>.Enumerator, ImmutableList<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator<TSource>> AsValueEnumerable<TSource>(this ImmutableList<TSource> source)
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<ImmutableList<TSource>, ImmutableList<TSource>.Enumerator, TSource, GetEnumerator<TSource>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<ImmutableList<TSource>, ImmutableList<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ImmutableList<TSource>.Enumerator Invoke(ImmutableList<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueueExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueueExtensions.cs
deleted file mode 100644
index e58289c03..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableQueueExtensions.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ImmutableQueueExtensions
-    {
-        // ImmutableQueue<TSource> is reference-type that implements IEnumerable<TSource> and has two enumerators:
-        // One that is a value-type and doesn't implement interfaces.
-        // Another that is a reference-type and implements IEnumerator<TSource>.
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static EnumerableExtensions.ValueEnumerable<ImmutableQueue<TSource>, ValueEnumerator<TSource>, ImmutableQueue<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator2<TSource>> AsValueEnumerable<TSource>(this ImmutableQueue<TSource> source)
-            => source.AsValueEnumerable<ImmutableQueue<TSource>, ValueEnumerator<TSource>, ImmutableQueue<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator2<TSource>>();
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<ImmutableQueue<TSource>, ValueEnumerator<TSource>> 
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerator<TSource> Invoke(ImmutableQueue<TSource> source) 
-                => new(((IEnumerable<TSource>)source).GetEnumerator());
-        }
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator2<TSource>
-            : IFunction<ImmutableQueue<TSource>, ImmutableQueue<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ImmutableQueue<TSource>.Enumerator Invoke(ImmutableQueue<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionaryExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionaryExtensions.cs
deleted file mode 100644
index c336609af..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableSortedDictionaryExtensions.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ImmutableSortedDictionaryExtensions
-    {
-        // ImmutableSortedDictionary<TKey, TValue> is reference-type that implements IReadOnlyCollection<KeyValuePair<TKey, TValue>> and has a value-type enumerator that implements IEnumerator<TKey, TValue>
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlyCollectionExtensions.ValueEnumerable<ImmutableSortedDictionary<TKey, TValue>, ImmutableSortedDictionary<TKey, TValue>.Enumerator, ImmutableSortedDictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>, GetEnumerator<TKey, TValue>> AsValueEnumerable<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue> source)
-            where TKey: notnull
-            => ReadOnlyCollectionExtensions.AsValueEnumerable<ImmutableSortedDictionary<TKey, TValue>, ImmutableSortedDictionary<TKey, TValue>.Enumerator, KeyValuePair<TKey, TValue>, GetEnumerator<TKey, TValue>>(source);
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TKey, TValue>
-            : IFunction<ImmutableSortedDictionary<TKey, TValue>, ImmutableSortedDictionary<TKey, TValue>.Enumerator>
-            where TKey: notnull
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ImmutableSortedDictionary<TKey, TValue>.Enumerator Invoke(ImmutableSortedDictionary<TKey, TValue> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStackExtensions.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStackExtensions.cs
deleted file mode 100644
index a153a1d07..000000000
--- a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableStackExtensions.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static class ImmutableStackExtensions
-    {
-        // ImmutableStack<TSource> is reference-type that implements IEnumerable<TSource> and has two enumerators:
-        // One that is a value-type and doesn't implement interfaces.
-        // Another that is a reference-type and implements IEnumerator<TSource>.
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static EnumerableExtensions.ValueEnumerable<ImmutableStack<TSource>, ValueEnumerator<TSource>, ImmutableStack<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator2<TSource>> AsValueEnumerable<TSource>(this ImmutableStack<TSource> source)
-            => source.AsValueEnumerable<ImmutableStack<TSource>, ValueEnumerator<TSource>, ImmutableStack<TSource>.Enumerator, TSource, GetEnumerator<TSource>, GetEnumerator2<TSource>>();
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator<TSource>
-            : IFunction<ImmutableStack<TSource>, ValueEnumerator<TSource>> 
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerator<TSource> Invoke(ImmutableStack<TSource> source) 
-                => new(((IEnumerable<TSource>)source).GetEnumerator());
-        }
-
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct GetEnumerator2<TSource>
-            : IFunction<ImmutableStack<TSource>, ImmutableStack<TSource>.Enumerator>
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ImmutableStack<TSource>.Enumerator Invoke(ImmutableStack<TSource> source) 
-                => source.GetEnumerator();
-        }
-    }
-}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Memory.cs b/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Memory.cs
deleted file mode 100644
index 0fbef647e..000000000
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Memory.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    static partial class ArrayExtensions
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Lease<TSource> ToArray<TSource>(this Memory<TSource> source, ArrayPool<TSource> pool, bool clearOnDispose = default)
-            => ((ReadOnlyMemory<TSource>)source).Span.ToArray(pool, clearOnDispose);
-    }
-}
-
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlyMemory.cs b/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlyMemory.cs
deleted file mode 100644
index 5b33812c9..000000000
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.ReadOnlyMemory.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    static partial class ArrayExtensions
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Lease<TSource> ToArray<TSource>(this ReadOnlyMemory<TSource> source, ArrayPool<TSource> pool, bool clearOnDispose = default)
-            => source.Span.ToArray(pool, clearOnDispose);
-    }
-}
-
diff --git a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Span.cs b/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Span.cs
deleted file mode 100644
index 204ed3e92..000000000
--- a/NetFabric.Hyperlinq/Conversion/ToArray/ToArray.Span.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-using System.Buffers;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    static partial class ArrayExtensions
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Lease<TSource> ToArray<TSource>(this Span<TSource> source, ArrayPool<TSource> pool, bool clearOnDispose = default)
-            => ((ReadOnlySpan<TSource>)source).ToArray(pool, clearOnDispose);
-    }
-}
-
diff --git a/NetFabric.Hyperlinq/Generator.AsValueEnumerable.cs b/NetFabric.Hyperlinq/Generator.AsValueEnumerable.cs
new file mode 100644
index 000000000..99d722e67
--- /dev/null
+++ b/NetFabric.Hyperlinq/Generator.AsValueEnumerable.cs
@@ -0,0 +1,470 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using NetFabric.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    public partial class Generator
+    {
+        static ValueEnumerableType? GenerateSourceAsValueEnumerable(Compilation compilation, SemanticModel semanticModel, TypeSymbolsCache typeSymbolsCache, MemberAccessExpressionSyntax expressionSyntax, CodeBuilder builder, Dictionary<MethodSignature, ValueEnumerableType> generatedMethods, CancellationToken cancellationToken)
+        {
+            // Check if the method is already defined in the project source
+            if (semanticModel.GetSymbolInfo(expressionSyntax, cancellationToken).Symbol is IMethodSymbol { } methodSymbol)
+                return methodSymbol.ReturnType.ToValueEnumerableType(typeSymbolsCache);
+
+            // Get the type this operator is applied to
+            var receiverTypeSymbol = semanticModel.GetTypeInfo(expressionSyntax.Expression, cancellationToken).Type;
+
+            // Check if NetFabric.Hyperlinq already contains specific overloads for this type
+            // This is required for when the 'using NetFabric.Hyperlinq;' statement is missing
+            if (receiverTypeSymbol is null
+                or { TypeKind: TypeKind.Array } // is array
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(ArraySegment<>)])
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(Span<>)])
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(ReadOnlySpan<>)])
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(Memory<>)])
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(ReadOnlyMemory<>)])
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(List<>)])
+                || SymbolEqualityComparer.Default.Equals(receiverTypeSymbol.OriginalDefinition, typeSymbolsCache[typeof(ImmutableArray<>)])
+                )
+                return null; // Do generate an implementation. The 'using NetFabric.Hyperlinq;' statement should be added instead.
+
+            // Receiver type implements IValueEnumerable<,>
+
+            var valueEnumerableType = AsValueEnumerable(expressionSyntax, compilation, semanticModel, typeSymbolsCache, expressionSyntax, builder, generatedMethods, cancellationToken);
+            if (valueEnumerableType is not null)
+            {
+                // Check if the method is already defined by this generator
+                var methodSignature = new MethodSignature("AsValueEnumerable", valueEnumerableType.Name);
+                if (generatedMethods.TryGetValue(methodSignature, out var returnType))
+                    return returnType;
+
+                // Receiver instance returns itself
+                _ = builder
+                    .Line()
+                    .GeneratedCodeMethodAttributes()
+                    .AggressiveInliningAttribute()
+                    .Line($"public static {valueEnumerableType.Name} AsValueEnumerable(this {valueEnumerableType.Name} source)")
+                    .Indent().Line($"=> source;");
+
+                // A new AsValueEnumerable() method has been generated
+                generatedMethods.Add(methodSignature, valueEnumerableType);
+                return valueEnumerableType;
+            }
+
+            // Receiver type is an enumerable
+
+            if (receiverTypeSymbol.IsEnumerable(compilation, out var enumerableSymbols))
+            {
+                var receiverTypeString = receiverTypeSymbol.ToDisplayString();
+
+                // Check if the method is already defined by this generator
+                var methodSignature = new MethodSignature("AsValueEnumerable", receiverTypeString);
+                if (generatedMethods.TryGetValue(methodSignature, out var returnType))
+                    return returnType;
+
+                // Use an unique identifier to avoid name clashing
+                var uniqueIdString = builder.IsUnitTest 
+                    ? receiverTypeString.Replace('.', '_').Replace(',', '_').Replace('<', '_').Replace('>', '_').Replace('`', '_')
+                    : Guid.NewGuid().ToString().Replace('-', '_'); // Use a GUID to avoid naming overflow
+
+                var enumerableTypeString = $"AsValueEnumerable_{uniqueIdString}";
+                var itemType = enumerableSymbols.EnumeratorSymbols.Current.Type;
+                var itemTypeString = itemType.ToDisplayString();
+
+                // Check if the returned type by GetEnumerator() does not require a wrapper
+                var getEnumeratorReturnType = enumerableSymbols.GetEnumerator.ReturnType;
+                var getEnumeratorReturnTypeString = getEnumeratorReturnType.ToDisplayString();
+
+                // Check what interfaces the enumerable implements, minimizing the calls to ImplementsInterface()
+                var enumerableIsIEnumerable = receiverTypeSymbol.ImplementsInterface(SpecialType.System_Collections_Generic_IEnumerable_T, out _);
+                var enumerableIsICollection = false;
+                var enumerableIsIReadOnlyCollection = false;
+                var enumerableIsIList = false;
+                var enumerableIsIReadOnlyList = false;
+                if (enumerableIsIEnumerable)
+                {
+                    enumerableIsICollection = receiverTypeSymbol.ImplementsInterface(SpecialType.System_Collections_Generic_ICollection_T, out _);
+                    if (enumerableIsICollection)
+                        enumerableIsIList = receiverTypeSymbol.ImplementsInterface(SpecialType.System_Collections_Generic_IList_T, out _);
+
+                    enumerableIsIReadOnlyCollection = receiverTypeSymbol.ImplementsInterface(SpecialType.System_Collections_Generic_IReadOnlyCollection_T, out _);
+                    if (enumerableIsIReadOnlyCollection)
+                        enumerableIsIReadOnlyList = receiverTypeSymbol.ImplementsInterface(SpecialType.System_Collections_Generic_IReadOnlyList_T, out _);
+                }
+
+                // Define what value enumerator type will be used
+                var enumeratorIsIEnumerator = getEnumeratorReturnType.ImplementsInterface(SpecialType.System_Collections_Generic_IEnumerator_T, out _);
+
+                var enumeratorTypeString = enumeratorIsIEnumerator
+                    ? getEnumeratorReturnType.IsValueType
+                        ? getEnumeratorReturnTypeString
+                        : $"ValueEnumerator<{itemTypeString}>"
+                    : $"{enumerableTypeString}.Enumerator";
+
+                // Generate the method
+                _ = builder
+                        .Line()
+                        .GeneratedCodeMethodAttributes()
+                        .AggressiveInliningAttribute()
+                        .Line($"public static {enumerableTypeString} AsValueEnumerable(this {receiverTypeString} source)")
+                        .Indent().Line($"=> new(source);");
+
+                // Generate the value enumerable wrapper
+                _ = builder
+                        .Line()
+                        .Line($"public readonly struct {enumerableTypeString}");
+
+                // Define what interfaces the wrapper implements
+                if (enumerableIsIList || enumerableIsIReadOnlyList)
+                    _ = builder.Indent().Line($": IValueReadOnlyList<{itemTypeString}, {enumeratorTypeString}>, IList<{itemTypeString}>");
+                else if (enumerableIsICollection || enumerableIsIReadOnlyCollection)
+                    _ = builder.Indent().Line($": IValueReadOnlyCollection<{itemTypeString}, {enumeratorTypeString}>, ICollection<{itemTypeString}>");
+                else
+                    _ = builder.Indent().Line($": IValueEnumerable<{itemTypeString}, {enumeratorTypeString}>");
+
+                using (builder.Block())
+                {
+                    // Define field and constructor
+                    _ = builder
+                            .Line($"readonly {receiverTypeString} source;")
+                            .Line()
+                            .Line($"internal {enumerableTypeString}({receiverTypeString} source)")
+                            .Indent().Line($"=> this.source = source;");
+
+                    // Implement interfaces
+                    ImplementIValueEnumerable(builder, enumerableSymbols, enumeratorTypeString, itemTypeString, enumeratorIsIEnumerator);
+                    if (enumerableIsICollection || enumerableIsIReadOnlyCollection)
+                    {
+                        var sourceIsReferenceType = receiverTypeSymbol.IsReferenceType;
+                        var itemIsReferenceType = itemType.IsReferenceType;
+                        ImplementICollection(builder, itemTypeString, sourceIsReferenceType, itemIsReferenceType, enumerableIsICollection);
+
+                        if (enumerableIsIList || enumerableIsIReadOnlyList)
+                            ImplementIList(builder, itemTypeString, sourceIsReferenceType, itemIsReferenceType, enumerableIsIList);
+                    }
+
+                    // A new AsValueEnumerable() method has been generated
+                    valueEnumerableType = new ValueEnumerableType(
+                        Name: enumerableTypeString,
+                        EnumeratorType: enumeratorTypeString,
+                        ItemType: itemTypeString,
+                        IsCollection: enumerableIsICollection || enumerableIsIReadOnlyCollection,
+                        IsList: enumerableIsIList || enumerableIsIReadOnlyList);
+                    generatedMethods.Add(methodSignature, valueEnumerableType);
+                    return valueEnumerableType;
+                }
+            }
+
+            return null;
+        }
+
+        static void ImplementIValueEnumerable(CodeBuilder builder, EnumerableSymbols enumerableSymbols, string enumeratorTypeString, string itemTypeString, bool enumeratorIsIEnumerator)
+        {
+            var getEnumeratorReturnType = enumerableSymbols.GetEnumerator.ReturnType;
+            var getEnumeratorReturnTypeString = getEnumeratorReturnType.ToDisplayString();
+
+            _ = builder
+                .Line()
+                .Line($"// Implement IValueEnumerable<{itemTypeString}, {enumeratorTypeString}>")
+                .Line();
+
+            if (enumeratorIsIEnumerator)
+            {
+                if (getEnumeratorReturnType.IsValueType)
+                {
+                    // No enumerator wrapper required
+                    _ = builder
+                        .AggressiveInliningAttribute()
+                        .Line($"public {enumeratorTypeString} GetEnumerator() => source.GetEnumerator();")
+                        .Line()
+                        .Line($"IEnumerator<{itemTypeString}> IEnumerable<{itemTypeString}>.GetEnumerator() => GetEnumerator();")
+                        .Line()
+                        .Line($"IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();");
+                }
+                else if (enumerableSymbols.GetEnumerator.ContainingType.IsInterface())
+                {
+                    // Use the ValueEnumerator<> enumerator wrapper
+                    _ = builder
+                        .AggressiveInliningAttribute()
+                        .Line($"public ValueEnumerator<{itemTypeString}> GetEnumerator() => new(source.GetEnumerator());")
+                        .Line()
+                        .Line($"IEnumerator<{itemTypeString}> IEnumerable<{itemTypeString}>.GetEnumerator() => source.GetEnumerator();")
+                        .Line()
+                        .Line($"IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();");
+                }
+                else
+                {
+                    // Use the ValueEnumerator<> enumerator wrapper
+                    _ = builder
+                        .AggressiveInliningAttribute()
+                        .Line($"public ValueEnumerator<{itemTypeString}> GetEnumerator() => new(source.GetEnumerator());")
+                        .Line()
+                        .Line($"IEnumerator<{itemTypeString}> IEnumerable<{itemTypeString}>.GetEnumerator() => source.GetEnumerator();")
+                        .Line()
+                        .Line($"IEnumerator IEnumerable.GetEnumerator() => source.GetEnumerator();");
+                }
+            }
+            else
+            {
+                // A custom enumerator wrapper is required
+
+                _ = builder
+                    .AggressiveInliningAttribute()
+                    .Line($"public Enumerator GetEnumerator() => new(source.GetEnumerator());")
+                    .Line()
+                    .Line($"IEnumerator<{itemTypeString}> IEnumerable<{itemTypeString}>.GetEnumerator() => GetEnumerator();")
+                    .Line()
+                    .Line($"IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();")
+                    .Line();
+
+                // define a value type enumerator wrapper
+                using (builder.Block($"public struct Enumerator : IEnumerator<{itemTypeString}>"))
+                {
+                    _ = builder
+                        .Line($"readonly {getEnumeratorReturnTypeString} source;")
+                        .Line()
+                        .Line($"internal Enumerator({getEnumeratorReturnTypeString} source)")
+                        .Indent().Line("=> this.source = source;")
+                        .Line()
+                        .Line($"public {itemTypeString} Current")
+                        .Line("{")
+                        .Indent().AggressiveInliningAttribute()
+                        .Indent().Line($"get => source.Current;")
+                        .Line("}")
+                        .Line()
+                        .Line("object? IEnumerator.Current => source.Current;")
+                        .Line()
+                        .AggressiveInliningAttribute()
+                        .Line("public bool MoveNext() => source.MoveNext();")
+                        .Line();
+
+                    _ = enumerableSymbols.EnumeratorSymbols.Reset is null
+                        ? builder
+                            .Line("public void Reset() => throw new NotSupportedException();")
+                        : builder
+                            .AggressiveInliningAttribute()
+                            .Line("public void Reset() => source.Reset();");
+
+                    _ = enumerableSymbols.EnumeratorSymbols.Dispose is null
+                        ? builder
+                            .Line()
+                            .AggressiveInliningAttribute()
+                            .Line("public void Dispose() { }")
+                        : builder
+                            .Line()
+                            .AggressiveInliningAttribute()
+                            .Line("public void Dispose() => source.Dispose();");
+                }
+            }
+        }
+
+        static void ImplementICollection(CodeBuilder builder, string itemTypeString, bool sourceIsReferenceType, bool itemIsReferenceType, bool sourceIsICollection)
+        {
+            _ = builder
+                .Line()
+                .Line($"// Implement ICollection<{itemTypeString}>")
+                .Line()
+                .Line("public int Count => source.Count;")
+                .Line()
+                .Line("public bool IsReadOnly => true;")
+                .Line()
+                .Line($"void ICollection<{itemTypeString}>.Add({itemTypeString} item) => throw new NotSupportedException();")
+                .Line()
+                .Line($"bool ICollection<{itemTypeString}>.Remove({itemTypeString} item) => throw new NotSupportedException();")
+                .Line()
+                .Line($"void ICollection<{itemTypeString}>.Clear() => throw new NotSupportedException();");
+
+            if (sourceIsICollection)
+            {
+                // Call the methods implemented by the source
+                _ = builder
+                    .Line()
+                    .AggressiveInliningAttribute()
+                    .Line($"public bool Contains({itemTypeString} item) => source.Contains(item);")
+                    .Line()
+                    .AggressiveInliningAttribute()
+                    .Line($"public void CopyTo({itemTypeString}[] array, int arrayIndex) => source.CopyTo(array, arrayIndex);");
+
+                return; // nothing else to do
+            }
+
+            // The source does not implement these methods so we have to add an implementation
+            _ = builder
+                .Line()
+                .MethodBlock($"public bool Contains({itemTypeString} item)",
+                    codeBuilder =>
+                        {
+                            _ = codeBuilder
+                                .Line("if (Count is 0)")
+                                .Indent().Line("return false;");
+
+                            if (sourceIsReferenceType)
+                            {
+                                _ = codeBuilder
+                                    .Line()
+                                    .Line($"if (source is ICollection<{itemTypeString}> collection)")
+                                    .Indent().Line("return collection.Contains(item);");
+                            }
+
+                            if (itemIsReferenceType) 
+                            {
+                                _ = codeBuilder
+                                    .Line()
+                                    .Line($"var comparer = EqualityComparer<{itemTypeString}>.Default;")
+                                    .Line("using var enumerator = GetEnumerator();")
+                                    .WhileBlock("enumerator.MoveNext()",
+                                        codeBuilder => _ = codeBuilder
+                                            .Line("if (comparer.Equals(enumerator.Current, item))")
+                                            .Indent().Line("return true;")
+                                    );
+                            }
+                            else // devirtualize the comparer
+                            {
+                                _ = codeBuilder
+                                    .Line()
+                                    .Line("using var enumerator = GetEnumerator();")
+                                    .WhileBlock("enumerator.MoveNext()",
+                                        codeBuilder => _ = codeBuilder
+                                            .Line($"if (EqualityComparer<{itemTypeString}>.Default.Equals(enumerator.Current, item))")
+                                            .Indent().Line("return true;")
+                                    );
+                            }
+
+                            _ = codeBuilder
+                                .Line("return false;");
+                        });
+
+            _ = builder
+                .Line()
+                .MethodBlock($"public void CopyTo({itemTypeString}[] array, int arrayIndex)",
+                    codeBuilder =>
+                    {
+                        _ = codeBuilder
+                            .Line("if (Count is 0)")
+                            .Indent().Line("return;")
+                            .Line()
+                            .Line("if (array.Length - arrayIndex < Count)")
+                            .Indent().Line($"throw new ArgumentException(\"{Resource.DestinationNotLongEnough}\", nameof(array));");
+
+                        if (sourceIsReferenceType)
+                        {
+                            codeBuilder
+                                .Line()
+                                .IfBlock($"source is ICollection<{itemTypeString}> collection",
+                                    codeBuilder => _ = codeBuilder
+                                        .Line("collection.CopyTo(array, arrayIndex);")
+                                        .Line("return;"));
+                        }
+                            
+                        _ = codeBuilder
+                            .Line()
+                            .Line("using var enumerator = GetEnumerator();")
+                            .IfBlock(
+                                "arrayIndex is 0 && array.Length == Count", // to enable range check elimination
+                                codeBuilder => _ = codeBuilder
+                                    .Line(
+                                        "for (var index = 0; index < array.Length && enumerator.MoveNext(); index++)")
+                                    .Indent().Line("array[index] = enumerator.Current;"),
+                                codeBuilder => _ = codeBuilder
+                                    .CheckedBlock(
+                                        codeBuilder => _ = codeBuilder
+                                            .Line(
+                                                "for (var index = arrayIndex; enumerator.MoveNext(); index++)")
+                                            .Indent().Line("array[index] = enumerator.Current;")
+                                    )
+                            );
+                    });
+        }
+
+        static void ImplementIList(CodeBuilder builder, string itemTypeString, bool sourceIsReferenceType, bool itemIsReferenceType, bool sourceIsIList)
+        {
+            _ = builder
+                .Line()
+                .Line($"// Implement IList<{itemTypeString}>")
+                .Line()
+                .Line($"public {itemTypeString} this[int index] => source[index];")
+                .Line();
+
+            using (builder.Block($"{itemTypeString} IList<{itemTypeString}>.this[int index]"))
+            {
+                _ = builder
+                    .Line("get => source[index];")
+                    .Line("set => throw new NotSupportedException();");
+            }
+
+            _ = builder
+                .Line()
+                .Line($"void IList<{itemTypeString}>.Insert(int index, {itemTypeString} item) => throw new NotSupportedException();")
+                .Line()
+                .Line($"void IList<{itemTypeString}>.RemoveAt(int index) => throw new NotSupportedException();")
+                .Line();
+
+            if (sourceIsIList)
+            {
+                // Call the methods implemented by the source
+                _ = builder
+                    .AggressiveInliningAttribute()
+                    .Line($"public int IndexOf({itemTypeString} item) => source.IndexOf(item);");
+
+                return;
+            }
+
+            // The source does not implement these methods so we have to add an implementation
+            builder
+                .MethodBlock($"public int IndexOf({itemTypeString} item)",
+                    codeBuilder => codeBuilder
+                        .IfBlock("Count is not 0",
+                            codeBuilder =>
+                            {
+                                if (sourceIsReferenceType)
+                                {
+                                    codeBuilder
+                                        .Line($"if (source is IList<{itemTypeString}> list)")
+                                        .Indent().Line("return list.IndexOf(item);")
+                                        .Line();
+                                }
+
+                                codeBuilder
+                                    .CheckedBlock(
+                                        codeBuilder =>
+                                        {
+                                            if (itemIsReferenceType) 
+                                            {
+                                                codeBuilder
+                                                    .Line($"var comparer = EqualityComparer<{itemTypeString}>.Default;")
+                                                    .Line("var index = 0;")
+                                                    .ForEachBlock("var current in source",
+                                                        codeBuilder => codeBuilder
+                                                            .Line($"if (comparer.Equals(current, item))")
+                                                            .Indent().Line("return index;")
+                                                            .Line()
+                                                            .Line("index++;")
+                                                    );
+                                            }
+                                            else // devirtualize the comparer
+                                            {
+                                                codeBuilder
+                                                    .Line("var index = 0;")
+                                                    .ForEachBlock("var current in source",
+                                                        codeBuilder => codeBuilder
+                                                            .Line(
+                                                                $"if (EqualityComparer<{itemTypeString}>.Default.Equals(current, item))")
+                                                            .Indent().Line("return index;")
+                                                            .Line()
+                                                            .Line("index++;")
+                                                    );
+                                            }
+                                        });
+                            })
+                        .Line("return -1;")
+                );
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Generator.cs b/NetFabric.Hyperlinq/Generator.cs
new file mode 100644
index 000000000..8bebaa42d
--- /dev/null
+++ b/NetFabric.Hyperlinq/Generator.cs
@@ -0,0 +1,349 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using NetFabric.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Text;
+using System.Threading;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    [Generator]
+    public partial class Generator
+        : ISourceGenerator
+    {
+        static readonly string assemblyName = typeof(CodeBuilder).Assembly.GetName().Name;
+        static readonly string assemblyVersion = typeof(CodeBuilder).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion ?? string.Empty;
+
+        static readonly DiagnosticDescriptor unhandledExceptionError = new(
+            id: "HPLG001",
+            title: "Unhandled exception while generating overloads",
+            messageFormat: "Unhandled exception while generating overloads: {0}",
+            category: "OverloadsGenerator",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
+
+        internal static readonly ImmutableHashSet<string> methods = ImmutableHashSet.Create(new[]
+        {
+            // aggregation
+            "Count",
+            "CountAsync",
+            "Sum",
+            "SumVector",
+            "SumAsync",
+
+            // conversion
+            "AsEnumerable",
+            "AsAsyncEnumerable",
+            "AsValueEnumerable",
+            "AsAsyncValueEnumerable",
+            "ToArray",
+            "ToArrayVector",
+            "ToArrayAsync",
+            "ToDictionary",
+            "ToDictionaryAsync",
+            "ToList",
+            "ToListVector",
+            "ToListAsync",
+
+            // element
+            "ElementAt",
+            "ElementAtAsync",
+            "First",
+            "FirstAsync",
+            "Single",
+            "SingleAsync",
+
+            // filtering
+            "Where",
+            "WhereAsync",
+
+            // partitioning
+            "Skip",
+            "SkipAsync",
+            "Take",
+            "TakeAsync",
+
+            // projection
+            "Select",
+            "SelectVector",
+            "SelectAsync",
+            "SelectMany",
+            "SelectManyAsync",
+
+            // quantifier
+            "All",
+            "AllAsync",
+            "Any",
+            "AnyAsync",
+            "Contains",
+            "ContainsVector",
+            "ContainsAsync",
+
+            // quantifier
+            "Distinct",
+            "DistinctAsync",
+        });
+
+        static readonly ImmutableHashSet<string> sumTypes = ImmutableHashSet.Create(new[]
+        {
+            "int",
+            "int?",
+            "nint",
+            "nint?",
+            "nuint",
+            "nuint?",
+            "long",
+            "long?",
+            "float",
+            "float?",
+            "double",
+            "double?",
+            "decimal",
+            "decimal?",
+        });
+
+        public void Initialize(GeneratorInitializationContext context)
+        {
+#if DEBUG
+            if (!Debugger.IsAttached)
+                _ = Debugger.Launch();
+#endif
+
+            context.RegisterForSyntaxNotifications(() => new SyntaxReceiver(methods));
+        }
+
+        public void Execute(GeneratorExecutionContext context)
+        {
+            var typeSymbolsCache = new TypeSymbolsCache(context.Compilation);
+
+            // Check if NetFabric.Hyperlinq.Abstractions and NetFabric.Hyperlinq.Abstractions are referenced
+            if (typeSymbolsCache[typeof(IValueEnumerable<,>)] is null 
+                || typeSymbolsCache[typeof(ValueEnumerableExtensions)] is null)
+                return; // TODO: return a Diagnostic?
+
+            if (context.SyntaxReceiver is not SyntaxReceiver receiver)
+                return;
+
+            try
+            {
+                var builder = new CodeBuilder();
+                GenerateSource(context.Compilation, typeSymbolsCache, receiver.MemberAccessExpressions, builder, context.CancellationToken);
+                context.AddSource("ExtensionMethods.g.cs", SourceText.From(builder.ToString(), Encoding.UTF8));
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(unhandledExceptionError, Location.None, ex.Message));
+            }
+        }
+
+        internal static void GenerateSource(Compilation compilation, TypeSymbolsCache typeSymbolsCache, List<MemberAccessExpressionSyntax> memberAccessExpressions, CodeBuilder builder, CancellationToken cancellationToken)
+        {
+            var generatedMethods = new Dictionary<MethodSignature, ValueEnumerableType>();
+
+            _ = builder
+                .Line("#nullable enable")
+                .Line()
+                .Line("using System;")
+                .Line("using System.CodeDom.Compiler;")
+                .Line("using System.Collections;")
+                .Line("using System.Collections.Generic;")
+                .Line("using System.ComponentModel;")
+                .Line("using System.Diagnostics;")
+                .Line("using System.Diagnostics.CodeAnalysis;")
+                .Line("using System.Runtime.CompilerServices;")
+                .Line()
+                .Line("namespace NetFabric.Hyperlinq;")
+                .Line();
+
+            using (builder.Block("static partial class GeneratedExtensionMethods"))
+            {
+                foreach (var expressionSyntax in memberAccessExpressions)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    var semanticModel = compilation.GetSemanticModel(expressionSyntax.SyntaxTree);
+
+                    _ = GenerateSource(compilation, semanticModel, typeSymbolsCache, expressionSyntax, builder, generatedMethods, cancellationToken);
+                }
+            }
+        }
+
+        static ValueEnumerableType? AsValueEnumerable(MemberAccessExpressionSyntax memberAccessExpressionSyntax, Compilation compilation, SemanticModel semanticModel, TypeSymbolsCache typeSymbolsCache, MemberAccessExpressionSyntax expressionSyntax, CodeBuilder builder, Dictionary<MethodSignature, ValueEnumerableType> generatedMethods, CancellationToken cancellationToken)
+        {
+            var typeSymbol = semanticModel.GetTypeInfo(memberAccessExpressionSyntax.Expression, cancellationToken).Type;
+            if (typeSymbol is null)
+                return null;
+
+            // Check if the receiver type implements IValueEnumerable<,>
+            var valueEnumerableType = typeSymbol.ToValueEnumerableType(typeSymbolsCache);
+            if (valueEnumerableType is not null)
+                return valueEnumerableType;
+
+            // Go up one layer. Generate method if required.
+            if (expressionSyntax.Expression is InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax receiverSyntax })
+            {
+                valueEnumerableType = GenerateSource(compilation, semanticModel, typeSymbolsCache, receiverSyntax, builder, generatedMethods, cancellationToken);
+                if (valueEnumerableType is not null)
+                    return valueEnumerableType;
+            }
+
+            // Receiver type does not implement IValueEnumerable<,> so nothing else needs to be done
+            return null;
+        }
+
+        static ValueEnumerableType? GenerateSource(Compilation compilation, SemanticModel semanticModel, TypeSymbolsCache typeSymbolsCache, MemberAccessExpressionSyntax expressionSyntax, CodeBuilder builder, Dictionary<MethodSignature, ValueEnumerableType> generatedMethods, CancellationToken cancellationToken) 
+            => expressionSyntax.Name.ToString() switch
+                {
+                    "AsValueEnumerable" => GenerateSourceAsValueEnumerable(compilation, semanticModel, typeSymbolsCache, expressionSyntax, builder, generatedMethods, cancellationToken),
+                    _ => GenerateSourceDefault(compilation, semanticModel, typeSymbolsCache, expressionSyntax, builder, generatedMethods, cancellationToken),
+                };
+
+        static ValueEnumerableType? GenerateSourceDefault(Compilation compilation, SemanticModel semanticModel, TypeSymbolsCache typeSymbolsCache, MemberAccessExpressionSyntax expressionSyntax, CodeBuilder builder, Dictionary<MethodSignature, ValueEnumerableType> generatedMethods, CancellationToken cancellationToken)
+        {
+            // Find the receiver type
+            var receiverType = AsValueEnumerable(expressionSyntax, compilation, semanticModel, typeSymbolsCache, expressionSyntax, builder, generatedMethods, cancellationToken);
+            if (receiverType is null)
+                return null;
+
+            var methodName = expressionSyntax.Name.ToString();
+            if (methodName == "Sum" && !sumTypes.Contains(receiverType.ItemType))
+                return null;
+
+            var containingClass = receiverType.IsList
+                ? typeSymbolsCache[typeof(ValueReadOnlyListExtensions)]!
+                : receiverType.IsCollection
+                    ? typeSymbolsCache[typeof(ValueReadOnlyCollectionExtensions)]!
+                    : typeSymbolsCache[typeof(ValueEnumerableExtensions)]!;
+            var containingClassString = containingClass.ToDisplayString();
+
+            // Check if the method is already defined
+            var symbol = semanticModel.GetSymbolInfo(expressionSyntax, cancellationToken).Symbol;
+            if (symbol is IMethodSymbol methodSymbol)
+            { 
+                // If it's an instance method of a type that implements IValueEnumerable<,> then it's already optimized.
+                if (methodSymbol.ReceiverType is not null && methodSymbol.ReceiverType.ImplementsInterface(typeSymbolsCache[typeof(IValueEnumerable<,>)]!, out _))
+                    return methodSymbol.ReturnType.ToValueEnumerableType(typeSymbolsCache); // return the returned type
+
+                // Check if the generator already generated the extension method
+                var parameters = methodSymbol.Parameters.Select(parameter => parameter.Type.ToDisplayString())
+                    .ToArray();
+                var methodSignature =
+                    new MethodSignature(expressionSyntax.Name.ToString(), receiverType.Name, parameters);
+                if (generatedMethods.TryGetValue(methodSignature, out var returnType))
+                    return returnType;
+
+                // Generate the extension method
+                var comparer = new TypeSymbolConversionComparer(compilation);
+                var parametersTypes = methodSymbol.Parameters.Select(parameter => parameter.Type).ToArray();
+                var hyperlinqMethods = containingClass
+                    .GetMembers()
+                    .OfType<IMethodSymbol>()
+                    .Where(method => 
+                        method.IsPublic() 
+                        && method.Name == methodName
+                        && method.Parameters.Skip(1).Select(parameter => parameter.Type).SequenceEqual(parametersTypes, comparer))
+                    .ToArray();
+                var hyperlinqMethod = hyperlinqMethods.FirstOrDefault();
+                if (hyperlinqMethod is null)
+                    return null;
+
+                var parametersString = string.Join(", ",
+                    new[] { $"{receiverType.Name} source" }
+                        .Concat(methodSymbol.Parameters.Select(static parameter => $"{parameter.Type.ToDisplayString()} {parameter.Name}")));
+                var argumentsString = string.Join(", ",
+                    new[] { "source" }
+                        .Concat(methodSymbol.Parameters.Select(parameter => MapArgument(parameter, typeSymbolsCache))));
+                var typeArgumentsString = string.Join(", ",
+                    new[] { receiverType.Name, receiverType.EnumeratorType }
+                        .Concat(methodSymbol.TypeArguments.Select(argument => MapTypeArgument(argument, typeSymbolsCache))));
+                var returnTypeString = hyperlinqMethod.ReturnType is INamedTypeSymbol { IsGenericType: true }
+                    ? $"{hyperlinqMethod.ReturnType.ContainingType}.{hyperlinqMethod.ReturnType.Name}<{typeArgumentsString}>"
+                    : hyperlinqMethod.ReturnType.ToDisplayString();
+                _ = builder
+                    .Line()
+                    .GeneratedCodeMethodAttributes()
+                    .Line("[MethodImpl(MethodImplOptions.AggressiveInlining)]")
+                    .Line($"public static {returnTypeString} {methodSymbol.Name}(this {parametersString})")
+                    .Indent()
+                    .Line($"=> {containingClassString}.{methodSymbol.Name}<{typeArgumentsString}>({argumentsString});");
+            }
+
+            // The method is not yet defined
+            if (expressionSyntax.Parent is InvocationExpressionSyntax invocation)
+            {
+                var a = invocation.ArgumentList.Arguments
+                    .Select(argument => semanticModel.GetTypeInfo(argument.Expression).Type)
+                    .ToArray();
+                // Check if the generator already generated the extension method
+                //var parameters = new string[] { receiverType.Name }.Concat(invocation.ArgumentList.Arguments.Select(argument => argument.ToDisplayString())).ToArray();
+                //var methodSignature = new MethodSignature(expressionSyntax.Name.ToString(), parameters);
+                //if (generatedMethods.TryGetValue(methodSignature, out var returnType))
+                //    return returnType;
+
+                //// Generate the extension method
+                //var hyperlinqMethod = hyperlinqMethods.FirstOrDefault();
+
+                //var parametersString = string.Join(", ",
+                //    new string[] { $"{receiverType.Name} source" }
+                //    .Concat(methodSymbol.Parameters.Select(parameter => $"{parameter.Type.ToDisplayString()} {parameter.Name}")));
+                //var argumentsString = string.Join(", ",
+                //    new string[] { "source" }
+                //    .Concat(methodSymbol.Parameters.Select(parameter => parameter.Name)));
+                //_ = builder
+                //    .Line()
+                //    .Line("[MethodImpl(MethodImplOptions.AggressiveInlining)]")
+                //    .Line($"public static {hyperlinqMethod.ReturnType.ToDisplayString()} {methodSymbol.Name}(this {parametersString})")
+                //    .Indent().Line($"=> {containingClassString}.{methodSymbol.Name}<{receiverType.Name}, {receiverType.EnumeratorType}, {receiverType.ItemType}>({argumentsString});");
+
+                //generatedMethods.Add(methodSignature, returnType);
+                //return returnType;
+            }
+
+            return null;
+
+            static string MapArgument(IParameterSymbol parameter, TypeSymbolsCache typeSymbolsCache)
+            {
+                if (parameter.Type is INamedTypeSymbol { IsGenericType: true } namedTypeSymbol)
+                {
+                    // Convert Func<> to FunctionWrapper<>
+                    if (SymbolEqualityComparer.Default.Equals(parameter.Type.OriginalDefinition, typeSymbolsCache[typeof(Func<,>)]))
+                    {
+                        var typeArguments = string.Join(", ",
+                            namedTypeSymbol.TypeArguments.Select(argument => argument.ToDisplayString()));
+                        return $"new NetFabric.Hyperlinq.FunctionWrapper<{typeArguments}>({parameter.Name})";
+                    }
+                }
+                
+                return parameter.Name;
+            }
+            
+            static string MapTypeArgument(ITypeSymbol argument, TypeSymbolsCache typeSymbolsCache)
+            {
+                if (argument is INamedTypeSymbol { IsGenericType: true } namedTypeSymbol)
+                {
+                    // Convert Func<> to FunctionWrapper<>
+                    if (SymbolEqualityComparer.Default.Equals(argument.OriginalDefinition, typeSymbolsCache[typeof(Func<,>)]))
+                    {
+                        var typeArguments = string.Join(", ",
+                            namedTypeSymbol.TypeArguments.Select(argument => argument.ToDisplayString()));
+                        return $"NetFabric.Hyperlinq.FunctionWrapper<{typeArguments}>";
+                    }
+                }
+                
+                return argument.ToDisplayString();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/ITypeSymbolExtensions.cs b/NetFabric.Hyperlinq/ITypeSymbolExtensions.cs
new file mode 100644
index 000000000..596bdd104
--- /dev/null
+++ b/NetFabric.Hyperlinq/ITypeSymbolExtensions.cs
@@ -0,0 +1,53 @@
+using Microsoft.CodeAnalysis;
+using NetFabric.CodeAnalysis;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+
+// ReSharper disable LoopCanBeConvertedToQuery
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    static class ITypeSymbolExtensions
+    {
+        public static bool ImplementsAnyInterface(this ITypeSymbol typeSymbol, INamedTypeSymbol[] interfaceTypes, out ImmutableArray<ITypeSymbol> genericArguments)
+        {
+            if (typeSymbol is INamedTypeSymbol namedTypeSymbol)
+            {
+                foreach (var interfaceType in interfaceTypes)
+                {
+                    if (SymbolEqualityComparer.Default.Equals(namedTypeSymbol.OriginalDefinition, interfaceType))
+                    {
+                        genericArguments = namedTypeSymbol.TypeArguments;
+                        return true;
+                    }
+                }
+            }
+
+            // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
+            foreach (var @interface in typeSymbol.AllInterfaces)
+            {
+                foreach (var interfaceType in interfaceTypes)
+                {
+                    if (SymbolEqualityComparer.Default.Equals(@interface.OriginalDefinition, interfaceType))
+                    {
+                        genericArguments = @interface.TypeArguments;
+                        return true;
+                    }
+                }
+            }
+
+            Unsafe.SkipInit(out genericArguments);
+            return false;
+        }
+
+        public static ValueEnumerableType? ToValueEnumerableType(this ITypeSymbol typeSymbol, TypeSymbolsCache typeSymbolsCache) 
+            => !typeSymbol.ImplementsInterface(typeSymbolsCache[typeof(IValueEnumerable<,>)]!, out var genericArguments)
+                ? null
+                : new ValueEnumerableType(
+                    Name: typeSymbol.ToDisplayString(),
+                    EnumeratorType: genericArguments[1].ToDisplayString(),
+                    ItemType: genericArguments[0].ToDisplayString(),
+                    IsCollection: typeSymbol.ImplementsInterface(typeSymbolsCache[typeof(IValueReadOnlyCollection<,>)]!, out _),
+                    IsList: typeSymbol.ImplementsInterface(typeSymbolsCache[typeof(IValueReadOnlyList<,>)]!, out _));
+    }
+}
diff --git a/NetFabric.Hyperlinq/MethodSignature.cs b/NetFabric.Hyperlinq/MethodSignature.cs
new file mode 100644
index 000000000..cdd27a357
--- /dev/null
+++ b/NetFabric.Hyperlinq/MethodSignature.cs
@@ -0,0 +1,41 @@
+using Microsoft.CodeAnalysis;
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    readonly struct MethodSignature
+        : IEquatable<MethodSignature>
+    {
+        public MethodSignature(string name, string receiverType, params string[] parameters)
+            => (Name, ReceiverType, Parameters) = (name, receiverType, ImmutableArray.Create(parameters));
+
+        string Name { get; }
+        string ReceiverType { get; }
+        ImmutableArray<string> Parameters { get; }
+
+        public bool Equals(MethodSignature other)
+            => Name == other.Name && ReceiverType == other.ReceiverType && Parameters.SequenceEqual(other.Parameters);
+
+        public override bool Equals(object other) 
+            => other is MethodSignature signature && Equals(signature);
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                const int hashingBase = (int)2166136261;
+                const int hashingMultiplier = 16777619;
+
+                var hash = hashingBase;
+                hash = (hash * hashingMultiplier) ^ Name.GetHashCode();
+                hash = (hash * hashingMultiplier) ^ ReceiverType.GetHashCode();
+                // ReSharper disable once ForeachCanBeConvertedToQueryUsingAnotherGetEnumerator
+                foreach(var parameter in Parameters)
+                    hash = (hash * hashingMultiplier) ^ parameter.GetHashCode();
+                return hash;
+            }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq/NetFabric.Hyperlinq.csproj b/NetFabric.Hyperlinq/NetFabric.Hyperlinq.csproj
index 1b7b2c4eb..ff22ce1c4 100644
--- a/NetFabric.Hyperlinq/NetFabric.Hyperlinq.csproj
+++ b/NetFabric.Hyperlinq/NetFabric.Hyperlinq.csproj
@@ -1,60 +1,55 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
-    <PackageId>NetFabric.Hyperlinq</PackageId>
-    <Title>NetFabric.Hyperlinq</Title>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <PackageId>NetFabric.Hyperlinq.SourceGenerator</PackageId>
+    <Title>NetFabric.Hyperlinq.SourceGenerator</Title>
     <Description> High performance LINQ implementation with minimal heap allocations. Supports enumerables, async enumerables, Memory, and Span.</Description>
     <Version>3.0.0-beta48</Version>
     <PackageIcon>Icon.png</PackageIcon>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageTags>netfabric, hyperlinq, linq, enumeration, extensions, performance</PackageTags>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
-    <IncludeSymbols>true</IncludeSymbols>
-    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <!-- <TreatWarningsAsErrors>true</TreatWarningsAsErrors> -->
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(TargetFramework)'=='net461' Or '$(TargetFramework)'=='netstandard2.0' Or '$(TargetFramework)'=='netcoreapp2.1'">
-    <!-- disable nullable warning -->
-    <NoWarn>$(NoWarn);8600;8601;8602;8603;8604</NoWarn>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild> <!-- Generates a package at build -->
+    <IncludeBuildOutput>false</IncludeBuildOutput> <!-- Do not include the generator as a lib dependency -->
   </PropertyGroup>
 
   <ItemGroup>
-    <SupportedPlatform Include="browser" />
+    <None Include="..\Icon.png" Link="Icon.png">
+      <PackagePath></PackagePath>
+      <Pack>true</Pack>
+    </None>
+    <None Include="..\LICENSE" Link="LICENSE">
+      <PackagePath></PackagePath>
+      <Pack>true</Pack>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="..\NetFabric.Hyperlinq.SourceGenerator\Attributes\GeneratorBindingsAttribute.cs" Link="Utils\Generator\GeneratorBindingsAttribute.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq.SourceGenerator\Attributes\GeneratorIgnoreAttribute.cs" Link="Utils\Generator\GeneratorIgnoreAttribute.cs" />
-    <Compile Include="..\NetFabric.Hyperlinq.SourceGenerator\Attributes\GeneratorMappingAttribute.cs" Link="Utils\Generator\GeneratorMappingAttribute.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)' == 'net461' Or '$(TargetFramework)' == 'netstandard2.0'">
-    <Compile Remove="Conversion\AsValueEnumerable\Bindings\System\Collections\Immutable\*.cs" />
+    <!-- Take a public dependency on NetFabric.Hyperlinq.Core. Consumers of this generator will get a reference to this package -->
+    <ProjectReference Include="..\NetFabric.Hyperlinq.Core\NetFabric.Hyperlinq.Core.csproj" />
   </ItemGroup>
-
+  
   <ItemGroup>
-    <None Include="..\Icon.png" Pack="true" PackagePath="" />
-    <None Include="..\LICENSE" Pack="true" PackagePath="" />
-  </ItemGroup>
+    <!-- Take a private dependency on Ben.TypeDictionary (PrivateAssets=all) Consumers of this generator will not reference it.
+         Set GeneratePathProperty=true so we can reference the binaries via the PKGBen_TypeDictionary property -->
+    <PackageReference Include="Ben.TypeDictionary" Version="0.1.4" PrivateAssets="all" GeneratePathProperty="true" />
+    
+    <!-- Take a private dependency on NetFabric.CodeAnalysis (PrivateAssets=all) Consumers of this generator will not reference it.
+         Set GeneratePathProperty=true so we can reference the binaries via the PKGNetFabric_CodeAnalysis property -->
+    <PackageReference Include="NetFabric.CodeAnalysis" Version="4.0.2" PrivateAssets="all" GeneratePathProperty="true" />
 
-  <ItemGroup>
-    <ProjectReference Include="..\NetFabric.Hyperlinq.Abstractions\NetFabric.Hyperlinq.Abstractions.csproj" />
-    <ProjectReference Include="..\NetFabric.Hyperlinq.SourceGenerator\NetFabric.Hyperlinq.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />  
+    <!-- Package the generator in the analyzer directory of the nuget package -->
+    <None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    
+    <!-- Package the Ben.TypeDictionary dependency alongside the generator assembly -->
+    <None Include="$(PKGBen_TypeDictionary)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="$(PKGNetFabric_CodeAnalysis)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
   </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net461' Or '$(TargetFramework)'=='netstandard2.0'">
-    <PackageReference Include="System.Memory" Version="4.5.4" />
-    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
-  </ItemGroup>
-
+  
   <ItemGroup>
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="5.0.0" />
-    <PackageReference Include="System.Buffers" Version="4.5.1" />
-    <PackageReference Include="Nullable" Version="1.3.0">
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.11.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
@@ -62,33 +57,29 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Meziantou.Analyzer" Version="1.0.667">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="UnoptimizedAssemblyDetector" Version="0.1.1">
+    <PackageReference Include="IsExternalInit" Version="1.0.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>    
+    <PackageReference Include="Nullable" Version="1.3.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
   </ItemGroup>
-
-  <ItemGroup>
-    <Compile Update="Resource.Designer.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Resource.resx</DependentUpon>
-    </Compile>
-  </ItemGroup>
-
+  
   <ItemGroup>
     <EmbeddedResource Update="Resource.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Resource.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
-
+  
   <ItemGroup>
-    <Folder Include="Utils\Contains\" />
+    <Compile Update="Resource.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
   </ItemGroup>
 
 </Project>
diff --git a/NetFabric.Hyperlinq/Properties/AssemblyInfo.cs b/NetFabric.Hyperlinq/Properties/AssemblyInfo.cs
index 718964469..a48e711f2 100644
--- a/NetFabric.Hyperlinq/Properties/AssemblyInfo.cs
+++ b/NetFabric.Hyperlinq/Properties/AssemblyInfo.cs
@@ -1,3 +1,3 @@
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
 
-[assembly:InternalsVisibleTo("NetFabric.Hyperlinq.UnitTests")]
\ No newline at end of file
+[assembly: InternalsVisibleTo("NetFabric.Hyperlinq.UnitTests")]
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/Quantifier/Any/Any.ValueReadOnlyCollection.cs b/NetFabric.Hyperlinq/Quantifier/Any/Any.ValueReadOnlyCollection.cs
deleted file mode 100644
index b1712c02e..000000000
--- a/NetFabric.Hyperlinq/Quantifier/Any/Any.ValueReadOnlyCollection.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace NetFabric.Hyperlinq
-{
-    public static partial class ValueReadOnlyCollectionExtensions
-    {
-        
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count is not 0;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => Any<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(source, new FunctionWrapper<TSource, bool>(predicate));
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, bool>
-            => source.Count is not 0 && ValueEnumerableExtensions.Any<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Any<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => AnyAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(source, new FunctionWrapper<TSource, int, bool>(predicate));
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
-            where TEnumerable : IValueReadOnlyCollection<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            where TPredicate : struct, IFunction<TSource, int, bool>
-            => source.Count is not 0 && ValueEnumerableExtensions.AnyAt<TEnumerable, TEnumerator, TSource, TPredicate>(source, predicate);
-    }
-}
-
diff --git a/NetFabric.Hyperlinq/Resource.Designer.cs b/NetFabric.Hyperlinq/Resource.Designer.cs
index ff4ee5dc4..f8a357e32 100644
--- a/NetFabric.Hyperlinq/Resource.Designer.cs
+++ b/NetFabric.Hyperlinq/Resource.Designer.cs
@@ -11,7 +11,7 @@ namespace NetFabric.Hyperlinq {
     using System;
     
     
-    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
     [System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class Resource {
@@ -45,28 +45,10 @@ internal static System.Globalization.CultureInfo Culture {
             }
         }
         
-        internal static string ArraySegmentNull {
-            get {
-                return ResourceManager.GetString("ArraySegmentNull", resourceCulture);
-            }
-        }
-        
         internal static string DestinationNotLongEnough {
             get {
                 return ResourceManager.GetString("DestinationNotLongEnough", resourceCulture);
             }
         }
-        
-        internal static string EmptySequence {
-            get {
-                return ResourceManager.GetString("EmptySequence", resourceCulture);
-            }
-        }
-        
-        internal static string NotSingleSequence {
-            get {
-                return ResourceManager.GetString("NotSingleSequence", resourceCulture);
-            }
-        }
     }
 }
diff --git a/NetFabric.Hyperlinq/Resource.resx b/NetFabric.Hyperlinq/Resource.resx
index 260aed1d5..d217097c0 100644
--- a/NetFabric.Hyperlinq/Resource.resx
+++ b/NetFabric.Hyperlinq/Resource.resx
@@ -1,132 +1,24 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
+
 <root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
+    <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+        <xsd:element name="root" msdata:IsDataSet="true">
+            
+        </xsd:element>
+    </xsd:schema>
+    <resheader name="resmimetype">
+        <value>text/microsoft-resx</value>
+    </resheader>
+    <resheader name="version">
+        <value>1.3</value>
+    </resheader>
+    <resheader name="reader">
+        <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <resheader name="writer">
+        <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <data name="DestinationNotLongEnough" xml:space="preserve">
+        <value>Destination array was not long enough. Check the destination index, length, and the array's lower bounds.</value>
     </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="ArraySegmentNull" xml:space="preserve">
-    <value>The array in the ArraySegment is null</value>
-  </data>
-  <data name="DestinationNotLongEnough" xml:space="preserve">
-    <value>Destination array was not long enough. Check the destination index, length, and the rentedArray's lower bounds.</value>
-  </data>
-  <data name="EmptySequence" xml:space="preserve">
-    <value>Sequence contains no elements</value>
-  </data>
-  <data name="NotSingleSequence" xml:space="preserve">
-    <value>Sequence contains more than one element</value>
-  </data>
 </root>
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq/SyntaxReceiver.cs b/NetFabric.Hyperlinq/SyntaxReceiver.cs
new file mode 100644
index 000000000..56fd3dd59
--- /dev/null
+++ b/NetFabric.Hyperlinq/SyntaxReceiver.cs
@@ -0,0 +1,33 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    class SyntaxReceiver : ISyntaxReceiver
+    {
+        readonly ImmutableHashSet<string> memberAccessNames;
+
+        public SyntaxReceiver(ImmutableHashSet<string> memberAccessNames) 
+            => this.memberAccessNames = memberAccessNames;
+
+        public List<MemberAccessExpressionSyntax> MemberAccessExpressions { get; } = new();
+
+        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+        {
+            switch (syntaxNode)
+            {
+                case MemberAccessExpressionSyntax { Name: var memberName } memberAccessExpression:
+                    if (memberAccessExpression.Kind() == SyntaxKind.SimpleMemberAccessExpression
+                        && memberAccessNames.Contains(memberName.Identifier.ValueText))
+                    {
+                        // It's a SimpleMemberAccessExpression and its name is in memberAccessNames collection
+                        MemberAccessExpressions.Add(memberAccessExpression);
+                    }
+                    break;
+            }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq/TypeSymbolsCache.cs b/NetFabric.Hyperlinq/TypeSymbolsCache.cs
new file mode 100644
index 000000000..f3694a1e6
--- /dev/null
+++ b/NetFabric.Hyperlinq/TypeSymbolsCache.cs
@@ -0,0 +1,28 @@
+using Ben.Collections;
+using Microsoft.CodeAnalysis;
+using System;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    class TypeSymbolsCache
+    {
+        readonly Compilation compilation;
+        readonly TypeDictionary<INamedTypeSymbol?> cacheByType = new();
+
+        public TypeSymbolsCache(Compilation compilation)
+            => this.compilation = compilation;
+
+        public INamedTypeSymbol? this[Type type]
+        {
+            get
+            {
+                if (cacheByType.TryGetValue(type, out var symbol))
+                    return symbol;
+
+                symbol = compilation.GetTypeByMetadataName(type.FullName);
+                cacheByType[type] = symbol;
+                return symbol;
+            }
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/AttributeExtensions.cs b/NetFabric.Hyperlinq/Utils/AttributeExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/AttributeExtensions.cs
rename to NetFabric.Hyperlinq/Utils/AttributeExtensions.cs
diff --git a/NetFabric.Hyperlinq/Utils/CodeBuilder.cs b/NetFabric.Hyperlinq/Utils/CodeBuilder.cs
new file mode 100644
index 000000000..1d81877fb
--- /dev/null
+++ b/NetFabric.Hyperlinq/Utils/CodeBuilder.cs
@@ -0,0 +1,152 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Text;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    class CodeBuilder
+    {
+        const string indentation = "    ";
+
+        readonly StringBuilder builder = new();
+        int currentLevel = 0;
+
+        public bool IsUnitTest { get; init; } = false;
+
+        StringBuilder AppendIndents()
+        {
+            for (var level = 0; level < currentLevel; level++)
+                _ = builder.Append(indentation);
+
+            return builder;
+        }
+
+        public CodeBuilder Indent()
+        {
+            _ = builder.Append(indentation);
+            return this;
+        }
+
+        public CodeBuilder Line()
+        {
+            _ = builder.AppendLine();
+            return this;
+        }
+
+        public CodeBuilder Line(char text)
+        {
+            _ = AppendIndents().Append(text).AppendLine();
+            return this;
+        }
+
+        public CodeBuilder Line(string text)
+        {
+            _ = AppendIndents().AppendLine(text);
+            return this;
+        }
+
+        public CodeBuilder Line(Action<StringBuilder> line)
+        {
+            _ = AppendIndents();
+            line(builder);
+            _ = Line();
+            return this;
+        }
+
+        public IDisposable Block()
+        {
+            _ = Line('{');
+            currentLevel++;
+            // ReSharper disable once HeapView.ObjectAllocation.Evident
+            return new CloseBlock(this);
+        }
+
+        public IDisposable Block(string text) 
+            => Line(text).Block();
+
+        public CodeBuilder MethodBlock(string header, Action<CodeBuilder> block)
+        {
+            using (Block(header))
+            {
+                block(this);
+            }
+            return this;
+        }
+
+        public CodeBuilder IfBlock(string condition, Action<CodeBuilder> block)
+        {
+            using (Block($"if ({condition})"))
+            {
+                block(this);
+            }
+            return this;
+        }
+
+        public CodeBuilder IfBlock(string condition, Action<CodeBuilder> trueBlock, Action<CodeBuilder> falseBlock)
+        {
+            using (Block($"if ({condition})"))
+            {
+                trueBlock(this);
+            }
+            using (Block("else"))
+            {
+                falseBlock(this);
+            }
+            return this;
+        }
+
+        public CodeBuilder ForEachBlock(string text, Action<CodeBuilder> block)
+        {
+            using (Block($"foreach ({text})"))
+            {
+                block(this);
+            }
+            return this;
+        }
+
+        public CodeBuilder ForBlock(string text, Action<CodeBuilder> block)
+        {
+            using (Block($"for ({text})"))
+            {
+                block(this);
+            }
+            return this;
+        }
+
+        public CodeBuilder WhileBlock(string text, Action<CodeBuilder> block)
+        {
+            using (Block($"while ({text})"))
+            {
+                block(this);
+            }
+            return this;
+        }
+
+        public CodeBuilder CheckedBlock(Action<CodeBuilder> block)
+        {
+            using (Block("checked"))
+            {
+                block(this);
+            }
+            return this;
+        }
+
+        class CloseBlock : IDisposable
+        {
+            readonly CodeBuilder builder;
+
+            public CloseBlock(CodeBuilder builder) 
+                => this.builder = builder;
+
+            public void Dispose()
+            {
+                builder.currentLevel--;
+                _ = builder.Line('}');
+            }
+        }
+
+        public override string ToString() 
+            => builder.ToString();
+    }
+}
diff --git a/NetFabric.Hyperlinq/Utils/CodeBuilderExtensions.cs b/NetFabric.Hyperlinq/Utils/CodeBuilderExtensions.cs
new file mode 100644
index 000000000..8c9725da7
--- /dev/null
+++ b/NetFabric.Hyperlinq/Utils/CodeBuilderExtensions.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Reflection;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    static class CodeBuilderExtensions
+    {
+        static readonly string assemblyName = typeof(CodeBuilder).Assembly
+            .GetName().Name;
+        static readonly string assemblyVersion = typeof(CodeBuilder).Assembly
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion 
+            ?? string.Empty;
+
+        public static CodeBuilder GeneratedCodeMethodAttributes(this CodeBuilder builder)
+            => builder.IsUnitTest 
+                ? builder // do nothing
+                : builder.Line($"[GeneratedCode(\"{assemblyName}\", \"{assemblyVersion}\")]")
+                    .Line("[DebuggerNonUserCode]")
+                    .Line("[ExcludeFromCodeCoverage]")
+                    .Line("[EditorBrowsable(EditorBrowsableState.Never)]");
+
+        public static CodeBuilder AggressiveInliningAttribute(this CodeBuilder builder)
+            => builder.Line("[MethodImpl(MethodImplOptions.AggressiveInlining)]");
+    }
+}
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/DictionarySet.cs b/NetFabric.Hyperlinq/Utils/DictionarySet.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/DictionarySet.cs
rename to NetFabric.Hyperlinq/Utils/DictionarySet.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/MethodSymbolExtensions.cs b/NetFabric.Hyperlinq/Utils/MethodSymbolExtensions.cs
similarity index 98%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/MethodSymbolExtensions.cs
rename to NetFabric.Hyperlinq/Utils/MethodSymbolExtensions.cs
index 8b92294ce..a04fe3d7e 100644
--- a/NetFabric.Hyperlinq.SourceGenerator/Utils/MethodSymbolExtensions.cs
+++ b/NetFabric.Hyperlinq/Utils/MethodSymbolExtensions.cs
@@ -54,7 +54,7 @@ public static MethodInfo GetInfo(this IMethodSymbol method, CompilationContext c
                 throw;
             }
 
-            string ToDisplayString(object? obj)
+            static string ToDisplayString(object? obj)
                 => obj switch
                 {
                     null => "<NULL>",
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/NamespaceSymbolExtensions.cs b/NetFabric.Hyperlinq/Utils/NamespaceSymbolExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/NamespaceSymbolExtensions.cs
rename to NetFabric.Hyperlinq/Utils/NamespaceSymbolExtensions.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/StringExtensions.cs b/NetFabric.Hyperlinq/Utils/StringExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/StringExtensions.cs
rename to NetFabric.Hyperlinq/Utils/StringExtensions.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/SymbolExtensions.cs b/NetFabric.Hyperlinq/Utils/SymbolExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/SymbolExtensions.cs
rename to NetFabric.Hyperlinq/Utils/SymbolExtensions.cs
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/TypeParameterSymbolExtensions.cs b/NetFabric.Hyperlinq/Utils/TypeParameterSymbolExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/TypeParameterSymbolExtensions.cs
rename to NetFabric.Hyperlinq/Utils/TypeParameterSymbolExtensions.cs
diff --git a/NetFabric.Hyperlinq/Utils/TypeSymbolConversionComparer.cs b/NetFabric.Hyperlinq/Utils/TypeSymbolConversionComparer.cs
new file mode 100644
index 000000000..f151d8a02
--- /dev/null
+++ b/NetFabric.Hyperlinq/Utils/TypeSymbolConversionComparer.cs
@@ -0,0 +1,24 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using System.Collections.Generic;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    public class TypeSymbolConversionComparer 
+        : IEqualityComparer<ITypeSymbol>
+    {
+        readonly Compilation compilation;
+
+        public TypeSymbolConversionComparer(Compilation compilation)
+            => this.compilation = compilation;
+
+        public bool Equals(ITypeSymbol x, ITypeSymbol y)
+            => (x is INamedTypeSymbol { IsGenericType: true }  
+                   && y is INamedTypeSymbol { IsGenericType: true }
+                   && compilation.ClassifyConversion(x.OriginalDefinition, y.OriginalDefinition).Exists)
+               || compilation.ClassifyConversion(x, y).Exists;
+
+        public int GetHashCode(ITypeSymbol obj) 
+            => SymbolEqualityComparer.Default.GetHashCode(obj);
+    }
+}
\ No newline at end of file
diff --git a/NetFabric.Hyperlinq.SourceGenerator/Utils/TypeSymbolExtensions.cs b/NetFabric.Hyperlinq/Utils/TypeSymbolExtensions.cs
similarity index 100%
rename from NetFabric.Hyperlinq.SourceGenerator/Utils/TypeSymbolExtensions.cs
rename to NetFabric.Hyperlinq/Utils/TypeSymbolExtensions.cs
diff --git a/NetFabric.Hyperlinq/ValueEnumerableType.cs b/NetFabric.Hyperlinq/ValueEnumerableType.cs
new file mode 100644
index 000000000..28b79c1f2
--- /dev/null
+++ b/NetFabric.Hyperlinq/ValueEnumerableType.cs
@@ -0,0 +1,6 @@
+using System;
+
+namespace NetFabric.Hyperlinq.SourceGenerator
+{
+    record ValueEnumerableType(string Name, string EnumeratorType, string ItemType, bool IsCollection, bool IsList);
+}
diff --git a/README.md b/README.md
index 0709d4fb2..ed0625676 100644
--- a/README.md
+++ b/README.md
@@ -426,6 +426,7 @@ The following open-source projects are used to build and test this project:
 
 - [.NET](https://github.com/dotnet)
 - [BenchmarkDotNet](https://benchmarkdotnet.org/)
+- [Ben.TypeDictionary](https://github.com/benaadams/Ben.TypeDictionary)
 - [coveralls](https://coveralls.io)
 - [coverlet](https://github.com/tonerdo/coverlet)
 - [ILRepack](https://github.com/gluck/il-repack)
@@ -434,6 +435,7 @@ The following open-source projects are used to build and test this project:
 - [NetFabric.Hyperlinq.Analyzer](https://github.com/NetFabric/NetFabric.Hyperlinq.Analyzer)
 - [Nullable](https://github.com/manuelroemer/Nullable)
 - [Source Link](https://github.com/dotnet/sourcelink)
+- [UnoptimizedAssemblyDetector](https://github.com/bruno-garcia/unoptimized-assembly-detector)
 - [xUnit.net](https://xunit.net/)
 
 ## License