diff --git a/Benchmarks/Benchmarks.cs b/Benchmarks/Benchmarks.cs
index e915aca..d179406 100644
--- a/Benchmarks/Benchmarks.cs
+++ b/Benchmarks/Benchmarks.cs
@@ -193,17 +193,17 @@ public void Setup()
         //    return intArray.SumF(x => x / 2);
         //}
 
-        [Benchmark]
-        public double IntReadOnlyArraySumWithSelectLinq()
-        {
-            return Array.AsReadOnly(intArray).Sum(x => x / 2);
-        }
+        //[Benchmark]
+        //public double IntReadOnlyArraySumWithSelectLinq()
+        //{
+        //    return Array.AsReadOnly(intArray).Sum(x => x / 2);
+        //}
 
-        [Benchmark]
-        public double IntReadOnlyArraySumWithSelectFast()
-        {
-            return Array.AsReadOnly(intArray).SumF(x => x / 2);
-        }
+        //[Benchmark]
+        //public double IntReadOnlyArraySumWithSelectFast()
+        //{
+        //    return Array.AsReadOnly(intArray).SumF(x => x / 2);
+        //}
 
         //[Benchmark]
         //public int IntArraySumFastSIMD()
@@ -211,29 +211,29 @@ public double IntReadOnlyArraySumWithSelectFast()
         //    return intArray.SumS();
         //}
 
-        [Benchmark]
-        public int? IntNullArraySumLinq()
-        {
-            return intNullArray.Sum();
-        }
+        //[Benchmark]
+        //public int? IntNullArraySumLinq()
+        //{
+        //    return intNullArray.Sum();
+        //}
 
-        [Benchmark]
-        public int? IntNullArraySumFast()
-        {
-            return intNullArray.SumF();
-        }
+        //[Benchmark]
+        //public int? IntNullArraySumFast()
+        //{
+        //    return intNullArray.SumF();
+        //}
 
-        [Benchmark]
-        public int IntNullArraySumLinqSelect()
-        {
-            return intNullArray.Sum(x => x/2 ?? 0);
-        }
+        //[Benchmark]
+        //public int IntNullArraySumLinqSelect()
+        //{
+        //    return intNullArray.Sum(x => x/2 ?? 0);
+        //}
 
-        [Benchmark]
-        public int IntNullArraySumFastSelect()
-        {
-            return intNullArray.SumF(x => x/2 ?? 0);
-        }
+        //[Benchmark]
+        //public int IntNullArraySumFastSelect()
+        //{
+        //    return intNullArray.SumF(x => x/2 ?? 0);
+        //}
 
         //[Benchmark]
         //public float FloatArraySumLinq()
@@ -271,29 +271,29 @@ public int IntNullArraySumFastSelect()
         //    return floatArray.SumF(x => x / 2);
         //}
 
-        [Benchmark]
-        public float? FloatNullArraySumLinq()
-        {
-            return floatNullArray.Sum();
-        }
+        //[Benchmark]
+        //public float? FloatNullArraySumLinq()
+        //{
+        //    return floatNullArray.Sum();
+        //}
 
-        [Benchmark]
-        public float? FloatNullArraySumFast()
-        {
-            return floatNullArray.SumF();
-        }
+        //[Benchmark]
+        //public float? FloatNullArraySumFast()
+        //{
+        //    return floatNullArray.SumF();
+        //}
 
-        [Benchmark]
-        public float FloatNullArraySumLinqSelect()
-        {
-            return floatNullArray.Sum(x => x / 2 ?? 0);
-        }
+        //[Benchmark]
+        //public float FloatNullArraySumLinqSelect()
+        //{
+        //    return floatNullArray.Sum(x => x / 2 ?? 0);
+        //}
 
-        [Benchmark]
-        public float FloatNullArraySumFastSelect()
-        {
-            return floatNullArray.SumF(x => x / 2 ?? 0);
-        }
+        //[Benchmark]
+        //public float FloatNullArraySumFastSelect()
+        //{
+        //    return floatNullArray.SumF(x => x / 2 ?? 0);
+        //}
 
 
         //[Benchmark]
@@ -332,41 +332,41 @@ public float FloatNullArraySumFastSelect()
         //    return doubleArray.SumF(x => x / 2);
         //}
 
-        [Benchmark]
-        public double? DoubleNullArraySumLinq()
-        {
-            return doubleNullArray.Sum();
-        }
+        //[Benchmark]
+        //public double? DoubleNullArraySumLinq()
+        //{
+        //    return doubleNullArray.Sum();
+        //}
 
