Use ValueTask in a few more places.

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Distinct.cs

@@ -88,19 +88,19 @@ namespace System.Linq
                 _comparer = comparer;
             }
 
-            public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                 return s.ToArray();
             }
 
-            public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                 return s;
             }
 
-            public async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public async ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
@@ -233,19 +233,19 @@ namespace System.Linq
                 _comparer = comparer;
             }
 
-            public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                 return s.ToArray();
             }
 
-            public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                 return s;
             }
 
-            public async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public async ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
@@ -332,7 +332,7 @@ namespace System.Linq
                 return false;
             }
 
-            private async Task<List<TSource>> FillSetAsync(CancellationToken cancellationToken)
+            private async ValueTask<List<TSource>> FillSetAsync(CancellationToken cancellationToken)
             {
                 var s = new Set<TKey>(_comparer);
                 var r = new List<TSource>();

Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Return.cs

@@ -33,11 +33,11 @@ namespace System.Linq
                 return new ReturnEnumerator(_value);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(1);
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(1);
 
-            public Task<TValue[]> ToArrayAsync(CancellationToken cancellationToken) => Task.FromResult(new[] { _value });
+            public ValueTask<TValue[]> ToArrayAsync(CancellationToken cancellationToken) => new ValueTask<TValue[]>(new[] { _value });
 
-            public Task<List<TValue>> ToListAsync(CancellationToken cancellationToken) => Task.FromResult(new List<TValue>(1) { _value });
+            public ValueTask<List<TValue>> ToListAsync(CancellationToken cancellationToken) => new ValueTask<List<TValue>>(new List<TValue>(1) { _value });
 
             private sealed class ReturnEnumerator : IAsyncEnumerator<TValue>
             {

Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerableHelpers.cs

@@ -11,14 +11,14 @@ namespace System.Collections.Generic
     // Based on https://github.com/dotnet/corefx/blob/ec2685715b01d12f16b08d0dfa326649b12db8ec/src/Common/src/System/Collections/Generic/EnumerableHelpers.cs
     internal static class AsyncEnumerableHelpers
     {
-        internal static async Task<T[]> ToArray<T>(IAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        internal static async ValueTask<T[]> ToArray<T>(IAsyncEnumerable<T> source, CancellationToken cancellationToken)
         {
             var result = await ToArrayWithLength(source, cancellationToken).ConfigureAwait(false);
             Array.Resize(ref result.Array, result.Length);
             return result.Array;
         }
 
-        internal static async Task<ArrayWithLength<T>> ToArrayWithLength<T>(IAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        internal static async ValueTask<ArrayWithLength<T>> ToArrayWithLength<T>(IAsyncEnumerable<T> source, CancellationToken cancellationToken)
         {
             var result = new ArrayWithLength<T>();
             // Check for short circuit optimizations. This one is very unlikely

Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs

@@ -62,16 +62,16 @@ namespace System.Linq
             await base.DisposeAsync().ConfigureAwait(false);
         }
 
-        public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+        public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
         {
             if (onlyIfCheap)
             {
-                return TaskExt.MinusOne;
+                return new ValueTask<int>(-1);
             }
 
             return Core();
 
-            async Task<int> Core()
+            async ValueTask<int> Core()
             {
                 if (!HasLimit)
                 {
@@ -291,7 +291,7 @@ namespace System.Linq
             return new Maybe<TSource>();
         }
 
-        public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+        public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
         {
             var en = _source.GetAsyncEnumerator(cancellationToken);
 
@@ -327,7 +327,7 @@ namespace System.Linq
 #endif
         }
 
-        public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+        public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
         {
             var list = new List<TSource>();
 

Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs

@@ -142,12 +142,12 @@ namespace System.Linq
             }
         }
 
-        public Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+        public ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
         {
             var count = Count;
             if (count == 0)
             {
-                return Task.FromResult(
+                return new ValueTask<TSource[]>(
 #if NO_ARRAY_EMPTY
                     EmptyArray<TSource>.Value
 #else
@@ -162,15 +162,15 @@ namespace System.Linq
                 array[i] = _source[curIdx];
             }
 
-            return Task.FromResult(array);
+            return new ValueTask<TSource[]>(array);
         }
 
-        public Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+        public ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
         {
             var count = Count;
             if (count == 0)
             {
-                return Task.FromResult(new List<TSource>());
+                return new ValueTask<List<TSource>>(new List<TSource>());
             }
 
             var list = new List<TSource>(count);
@@ -180,12 +180,12 @@ namespace System.Linq
                 list.Add(_source[i]);
             }
 
-            return Task.FromResult(list);
+            return new ValueTask<List<TSource>>(list);
         }
 
-        public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+        public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
         {
-            return Task.FromResult(Count);
+            return new ValueTask<int>(Count);
         }
     }
 }

Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs

@@ -18,14 +18,14 @@ namespace System.Linq
         /// </summary>
         /// <param name="cancellationToken"></param>
         /// <returns>The array.</returns>
-        Task<TElement[]> ToArrayAsync(CancellationToken cancellationToken);
+        ValueTask<TElement[]> ToArrayAsync(CancellationToken cancellationToken);
 
         /// <summary>
         /// Produce a <see cref="List{TElement}"/> of the sequence through an optimized path.
         /// </summary>
         /// <param name="cancellationToken"></param>
         /// <returns>The <see cref="List{TElement}"/>.</returns>
-        Task<List<TElement>> ToListAsync(CancellationToken cancellationToken);
+        ValueTask<List<TElement>> ToListAsync(CancellationToken cancellationToken);
 
         /// <summary>
         /// Returns the count of elements in the sequence.
@@ -34,6 +34,6 @@ namespace System.Linq
         /// so is quick (sure or likely to be constant time), otherwise -1 should be returned.</param>
         /// <param name="cancellationToken"></param>
         /// <returns>The number of elements.</returns>
-        Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken);
+        ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken);
     }
 }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs

@@ -86,9 +86,9 @@ namespace System.Linq
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
-            public abstract Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken);
-            public abstract Task<List<TSource>> ToListAsync(CancellationToken cancellationToken);
-            public abstract Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken);
+            public abstract ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken);
+            public abstract ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken);
+            public abstract ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken);
         }
 
         private sealed class AppendPrepend1AsyncIterator<TSource> : AppendPrependAsyncIterator<TSource>
