public static ValueReadOnlyCollectionExtensions.SelectEnumerable <ValueWrapper <TKey, TValue>, SortedDictionary <TKey, TValue> .KeyCollection.Enumerator, TKey, TResult> Select <TKey, TValue, TResult>( this SortedDictionary <TKey, TValue> .KeyCollection source, NullableSelector <TKey, TResult> selector) where TKey : notnull => ValueReadOnlyCollectionExtensions.Select <ValueWrapper <TKey, TValue>, SortedDictionary <TKey, TValue> .KeyCollection.Enumerator, TKey, TResult>(new ValueWrapper <TKey, TValue>(source), selector);
public void WhereSelect_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector) { // Arrange var expected = System.Linq.Enumerable.Select( System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc()); // Act var result = ArrayExtensions .Where((ReadOnlySpan <int>)source.AsSpan(), predicate) .Select(selector); // Assert _ = result.SequenceEqual(expected).Must().BeTrue(); }
public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey>(this ImmutableQueue <TSource> source, NullableSelector <TSource, TKey> keySelector) => ValueEnumerableExtensions.ToDictionary <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource, TKey>(new ValueWrapper <TSource>(source), keySelector);
public static ValueEnumerableExtensions.SelectEnumerable <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource, TResult> Select <TSource, TResult>( this ImmutableQueue <TSource> source, NullableSelector <TSource, TResult> selector) => ValueEnumerableExtensions.Select <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource, TResult>(new ValueWrapper <TSource>(source), selector);
public static ValueReadOnlyCollectionExtensions.SelectEnumerable <ValueWrapper <TSource>, ImmutableHashSet <TSource> .Enumerator, TSource, TResult> Select <TSource, TResult>( this ImmutableHashSet <TSource> source, NullableSelector <TSource, TResult> selector) => ValueReadOnlyCollectionExtensions.Select <ValueWrapper <TSource>, ImmutableHashSet <TSource> .Enumerator, TSource, TResult>(new ValueWrapper <TSource>(source), selector);
public static Dictionary <TKey, TSource> ToDictionary <TList, TSource, TKey>(this TList source, NullableSelector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer = default) where TList : IReadOnlyList <TSource> { if (keySelector is null) { Throw.ArgumentNullException(nameof(keySelector)); } return(ToDictionary <TList, TSource, TKey>(source, keySelector, comparer, 0, source.Count)); }
static Option <TResult> ElementAt <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, int index, NullableSelector <TSource, TResult> selector) where TEnumerable : IValueReadOnlyCollection <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { if (index >= 0 && index < source.Count) { using var enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { if (index-- == 0) { return(Option.Some(selector(enumerator.Current))); } } } return(Option.None); }
public void ToArray_With_Predicate_Selector_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector) { // Arrange var expected = Enumerable .Where(source, predicate.AsFunc()) .Select(selector.AsFunc()) .ToArray(); // Act var result = ArrayExtensions .Where(source.AsMemory(), predicate) .Select(selector) .ToArray(); // Assert _ = result.Must() .BeArrayOf <string>() .BeEqualTo(expected); }
static IMemoryOwner <TResult> ToArray <TSource, TResult>(this Memory <TSource> source, Predicate <TSource> predicate, NullableSelector <TSource, TResult> selector, MemoryPool <TResult> pool) => ToArray(source.Span, predicate, selector, pool);
public void ToList_Skip_Take_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, int skip, int take, Predicate <int> predicate, NullableSelector <int, string> selector) { // Arrange var wrapped = Wrap.AsReadOnlyList(source); var expected = Enumerable .Skip(source, skip) .Take(take) .Where(predicate.AsFunc()) .Select(selector.AsFunc()) .ToArray(); // Act var result = ReadOnlyListExtensions .Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip) .Take(take) .Where(predicate) .Select(selector) .ToList(); // Assert _ = result.Must() .BeOfType <List <string> >() .BeEnumerableOf <string>() .BeEqualTo(expected); }
static TResult[] ToArray <TSource, TResult>(this Memory <TSource> source, Predicate <TSource> predicate, NullableSelector <TSource, TResult> selector) => ToArray(source.Span, predicate, selector);
public void First_Predicate_Selector_With_ValidData_Must_Return_Some(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector) { // Arrange var wrapped = Wrap .AsValueEnumerable(source); var expected = Enumerable .Where(source, predicate.AsFunc()) .Select(selector.AsFunc()) .First(); // Act var result = ValueEnumerableExtensions .Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate) .Select(selector) .First(); // Assert _ = result.Match( value => value.Must().BeEqualTo(expected), () => throw new Exception()); }
public void First_Predicate_Selector_With_Empty_Must_Return_None(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector) { // Arrange var wrapped = Wrap .AsValueEnumerable(source); // Act var result = ValueEnumerableExtensions .Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate) .Select(selector) .First(); // Assert _ = result.Must() .BeOfType <Option <string> >() .EvaluateTrue(option => option.IsNone); }
static TResult[] ToArray <TSource, TResult>(this ReadOnlySpan <TSource> source, NullableSelector <TSource, TResult> selector) { var array = new TResult[source.Length]; for (var index = 0; index < source.Length; index++) { array[index] = selector(source[index]) !; } return(array); }
public void WhereSelect_With_ValidData_Must_Succeed(int[] source, int skip, int take, Predicate <int> predicate, NullableSelector <int, string> selector) { // Arrange var(offset, count) = Utils.SkipTake(source.Length, skip, take); var wrapped = new ArraySegment <int>(source, offset, count); var expected = Enumerable .Where(wrapped, predicate.AsFunc()) .Select(selector.AsFunc()); // Act var result = ArrayExtensions .Where(wrapped, predicate) .Select(selector); // Assert _ = result.Must() .BeEnumerableOf <string>() .BeEqualTo(expected, testRefStructs: false); _ = result.SequenceEqual(expected).Must().BeTrue(); }
static TResult[] ToArray <TSource, TResult>(this ReadOnlySpan <TSource> source, Predicate <TSource> predicate, NullableSelector <TSource, TResult> selector) { var builder = new LargeArrayBuilder <TResult>(initialize: true); builder.AddRange <TSource>(source, predicate, selector); return(builder.ToArray()); }
public static void Copy <TList, TSource, TResult>(TList source, int sourceOffset, TResult[] destination, int destinationOffset, int count, NullableSelector <TSource, TResult> selector) where TList : notnull, IReadOnlyList <TSource> { Debug.Assert(source.Count >= sourceOffset); Debug.Assert(destination.Length - destinationOffset >= count); if (count == 0) { return; } if (destinationOffset == 0) { if (sourceOffset == 0) { for (var index = 0; index < count; index++) { destination[index] = selector(source[index]) !; } } else { for (var index = 0; index < count; index++) { destination[index] = selector(source[index + sourceOffset]) !; } } } else { if (sourceOffset == 0) { for (var index = 0; index < count; index++) { destination[index + destinationOffset] = selector(source[index]) !; } } else { for (var index = 0; index < count; index++) { destination[index + destinationOffset] = selector(source[index + sourceOffset]) !; } } } }
public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement>(this ImmutableHashSet <TSource> source, Selector <TSource, TKey> keySelector, NullableSelector <TSource, TElement> elementSelector, IEqualityComparer <TKey>?comparer = default) where TKey : notnull => ValueReadOnlyCollectionExtensions.ToDictionary <ValueWrapper <TSource>, ImmutableHashSet <TSource> .Enumerator, TSource, TKey, TElement>(new ValueWrapper <TSource>(source), keySelector, elementSelector, comparer);
public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey>(this Memory <TSource> source, NullableSelector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer = null) => ToDictionary((ReadOnlySpan <TSource>)source.Span, keySelector, comparer);
static Dictionary <TKey, TElement> ToDictionary <TList, TSource, TKey, TElement>(this TList source, NullableSelector <TSource, TKey> keySelector, NullableSelector <TSource, TElement> elementSelector, IEqualityComparer <TKey>?comparer, int skipCount, int takeCount) where TList : IReadOnlyList <TSource> { var dictionary = new Dictionary <TKey, TElement>(source.Count, comparer); var end = skipCount + takeCount; for (var index = skipCount; index < end; index++) { dictionary.Add(keySelector(source[index]), elementSelector(source[index])); } return(dictionary); }
static bool Contains <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, [AllowNull] TResult value, NullableSelector <TSource, TResult> selector) where TEnumerable : notnull, IValueReadOnlyCollection <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> => source.Count != 0 && ValueEnumerableExtensions.Contains <TEnumerable, TEnumerator, TSource, TResult>(source, value, selector);
static Dictionary <TKey, TSource> ToDictionary <TList, TSource, TKey>(this TList source, NullableSelector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer, PredicateAt <TSource> predicate, int skipCount, int takeCount) where TList : IReadOnlyList <TSource> { var dictionary = new Dictionary <TKey, TSource>(source.Count, comparer); var end = skipCount + takeCount; for (var index = skipCount; index < end; index++) { if (predicate(source[index], index)) { dictionary.Add(keySelector(source[index]), source[index]); } } return(dictionary); }
public void ElementAt_Selector_With_OutOfRange_Must_Return_None(int[] source, NullableSelector <int, string> selector) { // Arrange var wrapped = Wrap .AsValueReadOnlyCollection(source); // Act var optionNegative = ValueReadOnlyCollectionExtensions .Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector) .ElementAt(-1); var optionTooLarge = ValueReadOnlyCollectionExtensions .Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector) .ElementAt(source.Length); // Assert _ = optionNegative.Must() .BeOfType <Option <string> >() .EvaluateTrue(option => option.IsNone); _ = optionTooLarge.Must() .BeOfType <Option <string> >() .EvaluateTrue(option => option.IsNone); }
public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement>(this ImmutableQueue <TSource> source, NullableSelector <TSource, TKey> keySelector, NullableSelector <TSource, TElement> elementSelector, IEqualityComparer <TKey>?comparer) => ValueEnumerableExtensions.ToDictionary <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource, TKey, TElement>(new ValueWrapper <TSource>(source), keySelector, elementSelector, comparer);
public static Option <TResult> First <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, NullableSelector <TSource, TResult> selector) where TEnumerable : IValueReadOnlyCollection <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { if (source.Count != 0) { using var enumerator = source.GetEnumerator(); if (enumerator.MoveNext()) { return(Option.Some(selector(enumerator.Current))); } } return(Option.None); }
public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement>(this ReadOnlySpan <TSource> source, Selector <TSource, TKey> keySelector, NullableSelector <TSource, TElement> elementSelector, IEqualityComparer <TKey>?comparer = null) where TKey : notnull { if (keySelector is null) { Throw.ArgumentNullException(nameof(keySelector)); } if (elementSelector is null) { Throw.ArgumentNullException(nameof(elementSelector)); } var dictionary = new Dictionary <TKey, TElement>(source.Length, comparer); for (var index = 0; index < source.Length; index++) { dictionary.Add(keySelector(source[index]), elementSelector(source[index]) !); } return(dictionary); }
public static Dictionary <TKey2, TElement> ToDictionary <TKey, TValue, TKey2, TElement>(this SortedDictionary <TKey, TValue> .KeyCollection source, Selector <TKey, TKey2> keySelector, NullableSelector <TKey, TElement> elementSelector, IEqualityComparer <TKey2>?comparer = default) where TKey : notnull where TKey2 : notnull => ValueReadOnlyCollectionExtensions.ToDictionary <ValueWrapper <TKey, TValue>, SortedDictionary <TKey, TValue> .KeyCollection.Enumerator, TKey, TKey2, TElement>(new ValueWrapper <TKey, TValue>(source), keySelector, elementSelector, comparer);