-        [Benchmark]
-        public double? DoubleNullArraySumFast()
-        {
-            return doubleNullArray.SumF();
-        }
+        //[Benchmark]
+        //public double? DoubleNullArraySumFast()
+        //{
+        //    return doubleNullArray.SumF();
+        //}
 
-        [Benchmark]
-        public double? DoubleNullArraySumLinqSelect()
-        {
-            return doubleNullArray.Sum(x => x / 2 ?? 0);
-        }
+        //[Benchmark]
+        //public double? DoubleNullArraySumLinqSelect()
+        //{
+        //    return doubleNullArray.Sum(x => x / 2 ?? 0);
+        //}
 
-        [Benchmark]
-        public double? DoubleNullArraySumFastSelect()
-        {
-            return doubleNullArray.SumF(x => x / 2 ?? 0);
-        }
+        //[Benchmark]
+        //public double? DoubleNullArraySumFastSelect()
+        //{
+        //    return doubleNullArray.SumF(x => x / 2 ?? 0);
+        //}
 
-        [Benchmark]
-        public double IntArrayAverageLinq()
-        {
-            return intArray.Average();
-        }
+        //[Benchmark]
+        //public double IntArrayAverageLinq()
+        //{
+        //    return intArray.Average();
+        //}
 
-        [Benchmark]
-        public double IntArrayAverageFast()
-        {
-            return intArray.AverageF();
-        }
+        //[Benchmark]
+        //public double IntArrayAverageFast()
+        //{
+        //    return intArray.AverageF();
+        //}
 
         //[Benchmark]
         //public double IntArrayAverageFastSIMD()
@@ -375,17 +375,17 @@ public double IntArrayAverageFast()
         //}
 
 
-        [Benchmark]
-        public double IntListAverageLinq()
-        {
-            return intList.Average();
-        }
+        //[Benchmark]
+        //public double IntListAverageLinq()
+        //{
+        //    return intList.Average();
+        //}
 
-        [Benchmark]
-        public double IntListAverageFast()
-        {
-            return intList.AverageF();
-        }
+        //[Benchmark]
+        //public double IntListAverageFast()
+        //{
+        //    return intList.AverageF();
+        //}
 
         //[Benchmark]
         //public double IntListAverageFastSIMD()
@@ -393,29 +393,29 @@ public double IntListAverageFast()
         //    return intList.AverageS();
         //}
 
-        [Benchmark]
-        public int IntListSumWithSelectLinq()
-        {
-            return intList.Sum(x => x / 2);
-        }
+        //[Benchmark]
+        //public int IntListSumWithSelectLinq()
+        //{
+        //    return intList.Sum(x => x / 2);
+        //}
 
-        [Benchmark]
-        public int IntListSumWithSelectFast()
-        {
-            return intList.SumF(x => x / 2);
-        }
+        //[Benchmark]
+        //public int IntListSumWithSelectFast()
+        //{
+        //    return intList.SumF(x => x / 2);
+        //}
 
-        [Benchmark]
-        public double IntReadOnlyListSumWithSelectLinq()
-        {
-            return intList.AsReadOnly().Sum(x => x / 2);
-        }
+        //[Benchmark]
+        //public double IntReadOnlyListSumWithSelectLinq()
+        //{
+        //    return intList.AsReadOnly().Sum(x => x / 2);
+        //}
 
-        [Benchmark]
-        public double IntReadOnlyListSumWithSelectFast()
-        {
-            return intList.AsReadOnly().SumF(x => x / 2);
-        }
+        //[Benchmark]
+        //public double IntReadOnlyListSumWithSelectFast()
+        //{
+        //    return intList.AsReadOnly().SumF(x => x / 2);
+        //}
 
 
         //private static readonly Func<double, int, double> mulXInts = (acc, x) => acc += x * x;
@@ -581,6 +581,89 @@ public double IntReadOnlyListSumWithSelectFast()
         //    return Array.AsReadOnly(intArray).FirstF(firstInts);
         //}
 