@@ -177,7 +177,7 @@ namespace System.Linq
                 }
             }
 
-            public override async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public override async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var count = await GetCountAsync(onlyIfCheap: true, cancellationToken).ConfigureAwait(false);
                 if (count == -1)
@@ -227,7 +227,7 @@ namespace System.Linq
                 return array;
             }
 
-            public override async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public override async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var count = await GetCountAsync(onlyIfCheap: true, cancellationToken).ConfigureAwait(false);
                 var list = count == -1 ? new List<TSource>() : new List<TSource>(count);
@@ -260,7 +260,7 @@ namespace System.Linq
                 return list;
             }
 
-            public override async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public override async ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (_source is IAsyncIListProvider<TSource> listProv)
                 {
@@ -386,7 +386,7 @@ namespace System.Linq
                 return new AppendPrependNAsyncIterator<TSource>(_source, res, _appended, _prependCount + 1, _appendCount);
             }
 
-            public override async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public override async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var count = await GetCountAsync(onlyIfCheap: true, cancellationToken).ConfigureAwait(false);
                 if (count == -1)
@@ -434,7 +434,7 @@ namespace System.Linq
                 return array;
             }
 
-            public override async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public override async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var count = await GetCountAsync(onlyIfCheap: true, cancellationToken).ConfigureAwait(false);
                 var list = count == -1 ? new List<TSource>() : new List<TSource>(count);
@@ -471,7 +471,7 @@ namespace System.Linq
                 return list;
             }
 
-            public override async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public override async ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (_source is IAsyncIListProvider<TSource> listProv)
                 {

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Concat.cs

@@ -66,12 +66,12 @@ namespace System.Linq
             private int _counter;
             private IAsyncEnumerator<TSource> _enumerator;
 
-            public Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 return AsyncEnumerableHelpers.ToArray(this, cancellationToken);
             }
 
-            public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var list = new List<TSource>();
                 for (var i = 0; ; i++)
@@ -100,16 +100,16 @@ namespace System.Linq
                 return list;
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var count = 0;
                     for (var i = 0; ; i++)

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Count.cs

@@ -86,7 +86,7 @@ namespace System.Linq
                 case ICollection<TSource> collection:
                     return Task.FromResult(collection.Count);
                 case IAsyncIListProvider<TSource> listProv:
-                    return listProv.GetCountAsync(onlyIfCheap: false, cancellationToken);
+                    return listProv.GetCountAsync(onlyIfCheap: false, cancellationToken).AsTask();
                 case ICollection collection:
                     return Task.FromResult(collection.Count);
             }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs

@@ -93,13 +93,13 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var array = await _source.ToArrayAsync(cancellationToken).ConfigureAwait(false);
                 return array.Length == 0 ? new[] { _defaultValue } : array;
             }
 
-            public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var list = await _source.ToListAsync(cancellationToken).ConfigureAwait(false);
                 if (list.Count == 0)
@@ -110,7 +110,7 @@ namespace System.Linq
                 return list;
             }
 
-            public async Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public async ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 int count;
                 if (!onlyIfCheap || _source is ICollection<TSource> || _source is ICollection)

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Distinct.cs

@@ -43,28 +43,28 @@ namespace System.Linq
                 _comparer = comparer;
             }
 
-            public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                 return s.ToArray();
             }
 
-            public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                 return s.ToList();
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var s = await FillSetAsync(cancellationToken).ConfigureAwait(false);
                     return s.Count;

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs

@@ -18,13 +18,13 @@ namespace System.Linq
 
             public TValue Current => default;
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(0);
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(0);
 
             public IAsyncPartition<TValue> Skip(int count) => this;
 
             public IAsyncPartition<TValue> Take(int count) => this;
 
-            public Task<TValue[]> ToArrayAsync(CancellationToken cancellationToken) => Task.FromResult(
+            public ValueTask<TValue[]> ToArrayAsync(CancellationToken cancellationToken) => new ValueTask<TValue[]>(
 #if NO_ARRAY_EMPTY
                 EmptyArray<TValue>.Value
 #else
@@ -32,7 +32,7 @@ namespace System.Linq
 #endif
                 );
 
-            public Task<List<TValue>> ToListAsync(CancellationToken cancellationToken) => Task.FromResult(new List<TValue>());
+            public ValueTask<List<TValue>> ToListAsync(CancellationToken cancellationToken) => new ValueTask<List<TValue>>(new List<TValue>());
 
             public ValueTask<Maybe<TValue>> TryGetElementAsync(int index, CancellationToken cancellationToken) => new ValueTask<Maybe<TValue>>(new Maybe<TValue>());
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs

@@ -378,28 +378,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return l.ToArray(_resultSelector);
             }
 
-            public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return l.ToList(_resultSelector);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -471,28 +471,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArray(_resultSelector).ConfigureAwait(false);
             }
 
-            public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToList(_resultSelector).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -565,28 +565,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArray(_resultSelector, cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToList(_resultSelector, cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -659,28 +659,28 @@ namespace System.Linq
                 return false;
             }
             
-            public async Task<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.Lookup<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -752,28 +752,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -846,28 +846,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<IAsyncGrouping<TKey, TElement>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<IAsyncGrouping<TKey, TElement>>> ToListAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TElement>> l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -937,28 +937,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.Lookup<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -1027,28 +1027,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 
@@ -1118,28 +1118,28 @@ namespace System.Linq
                 return false;
             }
 
-            public async Task<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<IAsyncGrouping<TKey, TSource>[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToArrayAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public async Task<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<IAsyncGrouping<TKey, TSource>>> ToListAsync(CancellationToken cancellationToken)
             {
                 IAsyncIListProvider<IAsyncGrouping<TKey, TSource>> l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
                 return await l.ToListAsync(cancellationToken).ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var l = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, cancellationToken).ConfigureAwait(false);
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs

@@ -267,9 +267,9 @@ namespace System.Linq.Internal
             _groupings = newGroupings;
         }
 
-        public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+        public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
         {
-            return Task.FromResult(Count);
+            return new ValueTask<int>(Count);
         }
 
         IAsyncEnumerator<IAsyncGrouping<TKey, TElement>> IAsyncEnumerable<IAsyncGrouping<TKey, TElement>>.GetAsyncEnumerator(CancellationToken cancellationToken)
@@ -279,7 +279,7 @@ namespace System.Linq.Internal
             return Enumerable.Cast<IAsyncGrouping<TKey, TElement>>(this).ToAsyncEnumerable().GetAsyncEnumerator(cancellationToken);
         }
 
-        Task<List<IAsyncGrouping<TKey, TElement>>> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToListAsync(CancellationToken cancellationToken)
+        ValueTask<List<IAsyncGrouping<TKey, TElement>>> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToListAsync(CancellationToken cancellationToken)
         {
             var list = new List<IAsyncGrouping<TKey, TElement>>(Count);
             var g = _lastGrouping;
@@ -293,10 +293,10 @@ namespace System.Linq.Internal
                 while (g != _lastGrouping);
             }
 
