Use ValueTask for internal IAsyncPartition interface.

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

@@ -217,7 +217,7 @@ namespace System.Linq
             return new AsyncEnumerablePartition<TSource>(_source, _minIndexInclusive, maxIndex);
         }
 
-        public async Task<Maybe<TSource>> TryGetElementAsync(int index, CancellationToken cancellationToken)
+        public async ValueTask<Maybe<TSource>> TryGetElementAsync(int index, CancellationToken cancellationToken)
         {
             // If the index is negative or >= our max count, return early.
             if (index >= 0 && (!HasLimit || index < Limit))
@@ -242,7 +242,7 @@ namespace System.Linq
             return new Maybe<TSource>();
         }
 
-        public async Task<Maybe<TSource>> TryGetFirstAsync(CancellationToken cancellationToken)
+        public async ValueTask<Maybe<TSource>> TryGetFirstAsync(CancellationToken cancellationToken)
         {
             var en = _source.GetAsyncEnumerator(cancellationToken);
 
@@ -261,7 +261,7 @@ namespace System.Linq
             return new Maybe<TSource>();
         }
 
-        public async Task<Maybe<TSource>> TryGetLastAsync(CancellationToken cancellationToken)
+        public async ValueTask<Maybe<TSource>> TryGetLastAsync(CancellationToken cancellationToken)
         {
             var en = _source.GetAsyncEnumerator(cancellationToken);
 
@@ -356,21 +356,21 @@ namespace System.Linq
             return list;
         }
 
-        private Task<bool> SkipBeforeFirstAsync(IAsyncEnumerator<TSource> en) => SkipBeforeAsync(_minIndexInclusive, en);
+        private ValueTask<bool> SkipBeforeFirstAsync(IAsyncEnumerator<TSource> en) => SkipBeforeAsync(_minIndexInclusive, en);
 
-        private static async Task<bool> SkipBeforeAsync(int index, IAsyncEnumerator<TSource> en)
+        private static async ValueTask<bool> SkipBeforeAsync(int index, IAsyncEnumerator<TSource> en)
         {
             var n = await SkipAndCountAsync(index, en).ConfigureAwait(false);
             return n == index;
         }
 
-        private static async Task<int> SkipAndCountAsync(int index, IAsyncEnumerator<TSource> en)
+        private static async ValueTask<int> SkipAndCountAsync(int index, IAsyncEnumerator<TSource> en)
         {
             Debug.Assert(index >= 0);
             return (int)await SkipAndCountAsync((uint)index, en).ConfigureAwait(false);
         }
 
-        private static async Task<uint> SkipAndCountAsync(uint index, IAsyncEnumerator<TSource> en)
+        private static async ValueTask<uint> SkipAndCountAsync(uint index, IAsyncEnumerator<TSource> en)
         {
             Debug.Assert(en != null);
 

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

@@ -89,38 +89,38 @@ namespace System.Linq
             }
         }
 
-        public Task<Maybe<TSource>> TryGetElementAsync(int index, CancellationToken cancellationToken)
+        public ValueTask<Maybe<TSource>> TryGetElementAsync(int index, CancellationToken cancellationToken)
         {
             if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive) && index < _source.Count - _minIndexInclusive)
             {
                 var res = _source[_minIndexInclusive + index];
-                return Task.FromResult(new Maybe<TSource>(res));
+                return new ValueTask<Maybe<TSource>>(new Maybe<TSource>(res));
             }
 
-            return Task.FromResult(new Maybe<TSource>());
+            return new ValueTask<Maybe<TSource>>(new Maybe<TSource>());
         }
 
-        public Task<Maybe<TSource>> TryGetFirstAsync(CancellationToken cancellationToken)
+        public ValueTask<Maybe<TSource>> TryGetFirstAsync(CancellationToken cancellationToken)
         {
             if (_source.Count > _minIndexInclusive)
             {
                 var res = _source[_minIndexInclusive];
-                return Task.FromResult(new Maybe<TSource>(res));
+                return new ValueTask<Maybe<TSource>>(new Maybe<TSource>(res));
             }
 
-            return Task.FromResult(new Maybe<TSource>());
+            return new ValueTask<Maybe<TSource>>(new Maybe<TSource>());
         }
 
-        public Task<Maybe<TSource>> TryGetLastAsync(CancellationToken cancellationToken)
+        public ValueTask<Maybe<TSource>> TryGetLastAsync(CancellationToken cancellationToken)
         {
             var lastIndex = _source.Count - 1;
             if (lastIndex >= _minIndexInclusive)
             {
                 var res = _source[Math.Min(lastIndex, _maxIndexInclusive)];
-                return Task.FromResult(new Maybe<TSource>(res));
+                return new ValueTask<Maybe<TSource>>(new Maybe<TSource>(res));
             }
 
-            return Task.FromResult(new Maybe<TSource>());
+            return new ValueTask<Maybe<TSource>>(new Maybe<TSource>());
         }
 
         private int Count

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

@@ -32,20 +32,20 @@ namespace System.Linq
         /// <param name="index">The 0-based index to access.</param>
         /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
         /// <returns>The element if found, otherwise, the default value of <see cref="Maybe{TElement}"/>.</returns>
-        Task<Maybe<TElement>> TryGetElementAsync(int index, CancellationToken cancellationToken);
+        ValueTask<Maybe<TElement>> TryGetElementAsync(int index, CancellationToken cancellationToken);
 
         /// <summary>
         /// Gets the first item in this sequence.
         /// </summary>
         /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
         /// <returns>The element if found, otherwise, the default value of <see cref="Maybe{TElement}"/>.</returns>