+        private static readonly Func<int, bool> LastInts = (x) => x > 0;
+
+        [Benchmark]
+        public double IntArrayLastLinq()
+        {
+            return intArray.Last(LastInts);
+        }
+
+        [Benchmark]
+        public double IntArrayLastFast()
+        {
+            return intArray.LastF(LastInts);
+        }
+
+        [Benchmark]
+        public double IntArrayLastFast1()
+        {
+            Predicate<int> predicate = new Predicate<int>(LastInts);
+            return Array.Find(intArray, predicate);
+        }
+
+
+        [Benchmark]
+        public double IntSpanLastForEach()
+        {
+            int[] localArray = intArray;
+            Span<int> asSpan = localArray.AsSpan();
+            foreach (int i in asSpan)
+            {
+                if (LastInts(i))
+                {
+                    return i;
+                }
+            }
+
+            return 0;
+        }
+
+        [Benchmark]
+        public double IntSpanLastFast()
+        {
+            int[] localArray = intArray;
+            Span<int> asSpan = localArray.AsSpan();
+            return asSpan.LastF(LastInts);
+        }
+
+        [Benchmark]
+        public double IntListLastLinq()
+        {
+            return intList.Last(LastInts);
+        }
+
+        [Benchmark]
+        public double IntListLastFast()
+        {
+            return intList.LastF(LastInts);
+        }
+
+        [Benchmark]
+        public double IntAsListReadOnlyLastLinq()
+        {
+            return intList.AsReadOnly().Last(LastInts);
+        }
+
+        [Benchmark]
+        public double IntAsListReadOnlyLastFast()
+        {
+            return intList.AsReadOnly().LastF(LastInts);
+        }
+
+        [Benchmark]
+        public double IntArrayAsReadOnlyLastLinq()
+        {
+            return Array.AsReadOnly(intArray).Last(LastInts);
+        }
+
+        [Benchmark]
+        public double IntArrayAsReadOnlyLastFast()
+        {
+            return Array.AsReadOnly(intArray).LastF(LastInts);
+        }
+
+
         //[Benchmark]
         //public double IntArrayWhereAggregateLinq()
         //{