-            return Task.FromResult(list);
+            return new ValueTask<List<IAsyncGrouping<TKey, TElement>>>(list);
         }
 
-        Task<IAsyncGrouping<TKey, TElement>[]> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToArrayAsync(CancellationToken cancellationToken)
+        ValueTask<IAsyncGrouping<TKey, TElement>[]> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToArrayAsync(CancellationToken cancellationToken)
         {
             var array = new IAsyncGrouping<TKey, TElement>[Count];
             var index = 0;
@@ -312,7 +312,7 @@ namespace System.Linq.Internal
                 while (g != _lastGrouping);
             }
 
-            return Task.FromResult(array);
+            return new ValueTask<IAsyncGrouping<TKey, TElement>[]>(array);
         }
     }
 
@@ -682,9 +682,9 @@ namespace System.Linq.Internal
             _groupings = newGroupings;
         }
 
-        public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+        public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
         {
-            return Task.FromResult(Count);
+            return new ValueTask<int>(Count);
         }
 
         IAsyncEnumerator<IAsyncGrouping<TKey, TElement>> IAsyncEnumerable<IAsyncGrouping<TKey, TElement>>.GetAsyncEnumerator(CancellationToken cancellationToken)
@@ -694,7 +694,7 @@ namespace System.Linq.Internal
             return Enumerable.Cast<IAsyncGrouping<TKey, TElement>>(this).ToAsyncEnumerable().GetAsyncEnumerator(cancellationToken);
         }
 
-        Task<List<IAsyncGrouping<TKey, TElement>>> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToListAsync(CancellationToken cancellationToken)
+        ValueTask<List<IAsyncGrouping<TKey, TElement>>> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToListAsync(CancellationToken cancellationToken)
         {
             var list = new List<IAsyncGrouping<TKey, TElement>>(Count);
             var g = _lastGrouping;
@@ -708,10 +708,10 @@ namespace System.Linq.Internal
                 while (g != _lastGrouping);
             }
 
-            return Task.FromResult(list);
+            return new ValueTask<List<IAsyncGrouping<TKey, TElement>>>(list);
         }
 
-        Task<IAsyncGrouping<TKey, TElement>[]> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToArrayAsync(CancellationToken cancellationToken)
+        ValueTask<IAsyncGrouping<TKey, TElement>[]> IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>.ToArrayAsync(CancellationToken cancellationToken)
         {
             var array = new IAsyncGrouping<TKey, TElement>[Count];
             var index = 0;
@@ -727,7 +727,7 @@ namespace System.Linq.Internal
                 while (g != _lastGrouping);
             }
 
-            return Task.FromResult(array);
+            return new ValueTask<IAsyncGrouping<TKey, TElement>[]>(array);
         }
     }
 }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs

@@ -41,7 +41,7 @@ namespace System.Linq
 
             public override AsyncIteratorBase<int> Clone() => new RangeAsyncIterator(_start, _end - _start);
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(_end - _start);
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(_end - _start);
 
             public IAsyncPartition<int> Skip(int count)
             {
@@ -67,7 +67,7 @@ namespace System.Linq
                 return new RangeAsyncIterator(_start, count);
             }
 
-            public Task<int[]> ToArrayAsync(CancellationToken cancellationToken)
+            public ValueTask<int[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var res = new int[_end - _start];
 
@@ -78,10 +78,10 @@ namespace System.Linq
                     res[i] = value++;
                 }
 
-                return Task.FromResult(res);
+                return new ValueTask<int[]>(res);
             }
 
-            public Task<List<int>> ToListAsync(CancellationToken cancellationToken)
+            public ValueTask<List<int>> ToListAsync(CancellationToken cancellationToken)
             {
                 var res = new List<int>(_end - _start);
 
@@ -90,7 +90,7 @@ namespace System.Linq
                     res.Add(value);
                 }
 
-                return Task.FromResult(res);
+                return new ValueTask<List<int>>(res);
             }
 
             public ValueTask<Maybe<int>> TryGetElementAsync(int index, CancellationToken cancellationToken)

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs

@@ -32,9 +32,9 @@ namespace System.Linq
 
             public override AsyncIteratorBase<TResult> Clone() => new RepeatAsyncIterator<TResult>(_element, _count);
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(_count);
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(_count);
 
-            public Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var res = new TResult[_count];
 
@@ -43,10 +43,10 @@ namespace System.Linq
                     res[i] = _element;
                 }
 
-                return Task.FromResult(res);
+                return new ValueTask<TResult[]>(res);
             }
 