-        Task<Maybe<TElement>> TryGetFirstAsync(CancellationToken cancellationToken);
+        ValueTask<Maybe<TElement>> TryGetFirstAsync(CancellationToken cancellationToken);
 
         /// <summary>
         /// Gets the last item in this sequence.
         /// </summary>
         /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
         /// <returns>The element if found, otherwise, the default value of <see cref="Maybe{TElement}"/>.</returns>
-        Task<Maybe<TElement>> TryGetLastAsync(CancellationToken cancellationToken);
+        ValueTask<Maybe<TElement>> TryGetLastAsync(CancellationToken cancellationToken);
     }
 }

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

@@ -34,11 +34,11 @@ namespace System.Linq
 
             public Task<List<TValue>> ToListAsync(CancellationToken cancellationToken) => Task.FromResult(new List<TValue>());
 
-            public Task<Maybe<TValue>> TryGetElementAsync(int index, CancellationToken cancellationToken) => Task.FromResult(new Maybe<TValue>());
+            public ValueTask<Maybe<TValue>> TryGetElementAsync(int index, CancellationToken cancellationToken) => new ValueTask<Maybe<TValue>>(new Maybe<TValue>());
 
-            public Task<Maybe<TValue>> TryGetFirstAsync(CancellationToken cancellationToken) => Task.FromResult(new Maybe<TValue>());
+            public ValueTask<Maybe<TValue>> TryGetFirstAsync(CancellationToken cancellationToken) => new ValueTask<Maybe<TValue>>(new Maybe<TValue>());
 
-            public Task<Maybe<TValue>> TryGetLastAsync(CancellationToken cancellationToken) => Task.FromResult(new Maybe<TValue>());
+            public ValueTask<Maybe<TValue>> TryGetLastAsync(CancellationToken cancellationToken) => new ValueTask<Maybe<TValue>>(new Maybe<TValue>());
 
             public ValueTask<bool> MoveNextAsync() => new ValueTask<bool>(false);
 

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

@@ -87,13 +87,13 @@ namespace System.Linq
             return first.HasValue ? first.Value : default;
         }
 
-        private static Task<Maybe<TSource>> TryGetFirst<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        private static ValueTask<Maybe<TSource>> TryGetFirst<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source is IList<TSource> list)
             {
                 if (list.Count > 0)
                 {
-                    return Task.FromResult(new Maybe<TSource>(list[0]));
+                    return new ValueTask<Maybe<TSource>>(new Maybe<TSource>(list[0]));
                 }
             }
             else if (source is IAsyncPartition<TSource> p)
@@ -104,7 +104,7 @@ namespace System.Linq
             {
                 return Core();
 
-                async Task<Maybe<TSource>> Core()
+                async ValueTask<Maybe<TSource>> Core()
                 {
                     var e = source.GetAsyncEnumerator(cancellationToken);
 
@@ -124,7 +124,7 @@ namespace System.Linq
                 }
             }
 
-            return Task.FromResult(new Maybe<TSource>());
+            return new ValueTask<Maybe<TSource>>(new Maybe<TSource>());
         }
 
         private static async Task<Maybe<TSource>> TryGetFirst<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)

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

@@ -87,14 +87,14 @@ namespace System.Linq
             return last.HasValue ? last.Value : default;
         }
 
-        private static Task<Maybe<TSource>> TryGetLast<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        private static ValueTask<Maybe<TSource>> TryGetLast<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source is IList<TSource> list)
             {
                 var count = list.Count;
                 if (count > 0)
                 {
-                    return Task.FromResult(new Maybe<TSource>(list[count - 1]));
+                    return new ValueTask<Maybe<TSource>>(new Maybe<TSource>(list[count - 1]));
                 }
             }
             else if (source is IAsyncPartition<TSource> p)
@@ -105,7 +105,7 @@ namespace System.Linq
             {
                 return Core();
 
-                async Task<Maybe<TSource>> Core()
+                async ValueTask<Maybe<TSource>> Core()
                 {
                     var last = default(TSource);
                     var hasLast = false;
@@ -129,7 +129,7 @@ namespace System.Linq
                 }
             }
 
-            return Task.FromResult(new Maybe<TSource>());
+            return new ValueTask<Maybe<TSource>>(new Maybe<TSource>());
         }
 
         private static async Task<Maybe<TSource>> TryGetLast<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)

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

@@ -93,19 +93,19 @@ namespace System.Linq
                 return Task.FromResult(res);
             }
 
-            public Task<Maybe<int>> TryGetElementAsync(int index, CancellationToken cancellationToken)
+            public ValueTask<Maybe<int>> TryGetElementAsync(int index, CancellationToken cancellationToken)
             {
                 if ((uint)index < (uint)(_end - _start))
                 {
-                    return Task.FromResult(new Maybe<int>(_start + index));
+                    return new ValueTask<Maybe<int>>(new Maybe<int>(_start + index));
                 }
 
-                return Task.FromResult(new Maybe<int>());
+                return new ValueTask<Maybe<int>>(new Maybe<int>());
             }
 
-            public Task<Maybe<int>> TryGetFirstAsync(CancellationToken cancellationToken) => Task.FromResult(new Maybe<int>(_start));
+            public ValueTask<Maybe<int>> TryGetFirstAsync(CancellationToken cancellationToken) => new ValueTask<Maybe<int>>(new Maybe<int>(_start));
 
-            public Task<Maybe<int>> TryGetLastAsync(CancellationToken cancellationToken) => Task.FromResult(new Maybe<int>(_end - 1));
+            public ValueTask<Maybe<int>> TryGetLastAsync(CancellationToken cancellationToken) => new ValueTask<Maybe<int>>(new Maybe<int>(_end - 1));
 
             protected override async ValueTask<bool> MoveNextCore()
             {