diff --git a/LinqFaster/First.cs b/LinqFaster/First.cs
index 9153d37..95383b2 100644
--- a/LinqFaster/First.cs
+++ b/LinqFaster/First.cs
@@ -9,7 +9,6 @@ namespace JM.LinqFaster
 {
     public static partial class LinqFaster
     {
-
         // --------------------------  Arrays --------------------------------------------
 
         /// <summary>
@@ -68,6 +67,7 @@ public static T FirstF<T>(this T[] source, Func<T, bool> predicate)
         /// <param name="source">The array to return the first element of.</param>
         /// <returns>default value if source is empty, otherwise, the first element
         /// in source.</returns>        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T FirstOrDefaultF<T>(this T[] source)
         {
             if (source == null)
diff --git a/LinqFaster/Last.cs b/LinqFaster/Last.cs
index d6072e6..abe3632 100644
--- a/LinqFaster/Last.cs
+++ b/LinqFaster/Last.cs
@@ -1,5 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+
+// ReSharper disable ForCanBeConvertedToForeach
+// ReSharper disable UnusedMember.Global
 
 namespace JM.LinqFaster
 {
@@ -12,11 +17,12 @@ public static partial class LinqFaster
         /// </summary>        
         /// <param name="source">An sequence to return the last element of.</param>
         /// <returns>The value at the last position in the source sequence.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T LastF<T>(this T[] source)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
             if (source.Length == 0)
             {
@@ -31,24 +37,27 @@ public static T LastF<T>(this T[] source)
         /// <param name="source">A sequence to return an element from.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <returns></returns>       
-        public static T LastF<T>(this T[] source, Predicate<T> predicate)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this T[] source, Func<T, bool> predicate)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
 
             if (predicate == null)
             {
-                throw Error.ArgumentNull("predicate");
+                throw Error.ArgumentNull(nameof(predicate));
             }
 
-            var lastIndex = Array.FindLastIndex(source, predicate);
-
-            if (lastIndex == -1)
-                throw Error.NoMatch();
-            else
-                return source[lastIndex];
+            for (int i = source.Length - 1; i >= 0; i--)
+            {
+                if (predicate(source[i]))
+                {
+                    return source[i];
+                }
+            }
+            throw Error.NoMatch();
         }
 
         /// <summary>
@@ -57,11 +66,12 @@ public static T LastF<T>(this T[] source, Predicate<T> predicate)
         /// <param name="source">An sequence to return the last element of.</param>
         /// <returns>default value if the source sequence is empty; otherwise, 
         /// the last element in the sequence</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T LastOrDefaultF<T>(this T[] source)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
             if (source.Length == 0)
             {
@@ -78,134 +88,155 @@ public static T LastOrDefaultF<T>(this T[] source)
         /// <returns>default value if the sequence is empty or if no elements pass the test 
         /// in the predicate function; otherwise, the last element that passes the test in the 
         /// predicate function.</returns>
-        public static T LastOrDefaultF<T>(this T[] source, Predicate<T> predicate)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastOrDefaultF<T>(this T[] source, Func<T, bool> predicate)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
 
             if (predicate == null)
             {
-                throw Error.ArgumentNull("predicate");
+                throw Error.ArgumentNull(nameof(predicate));
             }
 
-            var lastIndex = Array.FindLastIndex(source, predicate);
-
-            if (lastIndex == -1)
-                return default(T);
-            else
-                return source[lastIndex];
+            for (int i = source.Length - 1; i >= 0; i--)
+            {
+                if (predicate(source[i]))
+                {
+                    return source[i];
+                }
+            }
+            return default(T);
         }
 
-        // --------------------------  this Spans --------------------------------------------
+
 
         /// <summary>
-        /// Returns the last element of a sequence.
+        /// Returns the first element of an Array / List / IReadOnlyList.
         /// </summary>        
-        /// <param name="source">An sequence to return the last element of.</param>
-        /// <returns>The value at the last position in the source sequence.</returns>
-        public static T LastF<T>(this Span<T> source)
+        /// <param name="source">The array to return the first element of.</param>
+        /// <returns>The first element in the specified array.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this IReadOnlyList<T> source)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
-            if (source.Length == 0)
+            if (source.Count == 0)
             {
                 throw Error.NoElements();
             }
-            return source[source.Length - 1];
+            return source[source.Count - 1];
         }
 
         /// <summary>
-        /// Returns the last element of a sequence that satisfies a specified condition.
+        /// Returns the first element in an array / List / IReadOnlyList that satisfies a specified condition.
         /// </summary>        
-        /// <param name="source">A sequence to return an element from.</param>
+        /// <param name="source">An IReadOnlyList to return an element from.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
-        /// <returns></returns>       
-        public static T LastF<T>(this Span<T> source, Predicate<T> predicate)
+        /// <returns>The first element that satisfies the condition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this IReadOnlyList<T> source, Func<T, bool> predicate)
         {
-            if (source == null)
-            {
-                throw Error.ArgumentNull("source");
-            }
-
             if (predicate == null)
             {
-                throw Error.ArgumentNull("predicate");
+                throw Error.ArgumentNull(nameof(predicate));
             }
 
-            for (int i = source.Length - 1; i >= 0; i--)
+            switch (source)
             {
-                if (predicate(source[i])) return source[i];
+                case null:
+                    throw Error.ArgumentNull(nameof(source));
+                case T[] sa:
+                    return sa.LastF(predicate);
+                default:
+                    for (int i = source.Count - 1; i >= 0; i--)
+                    {
+                        if (predicate(source[i]))
+                        {
+                            return source[i];
+                        }
+                    }
+
+                    break;
             }
-            
-            throw Error.NoMatch();
 
+            throw Error.NoMatch();
         }
 
         /// <summary>
-        /// Returns the last element of a sequence, or a default value if the sequence contains no elements.
-        /// </summary>        
-        /// <param name="source">An sequence to return the last element of.</param>
-        /// <returns>default value if the source sequence is empty; otherwise, 
-        /// the last element in the sequence</returns>
-        public static T LastOrDefaultF<T>(this Span<T> source)
+        /// Returns the first element of an array, or a default value if the
+        /// array contains no elements.
+        /// </summary>             
+        /// <param name="source">The array to return the first element of.</param>
+        /// <returns>default value if source is empty, otherwise, the first element
+        /// in source.</returns>        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastOrDefaultF<T>(this IReadOnlyList<T> source)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
-            if (source.Length == 0)
+            if (source.Count == 0)
             {
                 return default(T);
             }
-            return source[source.Length - 1];
+            return source[source.Count - 1];
         }
 
         /// <summary>
-        /// Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
+        /// Returns the first element of the sequence that satisfies a condition or a 
+        /// default value if no such element is found.
         /// </summary>        
-        /// <param name="source">A sequence to return the last element of.</param>
+        /// <param name="source">An IEnumerable to return an element from.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
-        /// <returns>default value if the sequence is empty or if no elements pass the test 
-        /// in the predicate function; otherwise, the last element that passes the test in the 
-        /// predicate function.</returns>
-        public static T LastOrDefaultF<T>(this Span<T> source, Predicate<T> predicate)
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [Pure]
+        public static T LastOrDefaultF<T>(this IReadOnlyList<T> source, Func<T, bool> predicate)
         {
-            if (source == null)
-            {
-                throw Error.ArgumentNull("source");
-            }
-
             if (predicate == null)
             {
-                throw Error.ArgumentNull("predicate");
+                throw Error.ArgumentNull(nameof(predicate));
             }
-            
-            for (int i = source.Length - 1; i >= 0; i--)
+
+            switch (source)
             {
-                if (predicate(source[i])) return source[i];
+                case null:
+                    throw Error.ArgumentNull(nameof(source));
+                case T[] sa:
+                    return sa.LastOrDefaultF(predicate);
+                default:
+                    for (int i = source.Count - 1; i >= 0; i--)
+                    {
+                        if (predicate(source[i]))
+                        {
+                            return source[i];
+                        }
+                    }
+                    break;
             }
 
-            
             return default(T);
-            
         }
 
         // --------------------------  Lists --------------------------------------------
 
         /// <summary>
-        /// Returns the last element of a sequence.
+        /// Returns the first element of a list
         /// </summary>        
-        /// <param name="source">An sequence to return the last element of.</param>
-        /// <returns>The value at the last position in the source sequence.</returns>
+        /// <param name="source">The list to return the first element of.</param>
+        /// <returns>The first element in the specified list.</returns>   
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T LastF<T>(this List<T> source)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
             if (source.Count == 0)
             {
@@ -215,42 +246,48 @@ public static T LastF<T>(this List<T> source)
         }
 
         /// <summary>
-        /// Returns the last element of a sequence that satisfies a specified condition.
+        /// Returns the first element in a list that satisfies a specified condition.
         /// </summary>        
-        /// <param name="source">A sequence to return an element from.</param>
+        /// <param name="source">An list to return an element from.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
-        /// <returns></returns>
+        /// <returns>The first element in the list that satisfies the condition.</returns>       
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T LastF<T>(this List<T> source, Predicate<T> predicate)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
 
             if (predicate == null)
             {
-                throw Error.ArgumentNull("predicate");
+                throw Error.ArgumentNull(nameof(predicate));
             }
 
-            var lastIndex = source.FindLastIndex(predicate);
+            for (int i = source.Count - 1; i >= 0; i--)
+            {
+                if (predicate(source[i]))
+                {
+                    return source[i];
+                }
+            }
 
-            if (lastIndex == -1)
-                throw Error.NoMatch();
-            else
-                return source[lastIndex];
+            throw Error.NoMatch();
         }
 
         /// <summary>
