A few small optimizations.

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

@@ -87,37 +87,44 @@ namespace System.Linq
             return first.HasValue ? first.Value : default;
         }
 
-        private static async Task<Maybe<TSource>> TryGetFirst<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        private static Task<Maybe<TSource>> TryGetFirst<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source is IList<TSource> list)
             {
                 if (list.Count > 0)
                 {
-                    return new Maybe<TSource>(list[0]);
+                    return Task.FromResult(new Maybe<TSource>(list[0]));
                 }
             }
             else if (source is IAsyncPartition<TSource> p)
             {
-                return await p.TryGetFirstAsync(cancellationToken).ConfigureAwait(false);
+                return p.TryGetFirstAsync(cancellationToken);
             }
             else
             {
-                var e = source.GetAsyncEnumerator(cancellationToken);
+                return Core();
 
-                try
+                async Task<Maybe<TSource>> Core()
                 {
-                    if (await e.MoveNextAsync().ConfigureAwait(false))
+                    var e = source.GetAsyncEnumerator(cancellationToken);
+
+                    try
                     {
-                        return new Maybe<TSource>(e.Current);
+                        if (await e.MoveNextAsync().ConfigureAwait(false))
+                        {
+                            return new Maybe<TSource>(e.Current);
+                        }
                     }
-                }
-                finally
-                {
-                    await e.DisposeAsync().ConfigureAwait(false);
+                    finally
+                    {
+                        await e.DisposeAsync().ConfigureAwait(false);
+                    }
+
+                    return new Maybe<TSource>();
                 }
             }
 
-            return new Maybe<TSource>();
+            return Task.FromResult(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,47 +87,49 @@ namespace System.Linq
             return last.HasValue ? last.Value : default;
         }
 
-        private static async Task<Maybe<TSource>> TryGetLast<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        private static Task<Maybe<TSource>> TryGetLast<TSource>(IAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
         {
             if (source is IList<TSource> list)
             {
                 var count = list.Count;
                 if (count > 0)
                 {
-                    return new Maybe<TSource>(list[count - 1]);
+                    return Task.FromResult(new Maybe<TSource>(list[count - 1]));
                 }
             }
             else if (source is IAsyncPartition<TSource> p)
             {
-                return await p.TryGetLastAsync(cancellationToken).ConfigureAwait(false);
+                return p.TryGetLastAsync(cancellationToken);
             }
             else
             {
-                var last = default(TSource);
-                var hasLast = false;
+                return Core();
 
-                var e = source.GetAsyncEnumerator(cancellationToken);
-
-                try
+                async Task<Maybe<TSource>> Core()
                 {
-                    while (await e.MoveNextAsync().ConfigureAwait(false))
+                    var last = default(TSource);
+                    var hasLast = false;
+
+                    var e = source.GetAsyncEnumerator(cancellationToken);
+
+                    try
                     {
-                        hasLast = true;
-                        last = e.Current;
+                        while (await e.MoveNextAsync().ConfigureAwait(false))
+                        {
+                            hasLast = true;
+                            last = e.Current;
+                        }
+                    }
+                    finally
+                    {
+                        await e.DisposeAsync().ConfigureAwait(false);
                     }
-                }
-                finally
-                {
-                    await e.DisposeAsync().ConfigureAwait(false);
-                }
 
-                if (hasLast)
-                {
-                    return new Maybe<TSource>(last);
+                    return hasLast ? new Maybe<TSource>(last) : new Maybe<TSource>();
                 }
             }
 
-            return new Maybe<TSource>();
+            return Task.FromResult(new Maybe<TSource>());
         }
 
         private static async Task<Maybe<TSource>> TryGetLast<TSource>(IAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)