-            public Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var res = new List<TResult>(_count);
 
@@ -55,7 +55,7 @@ namespace System.Linq
                     res.Add(_element);
                 }
 
-                return Task.FromResult(res);
+                return new ValueTask<List<TResult>>(res);
             }
 
             protected override async ValueTask<bool> MoveNextCore()

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs

@@ -34,7 +34,7 @@ namespace System.Linq
                 _source = source;
             }
 
-            public async Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var array = await _source.ToArrayAsync(cancellationToken).ConfigureAwait(false);
 
@@ -50,7 +50,7 @@ namespace System.Linq
                 return array;
             }
 
-            public async Task<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
             {
                 var list = await _source.ToListAsync(cancellationToken).ConfigureAwait(false);
 
@@ -58,7 +58,7 @@ namespace System.Linq
                 return list;
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
@@ -69,11 +69,11 @@ namespace System.Linq
 
                     if (!(_source is ICollection<TSource>) && !(_source is ICollection))
                     {
-                        return TaskExt.MinusOne;
+                        return new ValueTask<int>(-1);
                     }
                 }
 
-                return _source.CountAsync(cancellationToken);
+                return new ValueTask<int>(_source.CountAsync(cancellationToken));
             }
 
             public override AsyncIteratorBase<TSource> Clone()

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs

@@ -272,11 +272,11 @@ namespace System.Linq
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 var count = 0;
@@ -291,7 +291,7 @@ namespace System.Linq
                     }
                 }
 
-                return Task.FromResult(count);
+                return new ValueTask<int>(count);
             }
 
             public override IAsyncEnumerable<TResult1> Select<TResult1>(Func<TResult, TResult1> selector)
@@ -299,7 +299,7 @@ namespace System.Linq
                 return new SelectIListIterator<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
-            public Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var n = _source.Count;
 
@@ -310,10 +310,10 @@ namespace System.Linq
                     res[i] = _selector(_source[i]);
                 }
 
-                return Task.FromResult(res);
+                return new ValueTask<TResult[]>(res);
             }
 
-            public Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var n = _source.Count;
 
@@ -324,7 +324,7 @@ namespace System.Linq
                     res.Add(_selector(_source[i]));
                 }
 
-                return Task.FromResult(res);
+                return new ValueTask<List<TResult>>(res);
             }
 
             protected override async ValueTask<bool> MoveNextCore()
@@ -641,16 +641,16 @@ namespace System.Linq
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var count = 0;
 
@@ -673,7 +673,7 @@ namespace System.Linq
                 return new SelectIListIteratorWithTask<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
-            public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var n = _source.Count;
 
@@ -687,7 +687,7 @@ namespace System.Linq
                 return res;
             }
 
-            public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var n = _source.Count;
 
@@ -757,16 +757,16 @@ namespace System.Linq
                 await base.DisposeAsync().ConfigureAwait(false);
             }
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
             {
                 if (onlyIfCheap)
                 {
-                    return TaskExt.MinusOne;
+                    return new ValueTask<int>(-1);
                 }
 
                 return Core();
 
-                async Task<int> Core()
+                async ValueTask<int> Core()
                 {
                     var count = 0;
 
@@ -789,7 +789,7 @@ namespace System.Linq
                 return new SelectIListIteratorWithTaskAndCancellation<TSource, TResult1>(_source, CombineSelectors(_selector, selector));
             }
 
-            public async Task<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
+            public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
             {
                 var n = _source.Count;
 
@@ -803,7 +803,7 @@ namespace System.Linq
                 return res;
             }
 
-            public async Task<List<TResult>> ToListAsync(CancellationToken cancellationToken)
+            public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
             {
                 var n = _source.Count;
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToArray.cs

@@ -24,9 +24,9 @@ namespace System.Linq
                 throw Error.ArgumentNull(nameof(source));
 
             if (source is IAsyncIListProvider<TSource> arrayProvider)
-                return arrayProvider.ToArrayAsync(cancellationToken);
+                return arrayProvider.ToArrayAsync(cancellationToken).AsTask();
 
-            return AsyncEnumerableHelpers.ToArray(source, cancellationToken);
+            return AsyncEnumerableHelpers.ToArray(source, cancellationToken).AsTask();
         }
     }
 }

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs

@@ -80,11 +80,11 @@ namespace System.Linq
 
             // These optimizations rely on the Sys.Linq impls from IEnumerable to optimize
             // and short circuit as appropriate