-        /// Returns the last element of a sequence, or a default value if the sequence contains no elements.
-        /// </summary>        
-        /// <param name="source">An sequence to return the last element of.</param>
-        /// <returns>default value if the source sequence is empty; otherwise, 
-        /// the last element in the sequence</returns>        
+        /// Returns the first element of an array, or a default value if the
+        /// array contains no elements.
+        /// </summary>             
+        /// <param name="source">The array to return the first element of.</param>
+        /// <returns>default value if source is empty, otherwise, the first element
+        /// in source.</returns>      
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T LastOrDefaultF<T>(this List<T> source)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
             if (source.Count == 0)
             {
@@ -260,31 +297,240 @@ public static T LastOrDefaultF<T>(this List<T> source)
         }
 
         /// <summary>
-        /// Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
+        /// Returns the first element of the sequence that satisfies a condition or a 
+        /// default value if no such element is found.
         /// </summary>        
-        /// <param name="source">A sequence to return the last element of.</param>
+        /// <param name="source">An IEnumerable to return an element from.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
-        /// <returns>default value if the sequence is empty or if no elements pass the test 
-        /// in the predicate function; otherwise, the last element that passes the test in the 
-        /// predicate function.</returns>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T LastOrDefaultF<T>(this List<T> source, Predicate<T> predicate)
         {
             if (source == null)
             {
-                throw Error.ArgumentNull("source");
+                throw Error.ArgumentNull(nameof(source));
             }
 
             if (predicate == null)
             {
-                throw Error.ArgumentNull("predicate");
+                throw Error.ArgumentNull(nameof(predicate));
             }
 
-            var lastIndex = source.FindLastIndex(predicate);
+            for (int i = source.Count - 1; i >= 0; i--)
+            {
+                if (predicate(source[i]))
+                {
+                    return source[i];
+                }
+            }
+            return default(T);
+        }
+
+        // --------------------------  Span --------------------------------------------
+        #region Normal Span
+        /// <summary>
+        /// Returns the first element of an Span.
+        /// </summary>        
+        /// <param name="source">The Span to return the first element of.</param>
+        /// <returns>The first element in the specified array.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this Span<T> source)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+            if (source.Length == 0)
+            {
+                throw Error.NoElements();
+            }
+            return source[source.Length - 1];
+        }
+
+        /// <summary>
+        /// Returns the first element in an Span that satisfies a specified condition.
+        /// </summary>        
+        /// <param name="source">An Span to return an element from.</param>
+        /// <param name="func">A function to test each element for a condition.</param>
+        /// <returns>The first element that satisfies the condition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this Span<T> source, Func<T, bool> func)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
 
