Added @inlinable to most functions (and computed properties).

Also added @inline(__always) to some, where they're particularly trivial (e.g. just aliases, in essence, for another function).

Most of these functions probably aren't performance sensitive - though some are, so the benefit for them is most obvious - but even for those that aren't, being inlinable apparently allows the optimiser to make better decisions (like omitting redundant calls entirely) which could be an aid to reducing malloc activity.

Author: wadetregaskis

Sources/FoundationExtensions/AsyncSequence.swift

@@ -6,6 +6,7 @@ public extension AsyncSequence {
     ///   - terminator: A subsequence to look for, that will terminate collection.  Should not be empty.
     ///   - stripTerminator: Whether to include the terminator in the returned collection.
     /// - Returns: A collection of zero or more elements.
+    @inlinable
     func collect<C: RangeReplaceableCollection>(
         upTo terminator: some Collection<Element>,
         stripTerminator: Bool = true

Sources/FoundationExtensions/BidirectionalCollection.swift

@@ -9,6 +9,7 @@ public extension BidirectionalCollection {
     ///
     /// - Parameter transform: The transform to apply, returning a value if successful or nil otherwise.  This _must_ have a single transition point (where it goes from returning values to returning nil, for increasingly long prefixes), else the result is undefined.
     /// - Returns: The result of a transformation closure on the longest prefix for which the transform succeeds, or nil if there is no [non-empty] prefix for which this is the case.
+    @inlinable
     func longestPrefix<T>(where transform: (SubSequence) throws -> T?) rethrows -> T? {
         var lowerBound = self.startIndex
         var lowerBoundResult: T? = nil

Sources/FoundationExtensions/BinaryInteger.swift

@@ -6,6 +6,7 @@ public extension BinaryInteger {
     /// Returns the individual bits of the integer, split out into an array.
     ///
     /// Not to be confused with ``bitIndices``, which is similar but the resulting array has the index of each bit that is set in the integer (`self`), not the value of that bit.
+    @inlinable
     var bits: [Self] {
         var remainder = self
         var result = [Self]()
@@ -24,6 +25,7 @@ public extension BinaryInteger {
     /// Returns the indices of each `1` bit of the integer.
     ///
     /// Not to be confused with ``bits``, which is similar but the resulting array contains the component numbers themselves.
+    @inlinable
     var bitIndices: IndexSet {
         var remainder = self
         var result = IndexSet()

Sources/FoundationExtensions/CollectionOfUInt8.swift

@@ -58,6 +58,8 @@ public extension Collection where Element == UInt8 {
     /// An ASCII representation of the given collection's ``UInt8`` contents, in uppercase and without any spaces.
     ///
     /// This is equivalent to calling ``asHexString(uppercase:delimiterEvery:delimiter:)`` with default arguments.  It is provided as a convenience so that the parentheses may be omitted.
+    @inlinable
+    @inline(__always)
     var asHexString: String {
         asHexString()
     }

Sources/FoundationExtensions/Comparable.swift

@@ -4,6 +4,7 @@ extension Comparable {
     /// Conforms the value to the given range.
     ///
     /// i.e. if it is below the range's lower bound, it is set to that lower bound.  Otherwise it is not modified.
+    @inlinable
     mutating func clamp(_ range: PartialRangeFrom<Self>) {
         if self < range.lowerBound {
             self = range.lowerBound
@@ -13,6 +14,7 @@ extension Comparable {
     /// Returns the value conformed to the given range.
     ///
     /// i.e. if it is below the range's lower bound, that lower bound is returned instead.  Otherwise it is returned as-is.
+    @inlinable
     func clamped(_ range: PartialRangeFrom<Self>) -> Self {
         if self < range.lowerBound {
             range.lowerBound
@@ -24,6 +26,7 @@ extension Comparable {
     /// Conforms the value to the given range.
     ///
     /// i.e. if it is above the range's upper bound, it is set to that upper bound.  Otherwise it is not modified.
+    @inlinable
     mutating func clamp(_ range: PartialRangeThrough<Self>) {
         if self > range.upperBound {
             self = range.upperBound
@@ -33,6 +36,7 @@ extension Comparable {
     /// Returns the value conformed to the given range.
     ///
     /// i.e. if it is above the range's upper bound, that upper bound is returned instead.  Otherwise it is returned as-is.
+    @inlinable
     func clamped(_ range: PartialRangeThrough<Self>) -> Self {
         if self > range.upperBound {
             range.upperBound
@@ -48,6 +52,7 @@ extension Comparable {
     /// If it is above the range's upper bound, it is set to that upper bound.
     ///
     /// Otherwise it is not modified.
+    @inlinable
     mutating func clamp(_ range: ClosedRange<Self>) {
         if self < range.lowerBound {
             self = range.lowerBound
@@ -63,6 +68,7 @@ extension Comparable {
     /// If it is above the range's upper bound, that upper bound is returned instead.
     ///
     /// Otherwise it is returned as-is.
+    @inlinable
     func clamped(_ range: ClosedRange<Self>) -> Self {
         if self < range.lowerBound {
             range.lowerBound
@@ -82,6 +88,7 @@ extension Comparable where Self: Strideable {
     /// If it is above the range's upper bound, it is set to that upper bound.
     ///
     /// Otherwise it is not modified.
+    @inlinable
     mutating func clamp(_ range: Range<Self>) {
         if self < range.lowerBound {
             self = range.lowerBound
@@ -97,6 +104,7 @@ extension Comparable where Self: Strideable {
     /// If it is above the range's upper bound, that upper bound is returned instead.
     ///
     /// Otherwise it is returned as-is.
+    @inlinable
     func clamped(_ range: Range<Self>) -> Self {
         if self < range.lowerBound {
             range.lowerBound
@@ -110,6 +118,7 @@ extension Comparable where Self: Strideable {
     /// Conforms the value to the given range.
     ///
     /// i.e. if it is above the range's upper bound, it is set to that upper bound.  Otherwise it is not modified.
+    @inlinable
     mutating func clamp(_ range: PartialRangeUpTo<Self>) {
         if self >= range.upperBound {
             self = range.upperBound.advanced(by: -1)
@@ -119,6 +128,7 @@ extension Comparable where Self: Strideable {
     /// Returns the value conformed to the given range.
     ///
     /// i.e. if it is above the range's upper bound, that upper bound is returned instead.  Otherwise it is returned as-is.
+    @inlinable
     func clamped(_ range: PartialRangeUpTo<Self>) -> Self {
         if self >= range.upperBound {
             range.upperBound.advanced(by: -1)

Sources/FoundationExtensions/Data.swift

@@ -7,11 +7,15 @@ public extension Data {
     /// A convenience wrapper over ``String(data:encoding:)``, to make it usable with optional chaining.
     /// - Parameter encoding: The encoding method that the data should be compliant with.
     /// - Returns: The decoded string, or nil if the data is not compliant with the given string encoding.
+    @inlinable
+    @inline(__always)
     func asString(encoding: String.Encoding) -> String? {
         String(data: self, encoding: encoding)
     }
 
     // The data as a valid UTF-8 string, or nil if the data is not a valid UTF-8 string.
+    @inlinable
+    @inline(__always)
     var asString: String? {
         asString(encoding: .utf8)
     }

Sources/FoundationExtensions/Date.swift

@@ -4,7 +4,8 @@
 import Foundation
 
 public extension Date {
-    private static let relativeDateTimeFormatter = {
+    @usableFromInline
+    internal static let relativeDateTimeFormatter = {
         var formatter = RelativeDateTimeFormatter()
         formatter.dateTimeStyle = .named
         formatter.unitsStyle = .full
@@ -15,6 +16,7 @@ public extension Date {
     /// Returns a human-readable, localised description of how long ago the date was, e.g. "2 hours ago".
     ///
     /// The description may be approximate, typically limited to only the first significant date & time component (e.g. just "2 hours ago" for deltas ranging from 1.5 to 2.5 hours ago).
+    @inlinable
     var timeAgo: String {
         Date.relativeDateTimeFormatter.localizedString(for: self, relativeTo: Date.now)
     }

Sources/FoundationExtensions/IteratorProtocol.swift

@@ -4,13 +4,17 @@ public extension IteratorProtocol {
     /// Returns a type-erased version of the iterator (an `AnyIterator`).
     ///
     /// This is a 'convenience' property to make `AnyIterator` more accessible, such as when using optional chaining.
+    @inlinable
+    @inline(__always)
     var typeErased: AnyIterator<Element> {
         AnyIterator(self)
     }
 
     /// Returns an async iterator wrapper over the iterator.
     ///
     /// Be careful in how you use this - Swift Concurrency contexts (async functions, inside Tasks, etc) basically do not support blocking code (their performance suffers, and it can lead to deadlock).  You should only use this for iterators that do not block (i.e. do not do any I/O, do not take any locks, etc), such as simple enumeration of `Array`s and the like.
+    @inlinable
+    @inline(__always)
     var async: AsyncIteratorOverSyncIterator<Self> {
         AsyncIteratorOverSyncIterator(self)
     }
@@ -22,12 +26,17 @@ public extension IteratorProtocol {
 public struct AsyncIteratorOverSyncIterator<I: IteratorProtocol>: AsyncIteratorProtocol {
     public typealias Element = I.Element
 
-    private var source: I
+    @usableFromInline
+    internal var source: I
 
+    @inlinable
+    @inline(__always)
     public mutating func next() async -> I.Element? {
         source.next()
     }
 
+    @inlinable
+    @inline(__always)
     public init(_ source: I) {
         self.source = source
     }

Sources/FoundationExtensions/Locale.swift

@@ -5,6 +5,8 @@ import Foundation
 
 public extension Locale {
     /// The POSIX locale (en\_US\_POSIX).
+    @inlinable
+    @inline(__always)
     static var POSIX: Locale {
         Locale(identifier: "en_US_POSIX")
     }

Sources/FoundationExtensions/Optional.swift

@@ -5,6 +5,7 @@ import Foundation
 
 public extension Optional {
     /// Returns the description (from ``String(describing:)``) of the value if it is non-nil, else the string "nil".
+    @inlinable
     var orNilString: String {
         if let value = self {
             return String(describing: value)
@@ -16,6 +17,8 @@ public extension Optional {
 
 public extension Optional where Wrapped == String {
     /// Returns the string if it is non-nil, else the string "nil".
+    @inlinable
+    @inline(__always)
     var orNilString: String {
         if let self {
             return self