-            public Task<T[]> ToArrayAsync(CancellationToken cancellationToken) => Task.FromResult(_source.ToArray());
+            public ValueTask<T[]> ToArrayAsync(CancellationToken cancellationToken) => new ValueTask<T[]>(_source.ToArray());
 
-            public Task<List<T>> ToListAsync(CancellationToken cancellationToken) => Task.FromResult(_source.ToList());
+            public ValueTask<List<T>> ToListAsync(CancellationToken cancellationToken) => new ValueTask<List<T>>(_source.ToList());
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(_source.Count());
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(_source.Count());
         }
 
         private sealed class AsyncIListEnumerableAdapter<T> : AsyncIterator<T>, IAsyncIListProvider<T>, IList<T>
@@ -139,11 +139,11 @@ namespace System.Linq
 
             // These optimizations rely on the Sys.Linq impls from IEnumerable to optimize
             // and short circuit as appropriate
-            public Task<T[]> ToArrayAsync(CancellationToken cancellationToken) => Task.FromResult(_source.ToArray());
+            public ValueTask<T[]> ToArrayAsync(CancellationToken cancellationToken) => new ValueTask<T[]>(_source.ToArray());
 
-            public Task<List<T>> ToListAsync(CancellationToken cancellationToken) => Task.FromResult(_source.ToList());
+            public ValueTask<List<T>> ToListAsync(CancellationToken cancellationToken) => new ValueTask<List<T>>(_source.ToList());
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(_source.Count);
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(_source.Count);
 
             IEnumerator<T> IEnumerable<T>.GetEnumerator() => _source.GetEnumerator();
 
@@ -226,11 +226,11 @@ namespace System.Linq
 
             // These optimizations rely on the Sys.Linq impls from IEnumerable to optimize
             // and short circuit as appropriate
-            public Task<T[]> ToArrayAsync(CancellationToken cancellationToken) => Task.FromResult(_source.ToArray());
+            public ValueTask<T[]> ToArrayAsync(CancellationToken cancellationToken) => new ValueTask<T[]>(_source.ToArray());
 
-            public Task<List<T>> ToListAsync(CancellationToken cancellationToken) => Task.FromResult(_source.ToList());
+            public ValueTask<List<T>> ToListAsync(CancellationToken cancellationToken) => new ValueTask<List<T>>(_source.ToList());
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => Task.FromResult(_source.Count);
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask<int>(_source.Count);
 
             IEnumerator<T> IEnumerable<T>.GetEnumerator() => _source.GetEnumerator();
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToList.cs

@@ -29,7 +29,7 @@ namespace System.Linq
         private static Task<List<TSource>> ToListCore<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source is IAsyncIListProvider<TSource> listProvider)
-                return listProvider.ToListAsync(cancellationToken);
+                return listProvider.ToListAsync(cancellationToken).AsTask();
 
             return Core();
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs

@@ -92,7 +92,7 @@ namespace System.Linq
                 _set = set;
             }
 
-            private async Task<bool> GetNextAsync()
+            private async ValueTask<bool> GetNextAsync()
             {
                 var set = _set;
                 Debug.Assert(set != null);
@@ -188,11 +188,33 @@ namespace System.Linq
                 }
             }
 
-            public Task<TSource[]> ToArrayAsync(CancellationToken cancellationToken) => FillSetAsync(cancellationToken).ContinueWith(set => set.Result.ToArray());
+            public async ValueTask<TSource[]> ToArrayAsync(CancellationToken cancellationToken)
+            {
+                var set = await FillSetAsync(cancellationToken).ConfigureAwait(false);
+                return set.ToArray();
+            }
+
+            public async ValueTask<List<TSource>> ToListAsync(CancellationToken cancellationToken)
+            {
+                var set = await FillSetAsync(cancellationToken).ConfigureAwait(false);
+                return set.ToList();
+            }
+
+            public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
+            {
+                if (onlyIfCheap)
+                {
+                    return new ValueTask<int>(-1);
+                }
 
-            public Task<List<TSource>> ToListAsync(CancellationToken cancellationToken) => FillSetAsync(cancellationToken).ContinueWith(set => set.Result.ToList());
+                return Core();
 
-            public Task<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => onlyIfCheap ? TaskExt.MinusOne : FillSetAsync(cancellationToken).ContinueWith(set => set.Result.Count);
+                async ValueTask<int> Core()
+                {
+                    var set = await FillSetAsync(cancellationToken).ConfigureAwait(false);
+                    return set.Count;
+                }
+            }
         }
 
         /// <summary>