-            if (lastIndex == -1)
+            if (func == null)
+            {
+                throw Error.ArgumentNull(nameof(func));
+            }
+
+            for (int i = source.Length - 1; i >= 0; i--)
+            {
+                if (func(source[i]))
+                {
+                    return source[i];
+                }
+            }
+
+            throw Error.NoMatch();
+        }
+
+        /// <summary>
+        /// Returns the first element of an Span, or a default value if the
+        /// array contains no elements.
+        /// </summary>             
+        /// <param name="source">The Span to return the first element of.</param>
+        /// <returns>default value if source is empty, otherwise, the first element
+        /// in source.</returns>        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastOrDefaultF<T>(this Span<T> source)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+            if (source.Length == 0)
+            {
                 return default(T);
-            else
-                return source[lastIndex];
+            }
+            return source[source.Length - 1];
+        }
+
+        /// <summary>
+        /// Returns the first element of the sequence that satisfies a condition or a 
+        /// default value if no such element is found.
+        /// </summary>        
+        /// <param name="source">An Span to return an element from.</param>
+        /// <param name="func">A function to test each element for a condition.</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastOrDefaultF<T>(this Span<T> source, Func<T, bool> func)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+
+            if (func == null)
+            {
+                throw Error.ArgumentNull(nameof(func));
+            }
+
+            for (int i = source.Length - 1; i >= 0; i--)
+            {
+                if (func(source[i]))
+                {
+                    return source[i];
+                }
+            }
+
+            return default(T);
+        }
+        #endregion Normal Span
+
+        #region ReadOnlySpan
+        /// <summary>
+        /// Returns the first element of an ReadOnlySpan.
+        /// </summary>        
+        /// <param name="source">The ReadOnlySpan to return the first element of.</param>
+        /// <returns>The first element in the specified array.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this ReadOnlySpan<T> source)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+            if (source.Length == 0)
+            {
+                throw Error.NoElements();
+            }
+            return source[source.Length - 1];
+        }
+
+        /// <summary>
+        /// Returns the first element in an ReadOnlySpan that satisfies a specified condition.
+        /// </summary>        
+        /// <param name="source">An ReadOnlySpan to return an element from.</param>
+        /// <param name="func">A function to test each element for a condition.</param>
+        /// <returns>The first element that satisfies the condition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastF<T>(this ReadOnlySpan<T> source, Func<T, bool> func)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+
+            if (func == null)
+            {
+                throw Error.ArgumentNull(nameof(func));
+            }
+
+            for (int i = source.Length - 1; i >= 0; i--)
+            {
+                if (func(source[i]))
+                {
+                    return source[i];
+                }
+            }
+
+            throw Error.NoMatch();
+        }
+
+        /// <summary>
+        /// Returns the first element of an ReadOnlySpan, or a default value if the
+        /// array contains no elements.
+        /// </summary>             
+        /// <param name="source">The ReadOnlySpan to return the first element of.</param>
+        /// <returns>default value if source is empty, otherwise, the first element
+        /// in source.</returns>        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastOrDefaultF<T>(this ReadOnlySpan<T> source)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+            if (source.Length == 0)
+            {
+                return default(T);
+            }
+            return source[source.Length - 1];
+        }
+
+        /// <summary>
+        /// Returns the first element of the sequence that satisfies a condition or a 
+        /// default value if no such element is found.
+        /// </summary>        
+        /// <param name="source">An ReadOnlySpan to return an element from.</param>
+        /// <param name="func">A function to test each element for a condition.</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T LastOrDefaultF<T>(this ReadOnlySpan<T> source, Func<T, bool> func)
+        {
+            if (source == null)
+            {
+                throw Error.ArgumentNull(nameof(source));
+            }
+
+            if (func == null)
+            {
+                throw Error.ArgumentNull(nameof(func));
+            }
+
+            for (int i = source.Length - 1; i >= 0; i--)
+            {
+                if (func(source[i]))
+                {
+                    return source[i];
+                }
+            }
+
+            return default(T);
         }
