public void AddRange <TEnumerable, TEnumerator, U>(TEnumerable items, NullableSelectorAt <U, T> selector)
where TEnumerable : IValueEnumerable <U, TEnumerator>
where TEnumerator : struct, IEnumerator <U>
{
Debug.Assert(items is object);
using var enumerator = items.GetEnumerator();
var destination = _current;
var index = _index;
// Continuously read in items from the enumerator, updating _count
// and _index when we run out of space.
while (enumerator.MoveNext())
{
var item = enumerator.Current;
if ((uint)index >= (uint)destination.Length)
{
AddWithBufferAllocation(selector(item, index), ref destination, ref index);
}
else
{
destination[index] = selector(item, index) !;
}
index++;
}
// Final update to _count and _index.
_count += index - _index;
_index = index;
}
static TResult[] ToArray <TSource, TResult>(this TSource[] source, NullableSelectorAt <TSource, TResult> selector, int skipCount, int takeCount)
{
var array = new TResult[takeCount];
if (skipCount == 0)
{
if (takeCount == source.Length)
{
for (var index = 0; index < source.Length; index++)
{
array[index] = selector(source[index], index);
}
}
else
{
for (var index = 0; index < takeCount; index++)
{
array[index] = selector(source[index], index);
}
}
}
else
{
for (var index = 0; index < takeCount; index++)
{
array[index] = selector(source[index + skipCount], index);
}
}
return(array);
}
static TResult[] ToArray <TList, TSource, TResult>(this TList source, NullableSelectorAt <TSource, TResult> selector, int offset, int count)
where TList : notnull, IReadOnlyList <TSource>
{
#if NET5_0
var result = GC.AllocateUninitializedArray <TResult>(count);
#else
var result = new TResult[count];
#endif
ReadOnlyListExtensions.Copy(source, offset, result, 0, count, selector);
return(result);
}
public static SelectAtEnumerable <TSource, TResult> Select <TSource, TResult>(
this TSource[] source,
NullableSelectorAt <TSource, TResult> selector)
{
if (selector is null)
{
Throw.ArgumentNullException(nameof(selector));
}
return(new SelectAtEnumerable <TSource, TResult>(in source, selector, 0, source.Length));
}
public static MemorySelectAtEnumerable <TSource, TResult> Select <TSource, TResult>(
this ReadOnlyMemory <TSource> source,
NullableSelectorAt <TSource, TResult> selector)
{
if (selector is null)
{
Throw.ArgumentNullException(nameof(selector));
}
return(new MemorySelectAtEnumerable <TSource, TResult>(in source, selector));
}
public static SelectAtEnumerable <TList, TSource, TResult> Select <TList, TSource, TResult>(
this TList source,
NullableSelectorAt <TSource, TResult> selector)
where TList : notnull, IReadOnlyList <TSource>
{
if (selector is null)
{
Throw.ArgumentNullException(nameof(selector));
}
return(new SelectAtEnumerable <TList, TSource, TResult>(in source, selector, 0, source.Count));
}
public void Select_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.Select(source, selector.AsFunc());
// Act
var result = ArrayExtensions.Select((ReadOnlySpan <int>)source.AsSpan(), selector);
// Assert
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public static SelectAtEnumerable <TEnumerable, TEnumerator, TSource, TResult> Select <TEnumerable, TEnumerator, TSource, TResult>(
this TEnumerable source,
NullableSelectorAt <TSource, TResult> selector)
where TEnumerable : IValueReadOnlyCollection <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
{
if (selector is null)
{
Throw.ArgumentNullException(nameof(selector));
}
return(new SelectAtEnumerable <TEnumerable, TEnumerator, TSource, TResult>(in source, selector));
}
public void Single_SelectorAt_With_Multiple_Must_Return_None(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
// Act
var result = ArrayExtensions
.Select(source.AsMemory(), selector)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void First_SelectorAt_With_Empty_Must_Return_None(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
// Act
var result = ArrayExtensions
.Select((ReadOnlySpan <int>)source.AsSpan(), selector)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Select_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.Select(source, selector.AsFunc());
// Act
var result = ArrayExtensions.Select(source.AsMemory(), selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected, testRefStructs: false);
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void First_SelectorAt_With_Empty_Must_Return_None(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyCollection(source);
// Act
var result = ValueReadOnlyCollectionExtensions
.Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Single_SelectorAt_With_Multiple_Must_Return_None(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Select_Selector_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected = System.Linq.Enumerable
.Select(source, selector.AsFunc());
// Act
var result = AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync());
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <string>()
.BeEqualTo(expected);
}
public void ToArray_SelectorAt_MemoryPool_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToArray();
// Act
using var result = ArrayExtensions
.Select((ReadOnlyMemory <int>)source.AsMemory(), selector)
.ToArray(pool);
// Assert
_ = result.Memory.Must()
.BeEqualTo(expected);
}
public void ToArray_With_SelectorAt_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
// Act
var result = ArrayExtensions
.Select <int, string>((ReadOnlySpan <int>)source.AsSpan(), selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void Select_SelectorAt_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var list = source.ToList();
var expected = Enumerable
.Select(source, selector.AsFunc());
// Act
var result = ListBindings
.Select(list, selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected, testRefStructs: false);
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void First_SelectorAt_With_ValidData_Must_Return_Some(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.First();
// Act
var result = ArrayExtensions
.Select((ReadOnlySpan <int>)source.AsSpan(), selector)
.First();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToArray_With_SelectorAt_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToArray();
// Act
var result = ArrayExtensions
.Select(source.AsMemory(), selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void Single_SelectorAt_With_Single_Must_Return_Some(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.Single();
// Act
var result = ArrayExtensions
.Select <int, string>(source.AsMemory(), selector)
.Single();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToList_With_SelectorAt_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToList();
// Act
var result = ArrayExtensions
.Select((ReadOnlySpan <int>)source.AsSpan(), selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void ToArray_SelectorAt_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyCollection(source);
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
// Act
var result = ValueReadOnlyCollectionExtensions
.Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void First_SelectorAt_With_ValidData_Must_Return_Some(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyCollection(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.First();
// Act
var result = ValueReadOnlyCollectionExtensions
.Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.First();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToList_SelectorAt_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToList();
// Act
var result = ValueEnumerableExtensions
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
static TResult[] ToArray <TList, TSource, TResult>(this TList source, NullableSelectorAt <TSource, TResult> selector, int skipCount, int takeCount)
where TList : IReadOnlyList <TSource>
{
var array = new TResult[takeCount];
if (skipCount == 0)
{
for (var index = 0; index < takeCount; index++)
{
array[index] = selector(source[index], index) !;
}
}
else
{
for (var index = 0; index < takeCount; index++)
{
array[index] = selector(source[index + skipCount], index) !;
}
}
return(array);
}
public void ToList_SelectorAt_Must_Succeed(int[] source, int skip, int take, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = new ArraySegment <int>(source);
var expected = Enumerable
.Skip(wrapped, skip)
.Take(take)
.Select(selector.AsFunc())
.ToList();
// Act
var result = ArrayExtensions
.Skip(wrapped, skip)
.Take(take)
.Select(selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
static IMemoryOwner <TResult> ToArray <TSource, TResult>(this ReadOnlySpan <TSource> source, NullableSelectorAt <TSource, TResult> selector, MemoryPool <TResult> pool)
{
var result = pool.RentSliced(source.Length);
ArrayExtensions.Copy(source, result.Memory.Span, selector);
return(result);
}
static TResult[] ToArray <TSource, TResult>(this ReadOnlySpan <TSource> source, NullableSelectorAt <TSource, TResult> selector)
{
#if NET5_0
var result = GC.AllocateUninitializedArray <TResult>(source.Length);
#else
var result = new TResult[source.Length];
#endif
ArrayExtensions.Copy(source, result, selector);
return(result);
}
public static ValueReadOnlyCollectionExtensions.SelectAtEnumerable <ValueWrapper <TKey, TValue>, Dictionary <TKey, TValue> .Enumerator, KeyValuePair <TKey, TValue>, TResult> Select <TKey, TValue, TResult>(
this Dictionary <TKey, TValue> source,
NullableSelectorAt <KeyValuePair <TKey, TValue>, TResult> selector)
where TKey : notnull
=> ValueReadOnlyCollectionExtensions.Select <ValueWrapper <TKey, TValue>, Dictionary <TKey, TValue> .Enumerator, KeyValuePair <TKey, TValue>, TResult>(new ValueWrapper <TKey, TValue>(source), selector);
public static Option <TResult> ElementAt <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, int index, NullableSelectorAt <TSource, TResult> selector)
where TEnumerable : notnull, IValueReadOnlyCollection <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
{
if (index >= 0 && index < source.Count)
{
using var enumerator = source.GetEnumerator();
checked
{
for (var sourceIndex = 0; enumerator.MoveNext(); sourceIndex++)
{
if (sourceIndex == index)
{
return(Option.Some(selector(enumerator.Current, sourceIndex)));
}
}
}
}
return(Option.None);
}
