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);