+        #endregion ReadOnlySpan
     }
 }
diff --git a/docs/linqfaster.xml b/docs/linqfaster.xml
index 1cb17f9..995556c 100644
--- a/docs/linqfaster.xml
+++ b/docs/linqfaster.xml
@@ -793,7 +793,7 @@
             <param name="source">An sequence to return the last element of.</param>
             <returns>The value at the last position in the source sequence.</returns>
         </member>
-        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(``0[],System.Predicate{``0})">
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(``0[],System.Func{``0,System.Boolean})">
             <summary>
             Returns the last element of a sequence that satisfies a specified condition.
             </summary>        
@@ -809,7 +809,7 @@
             <returns>default value if the source sequence is empty; otherwise, 
             the last element in the sequence</returns>
         </member>
-        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(``0[],System.Predicate{``0})">
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(``0[],System.Func{``0,System.Boolean})">
             <summary>
             Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
             </summary>        
@@ -819,71 +819,137 @@
             in the predicate function; otherwise, the last element that passes the test in the 
             predicate function.</returns>
         </member>
-        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Span{``0})">
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Collections.Generic.IReadOnlyList{``0})">
             <summary>
-            Returns the last element of a sequence.
+            Returns the first element of an Array / List / IReadOnlyList.
             </summary>        
-            <param name="source">An sequence to return the last element of.</param>
-            <returns>The value at the last position in the source sequence.</returns>
+            <param name="source">The array to return the first element of.</param>
+            <returns>The first element in the specified array.</returns>
         </member>
-        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Span{``0},System.Predicate{``0})">
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Collections.Generic.IReadOnlyList{``0},System.Func{``0,System.Boolean})">
             <summary>
-            Returns the last element of a sequence that satisfies a specified condition.
+            Returns the first element in an array / List / IReadOnlyList that satisfies a specified condition.
             </summary>        
-            <param name="source">A sequence to return an element from.</param>
+            <param name="source">An IReadOnlyList to return an element from.</param>
             <param name="predicate">A function to test each element for a condition.</param>
-            <returns></returns>       
+            <returns>The first element that satisfies the condition.</returns>
         </member>
-        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Span{``0})">
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Collections.Generic.IReadOnlyList{``0})">
             <summary>
-            Returns the last element of a sequence, or a default value if the sequence contains no elements.
-            </summary>        
-            <param name="source">An sequence to return the last element of.</param>
-            <returns>default value if the source sequence is empty; otherwise, 
-            the last element in the sequence</returns>
+            Returns the first element of an array, or a default value if the
+            array contains no elements.
+            </summary>             
+            <param name="source">The array to return the first element of.</param>
+            <returns>default value if source is empty, otherwise, the first element
+            in source.</returns>        
         </member>
-        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Span{``0},System.Predicate{``0})">
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Collections.Generic.IReadOnlyList{``0},System.Func{``0,System.Boolean})">
             <summary>
-            Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
+            Returns the first element of the sequence that satisfies a condition or a 
+            default value if no such element is found.
             </summary>        
-            <param name="source">A sequence to return the last element of.</param>
+            <param name="source">An IEnumerable to return an element from.</param>
             <param name="predicate">A function to test each element for a condition.</param>
-            <returns>default value if the sequence is empty or if no elements pass the test 
-            in the predicate function; otherwise, the last element that passes the test in the 
-            predicate function.</returns>
+            <returns></returns>
         </member>
         <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Collections.Generic.List{``0})">
             <summary>
-            Returns the last element of a sequence.
+            Returns the first element of a list
             </summary>        
-            <param name="source">An sequence to return the last element of.</param>
-            <returns>The value at the last position in the source sequence.</returns>
+            <param name="source">The list to return the first element of.</param>
+            <returns>The first element in the specified list.</returns>   
         </member>
         <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Collections.Generic.List{``0},System.Predicate{``0})">
             <summary>
