Add Count(predicate) (#363)

Directory.Build.props

@@ -4,7 +4,7 @@
   <PropertyGroup>
     <Authors>Antao Almada</Authors>
     <Copyright>Copyright 2019-2021 Antao Almada</Copyright>
-    <LangVersion>9.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Features>strict</Features>
     <Nullable>enable</Nullable>
   </PropertyGroup>

NetFabric.Hyperlinq.Abstractions/NetFabric.Hyperlinq.Abstractions.csproj

@@ -1,15 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net461;net5.0;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>net5.0;netstandard2.0;netstandard2.1</TargetFrameworks>
     <PackageId>NetFabric.Hyperlinq.Abstractions</PackageId>
     <Title>NetFabric.Hyperlinq.Abstractions</Title>
     <Description>Abstractions for high performance enumeration.</Description>
-    <Version>1.2.0</Version>
+    <Version>1.3.0</Version>
     <PackageIcon>Icon.png</PackageIcon>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageTags>netfabric, hyperlinq, abstractions, linq, enumeration, performance</PackageTags>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <PackageReleaseNotes></PackageReleaseNotes>
   </PropertyGroup>
 

NetFabric.Hyperlinq.Benchmarks/NetFabric.Hyperlinq.Benchmarks.csproj

@@ -18,9 +18,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.0.1555" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.0.1561" />
     <PackageReference Include="LinqFaster.SIMD" Version="1.0.3" />
-    <PackageReference Include="StructLinq" Version="0.26.0" />
+    <PackageReference Include="StructLinq" Version="0.27.0" />
     <PackageReference Include="System.Interactive" Version="5.0.0" />
     <PackageReference Include="System.Interactive.Async" Version="5.0.0" />
     <PackageReference Include="System.Linq.Async" Version="5.0.0" />

NetFabric.Hyperlinq.Immutable/NetFabric.Hyperlinq.Immutable.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net461;netstandard2.0</TargetFrameworks>
+    <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>
@@ -36,7 +36,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Meziantou.Analyzer" Version="1.0.663">
+    <PackageReference Include="Meziantou.Analyzer" Version="1.0.667">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.9.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.10.0" />
     <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" />

NetFabric.Hyperlinq.SourceGenerator/NetFabric.Hyperlinq.SourceGenerator.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.9.0" PrivateAssets="all" />
+    <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>

NetFabric.Hyperlinq.SourceGenerator/OverloadsGenerator.cs

@@ -344,7 +344,10 @@ void GenerateMethodSource(CodeBuilder builder, CompilationContext context, IName
 
             if (isExtensionMethod)
             {
-                _ = builder.AppendLine($"public static {methodReturnType} {methodName}{methodGenericParametersString}(this {methodExtensionType} source{methodParameters})");
+                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"

NetFabric.Hyperlinq.UnitTests/Conversion/AsValueEnumerable/Bindings/System/Collections/Immutable/ImmutableArray.Tests.cs

@@ -24,7 +24,7 @@ public void AsValueEnumerable_With_ImmutableArray_Must_ReturnWrapper(int[] sourc
                 .BeOfType<ArrayExtensions.ArraySegmentValueEnumerable<int>>()
                 .BeEnumerableOf<int>()
                 .BeEqualTo(wrapped, testRefStructs: false);
-            result.SequenceEqual(wrapped).Must().BeTrue();
+            _ = result.SequenceEqual(wrapped).Must().BeTrue();
         }
     }
 }

NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net461;netcoreapp2.1;netcoreapp3.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netcoreapp2.1;netcoreapp3.1;net6.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
@@ -24,7 +24,7 @@
     </PackageReference>
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)'=='net461' Or '$(TargetFramework)'=='netcoreapp2.1'">
+  <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>

NetFabric.Hyperlinq/Aggregation/Count/Count.ReadOnlySpan.cs

@@ -9,8 +9,11 @@ public static partial class ArrayExtensions
         static int Count<TSource>(this ReadOnlySpan<TSource> source)
             => source.Length;
 
-        [GeneratorIgnore]
-        static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static int Count<TSource>(this 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)
             where TPredicate: struct, IFunction<TSource, bool>
         {
             var counter = 0;
@@ -21,8 +24,11 @@ static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredic
             return counter;
         }
 
-        [GeneratorIgnore]
-        static int CountAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        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)
             where TPredicate: struct, IFunction<TSource, int, bool>
         {
             var counter = 0;

NetFabric.Hyperlinq/Aggregation/Count/Count.ValueEnumerable.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 
 namespace NetFabric.Hyperlinq
 {
@@ -17,9 +19,14 @@ 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));
 
-        [GeneratorIgnore]
-        internal static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate 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>
             where TPredicate: struct, IFunction<TSource, bool>
@@ -33,9 +40,14 @@ internal static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TE
             }
             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));
 
-        [GeneratorIgnore]
-        internal static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
+        public static int CountAt<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, int, bool>

NetFabric.Hyperlinq/Aggregation/Count/Count.ValueReadOnlyCollection.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 
 namespace NetFabric.Hyperlinq
 {
@@ -9,8 +11,13 @@ public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable sour
             where TEnumerator : struct, IEnumerator<TSource>
             => source.Count;
 
-        [GeneratorIgnore]
-        static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
+        [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>
             where TPredicate: struct, IFunction<TSource, bool>
@@ -19,9 +26,14 @@ static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable
                 {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));
 
-        [GeneratorIgnore]
-        static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate)
+        public static int CountAt<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>

NetFabric.Hyperlinq/Aggregation/Count/CountAsync.AsyncValueEnumerable.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -27,8 +29,13 @@ public static async ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource>
             return counter;
         }
 
-        [GeneratorIgnore]
-        static async ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
+        [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>
             where TPredicate: struct, IAsyncFunction<TSource, bool>
@@ -53,8 +60,13 @@ static async ValueTask<int> CountAsync<TEnumerable, TEnumerator, TSource, TPredi
             return counter;
         }
 
-        [GeneratorIgnore]
-        static async ValueTask<int> CountAtAsync<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, CancellationToken cancellationToken, TPredicate predicate)
+        [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>
             where TPredicate: struct, IAsyncFunction<TSource, int, bool>

NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyCollection.cs

@@ -110,6 +110,24 @@ public bool Contains(TSource value, IEqualityComparer<TSource>? comparer)
         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);

NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ReadOnlyList.cs

@@ -182,6 +182,28 @@ public static int Count<TList, TSource>(this ValueEnumerable<TList, TSource> sou
             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>

NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable'1.ValueReadOnlyCollection.cs

@@ -100,6 +100,28 @@ public static int Count<TSource, TEnumerator>(this ValueEnumerable<TSource, TEnu
             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>