-            Returns the last element of a sequence that satisfies a specified condition.
+            Returns the first element in a list that satisfies a specified condition.
             </summary>        
-            <param name="source">A sequence to return an element from.</param>
+            <param name="source">An list to return an element from.</param>
             <param name="predicate">A function to test each element for a condition.</param>
-            <returns></returns>
+            <returns>The first element in the list that satisfies the condition.</returns>       
         </member>
         <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Collections.Generic.List{``0})">
             <summary>
-            Returns the last element of a sequence, or a default value if the sequence contains no elements.
-            </summary>        
-            <param name="source">An sequence to return the last element of.</param>
-            <returns>default value if the source sequence is empty; otherwise, 
-            the last element in the sequence</returns>        
+            Returns the first element of an array, or a default value if the
+            array contains no elements.
+            </summary>             
+            <param name="source">The array to return the first element of.</param>
+            <returns>default value if source is empty, otherwise, the first element
+            in source.</returns>      
         </member>
         <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Collections.Generic.List{``0},System.Predicate{``0})">
             <summary>
-            Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
+            Returns the first element of the sequence that satisfies a condition or a 
+            default value if no such element is found.
             </summary>        
-            <param name="source">A sequence to return the last element of.</param>
+            <param name="source">An IEnumerable to return an element from.</param>
             <param name="predicate">A function to test each element for a condition.</param>
-            <returns>default value if the sequence is empty or if no elements pass the test 
-            in the predicate function; otherwise, the last element that passes the test in the 
-            predicate function.</returns>
+            <returns></returns>
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Span{``0})">
+            <summary>
+            Returns the first element of an Span.
+            </summary>        
+            <param name="source">The Span to return the first element of.</param>
+            <returns>The first element in the specified array.</returns>
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.Span{``0},System.Func{``0,System.Boolean})">
+            <summary>
+            Returns the first element in an Span that satisfies a specified condition.
+            </summary>        
+            <param name="source">An Span to return an element from.</param>
+            <param name="func">A function to test each element for a condition.</param>
+            <returns>The first element that satisfies the condition.</returns>
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Span{``0})">
+            <summary>
+            Returns the first element of an Span, or a default value if the
+            array contains no elements.
+            </summary>             
+            <param name="source">The Span to return the first element of.</param>
+            <returns>default value if source is empty, otherwise, the first element
+            in source.</returns>        
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.Span{``0},System.Func{``0,System.Boolean})">
+            <summary>
+            Returns the first element of the sequence that satisfies a condition or a 
+            default value if no such element is found.
+            </summary>        
+            <param name="source">An Span to return an element from.</param>
+            <param name="func">A function to test each element for a condition.</param>
+            <returns></returns>
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.ReadOnlySpan{``0})">
+            <summary>
+            Returns the first element of an ReadOnlySpan.
+            </summary>        
+            <param name="source">The ReadOnlySpan to return the first element of.</param>
+            <returns>The first element in the specified array.</returns>
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastF``1(System.ReadOnlySpan{``0},System.Func{``0,System.Boolean})">
+            <summary>
+            Returns the first element in an ReadOnlySpan that satisfies a specified condition.
+            </summary>        
+            <param name="source">An ReadOnlySpan to return an element from.</param>
+            <param name="func">A function to test each element for a condition.</param>
+            <returns>The first element that satisfies the condition.</returns>
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.ReadOnlySpan{``0})">
+            <summary>
+            Returns the first element of an ReadOnlySpan, or a default value if the
+            array contains no elements.
+            </summary>             
+            <param name="source">The ReadOnlySpan to return the first element of.</param>
+            <returns>default value if source is empty, otherwise, the first element
+            in source.</returns>        
+        </member>
+        <member name="M:JM.LinqFaster.LinqFaster.LastOrDefaultF``1(System.ReadOnlySpan{``0},System.Func{``0,System.Boolean})">
+            <summary>
+            Returns the first element of the sequence that satisfies a condition or a 
+            default value if no such element is found.
+            </summary>        
+            <param name="source">An ReadOnlySpan to return an element from.</param>
+            <param name="func">A function to test each element for a condition.</param>
+            <returns></returns>
         </member>
         <member name="M:JM.LinqFaster.LinqFaster.MaxF``1(``0[])">
             <summary>