diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9c1f155..9f71a8e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,5 +2,6 @@
 
 - [SwiftLint](https://github.com/realm/SwiftLint) with a .swiftlint.yml file. lint checks are done on CI
 - `Sendable` conformance to `Version` to satisfy build warnings when complete concurrency checks are enabled
+- [SwiftFormat](https://github.com/nicklockwood/SwiftFormat/tree/main) with a format file. lint checks are done on CI
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
diff --git a/Package.swift b/Package.swift
index 2a8c143..e99e927 100644
--- a/Package.swift
+++ b/Package.swift
@@ -16,8 +16,8 @@ let package = Package(
             name: "VersionCompare",
             targets: [
                 "VersionCompare"
-                ]
-        ),
+            ]
+        )
     ],
     targets: [
         .target(
@@ -31,8 +31,8 @@ let package = Package(
             name: "VersionCompareTests",
             dependencies: [
                 "VersionCompare"
-                ]
-        ),
+            ]
+        )
     ],
     swiftLanguageVersions: [.v5]
 )
diff --git a/Sources/Helper/Character+Extensions.swift b/Sources/Helper/Character+Extensions.swift
index 405eaa5..54a31ba 100644
--- a/Sources/Helper/Character+Extensions.swift
+++ b/Sources/Helper/Character+Extensions.swift
@@ -5,7 +5,7 @@
 //  Created by Marius Felkner on 30.03.21.
 //
 
-internal extension Character {
+extension Character {
     var isZero: Bool {
         if self == "0" {
             return true
diff --git a/Sources/Helper/String+Regex.swift b/Sources/Helper/String+Regex.swift
index dc6dee9..9b29fb7 100644
--- a/Sources/Helper/String+Regex.swift
+++ b/Sources/Helper/String+Regex.swift
@@ -5,7 +5,7 @@
 //  Created by Marius Felkner on 05.01.21.
 //
 
-internal extension String {
+extension String {
     var isAlphaNumericString: Bool {
         matches("^[a-zA-Z0-9-]+$")
     }
diff --git a/Sources/Helper/VersionValidationError.swift b/Sources/Helper/VersionValidationError.swift
index b3397ba..6d893b1 100644
--- a/Sources/Helper/VersionValidationError.swift
+++ b/Sources/Helper/VersionValidationError.swift
@@ -11,6 +11,8 @@ enum VersionValidationError: Swift.Error {
     case invalidVersionIdentifier
 }
 
+// MARK: LocalizedError
+
 extension VersionValidationError: LocalizedError {
     var errorDescription: String? {
         switch self {
diff --git a/Sources/SemanticVersionComparable/BuildMetaData/BuildMetaData+ExpressibleByLiteral.swift b/Sources/SemanticVersionComparable/BuildMetaData/BuildMetaData+ExpressibleByLiteral.swift
index 4f25714..5f72c35 100644
--- a/Sources/SemanticVersionComparable/BuildMetaData/BuildMetaData+ExpressibleByLiteral.swift
+++ b/Sources/SemanticVersionComparable/BuildMetaData/BuildMetaData+ExpressibleByLiteral.swift
@@ -5,6 +5,8 @@
 //  Created by Marius Felkner on 12.03.21.
 //
 
+// MARK: - BuildMetaData + LosslessStringConvertible
+
 extension BuildMetaData: LosslessStringConvertible {
     public var description: String { value }
 
@@ -13,6 +15,8 @@ extension BuildMetaData: LosslessStringConvertible {
     }
 }
 
+// MARK: - BuildMetaData + ExpressibleByStringLiteral
+
 extension BuildMetaData: ExpressibleByStringLiteral {
     public init(stringLiteral value: StringLiteralType) {
         self.init(private: value)
diff --git a/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier+ExpressibleByLiteral.swift b/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier+ExpressibleByLiteral.swift
index 200bd4b..3bbf758 100644
--- a/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier+ExpressibleByLiteral.swift
+++ b/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier+ExpressibleByLiteral.swift
@@ -5,6 +5,8 @@
 //  Created by Marius Felkner on 12.03.21.
 //
 
+// MARK: - PrereleaseIdentifier + LosslessStringConvertible
+
 extension PrereleaseIdentifier: LosslessStringConvertible {
     public var description: String { value }
 
@@ -13,16 +15,20 @@ extension PrereleaseIdentifier: LosslessStringConvertible {
     }
 }
 
+// MARK: - PrereleaseIdentifier + ExpressibleByStringLiteral
+
 extension PrereleaseIdentifier: ExpressibleByStringLiteral {
     public init(stringLiteral value: StringLiteralType) {
         self.init(private: value)
     }
 }
 
+// MARK: - PrereleaseIdentifier + ExpressibleByIntegerLiteral
+
 extension PrereleaseIdentifier: ExpressibleByIntegerLiteral {
     public init(integerLiteral value: IntegerLiteralType) {
         let absoluteInteger: Int = abs(value)
-        let unsignedInteger: UInt = UInt(absoluteInteger)
+        let unsignedInteger = UInt(absoluteInteger)
         self = .numeric(unsignedInteger)
     }
 }
diff --git a/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier.swift b/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier.swift
index 6fe0d3d..5f95ae0 100644
--- a/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier.swift
+++ b/Sources/SemanticVersionComparable/PrereleaseIdentifier/PrereleaseIdentifier.swift
@@ -35,7 +35,8 @@ public enum PrereleaseIdentifier: Comparable, Hashable {
 
     init(private string: String) {
         if string.isNumericString,
-           let numeric = UInt(string) {
+           let numeric = UInt(string)
+        {
             self = .numeric(numeric)
         } else if string.isAlphaNumericString {
             self = .alphaNumeric(string)
diff --git a/Sources/SemanticVersionComparable/SemanticVersionComparable+Comparable.swift b/Sources/SemanticVersionComparable/SemanticVersionComparable+Comparable.swift
index e7809a3..b723541 100644
--- a/Sources/SemanticVersionComparable/SemanticVersionComparable+Comparable.swift
+++ b/Sources/SemanticVersionComparable/SemanticVersionComparable+Comparable.swift
@@ -22,21 +22,25 @@ public extension SemanticVersionComparable {
         // non-pre-release lhs version is always >= than rhs version
         guard
             let lhspr = lhs.prerelease,
-            !lhspr.isEmpty else {
+            !lhspr.isEmpty
+        else {
             return false
         }
 
         // same goes for rhs vise versa
         guard
             let rhspr = rhs.prerelease,
-            !rhspr.isEmpty  else {
+            !rhspr.isEmpty
+        else {
             return true
         }
 
         // compare content of pre-release identifier
         for (untypedLhs, untypedRhs) in zip(lhspr, rhspr) {
             // if both pre-release identifier are equal, skip the now obsolete comparison
-            if untypedLhs == untypedRhs { continue }
+            if untypedLhs == untypedRhs {
+                continue
+            }
 
             // cast identifiers to int or string as Any
             let typedLhs: Any = Int(untypedLhs.value) ?? untypedLhs.value
diff --git a/Sources/SemanticVersionComparable/SemanticVersionComparable.swift b/Sources/SemanticVersionComparable/SemanticVersionComparable.swift
index 29eee7b..a00289a 100644
--- a/Sources/SemanticVersionComparable/SemanticVersionComparable.swift
+++ b/Sources/SemanticVersionComparable/SemanticVersionComparable.swift
@@ -56,7 +56,7 @@ public extension SemanticVersionComparable {
     /// Lhs must be a lower version to return a valid result. Otherwise `.noUpdate` will be
     /// returned regardless of the difference between the two version objects.
     ///
-    /// - Parameter version: A version object that conforms to the `SemanticVersionComparable` protocol that will be 
+    /// - Parameter version: A version object that conforms to the `SemanticVersionComparable` protocol that will be
     /// compared.
     ///
     /// - Returns: A `VersionCompareResult` as the severity of the update.
@@ -68,8 +68,9 @@ public extension SemanticVersionComparable {
             if lhs < rhs {
                 return .prerelease
             }
-            if lhs.build != rhs.build &&
-               lhs.prereleaseIdentifierString == rhs.prereleaseIdentifierString {
+            if lhs.build != rhs.build,
+               lhs.prereleaseIdentifierString == rhs.prereleaseIdentifierString
+            {
                 return .build
             }
 
@@ -148,14 +149,14 @@ public extension SemanticVersionComparable {
     /// The pre-release identifier as a string if available.
     var prereleaseIdentifierString: String? {
         prerelease?
-            .compactMap { $0.value }
+            .compactMap(\.value)
             .joined(separator: ".")
     }
 
     /// The build-meta-data as a string if available.
     var buildMetaDataString: String? {
         build?
-            .compactMap { $0.value }
+            .compactMap(\.value)
             .joined(separator: ".")
     }
 }
diff --git a/Sources/Version+Bundle.swift b/Sources/Version+Bundle.swift
index b498ab4..ee790be 100644
--- a/Sources/Version+Bundle.swift
+++ b/Sources/Version+Bundle.swift
@@ -8,9 +8,9 @@
 import Foundation
 
 public extension Bundle {
-     /// The version of the current bundle.
-     ///
-     /// - Note: Uses the key `CFBundleShortVersionString` for retrieving version values.
+    /// The version of the current bundle.
+    ///
+    /// - Note: Uses the key `CFBundleShortVersionString` for retrieving version values.
     var shortVersion: Version? {
         guard let versionString: String = infoDictionary?["CFBundleShortVersionString"] as? String else {
             return nil
@@ -26,10 +26,11 @@ public extension Bundle {
     var version: Version? {
         guard
             let versionString: String = infoDictionary?["CFBundleShortVersionString"] as? String,
-            let buildString: String = infoDictionary?["CFBundleVersion"] as? String else {
+            let buildString: String = infoDictionary?["CFBundleVersion"] as? String
+        else {
             return nil
         }
-        let fullVersionString: String = "\(versionString)+\(buildString)"
+        let fullVersionString = "\(versionString)+\(buildString)"
         let version: Version? = Version(fullVersionString)
 
         return version
diff --git a/Sources/Version+OS.swift b/Sources/Version+OS.swift
index 44d2bb7..b8c7366 100644
--- a/Sources/Version+OS.swift
+++ b/Sources/Version+OS.swift
@@ -12,7 +12,7 @@ public extension ProcessInfo {
     @available(macOS, introduced: 10.10)
     var comparableOperatingSystemVersion: Version {
         let osVersion: OperatingSystemVersion = operatingSystemVersion
-        let version: Version = Version(
+        let version = Version(
             major: UInt(osVersion.majorVersion),
             minor: UInt(osVersion.minorVersion),
             patch: UInt(osVersion.patchVersion)
diff --git a/Sources/Version+StringInitializer.swift b/Sources/Version+StringInitializer.swift
index 6e8ca99..f418065 100644
--- a/Sources/Version+StringInitializer.swift
+++ b/Sources/Version+StringInitializer.swift
@@ -5,6 +5,8 @@
 //  Created by Marius Felkner on 05.01.21.
 //
 
+// MARK: - Version + LosslessStringConvertible
+
 extension Version: LosslessStringConvertible {
     public var description: String { absoluteString }
 
@@ -18,6 +20,8 @@ extension Version: LosslessStringConvertible {
     }
 }
 
+// MARK: - Version + ExpressibleByStringLiteral
+
 extension Version: ExpressibleByStringLiteral {
     /// Creates a new version from a string literal.
     ///
@@ -28,6 +32,8 @@ extension Version: ExpressibleByStringLiteral {
     }
 }
 
+// MARK: - Version + ExpressibleByStringInterpolation
+
 extension Version: ExpressibleByStringInterpolation {
     /// Creates a new version from a string interpolation.
     ///
diff --git a/Sources/Version.swift b/Sources/Version.swift
index e7eea0d..60c870e 100644
--- a/Sources/Version.swift
+++ b/Sources/Version.swift
@@ -104,11 +104,12 @@ public struct Version: Sendable, SemanticVersionComparable {
         let versionSplitBuild: [String.SubSequence] = string.split(separator: "+", omittingEmptySubsequences: false)
 
         // check if string does not contain only build-meta-data e.g. "+123" or falsely "+123+something"
-        let maxNumberOfSplits: Int = 2
+        let maxNumberOfSplits = 2
         guard
             !versionSplitBuild.isEmpty,
             versionSplitBuild.count <= maxNumberOfSplits,
-            let versionPrereleaseString = versionSplitBuild.first else {
+            let versionPrereleaseString = versionSplitBuild.first
+        else {
             return nil
         }
 
@@ -120,13 +121,14 @@ public struct Version: Sendable, SemanticVersionComparable {
         guard
             !versionSplitPrerelease.isEmpty,
             let versionStringElement = versionSplitPrerelease.first,
-            !versionStringElement.isEmpty else {
+            !versionStringElement.isEmpty
+        else {
             return nil
         }
 
         // check that the version string has the correct SemVer format which are 0 and positive numbers in the form
         // of `x`, `x.x`or `x.x.x`.
-        let versionString: String = String(versionStringElement)
+        let versionString = String(versionStringElement)
         guard versionString.matchesSemVerFormat() else {
             return nil
         }
@@ -141,7 +143,8 @@ public struct Version: Sendable, SemanticVersionComparable {
                 guard
                     let element = UInt($0),
                     let firstCharacter = $0.first,
-                    !(firstCharacter.isZero && $0.count > 1) else {
+                    !(firstCharacter.isZero && $0.count > 1)
+                else {
                     throw VersionValidationError.invalidVersionIdentifier
                 }
 
@@ -153,16 +156,16 @@ public struct Version: Sendable, SemanticVersionComparable {
         }
 
         // map valid identifiers to corresponding version identifier
-        self.major = safeIdentifiers[0]
-        self.minor = safeIdentifiers.indices.contains(1) ? safeIdentifiers[1] : nil
+        major = safeIdentifiers[0]
+        minor = safeIdentifiers.indices.contains(1) ? safeIdentifiers[1] : nil
         // swiftlint:disable:next no_magic_numbers
-        self.patch = safeIdentifiers.indices.contains(2) ? safeIdentifiers[2] : nil
+        patch = safeIdentifiers.indices.contains(2) ? safeIdentifiers[2] : nil
 
         // extract pre-release identifier if available
         if versionSplitPrerelease.indices.contains(1) {
             versionSplitPrerelease.removeFirst(1)
             let prereleaseSubstring: String = versionSplitPrerelease.joined(separator: "-")
-            self.prerelease = String(prereleaseSubstring)
+            prerelease = String(prereleaseSubstring)
                 .split(separator: ".")
                 .map(String.init)
                 .compactMap {
@@ -175,20 +178,22 @@ public struct Version: Sendable, SemanticVersionComparable {
             // if a pre-release identifier element is initialized as .unkown, we can savely assume that the given
             // string is not a valid  `SemVer` version string.
             if
-                let prerelease = self.prerelease,
-                prerelease.contains(where: { $0 == .unknown }) {
+                let prerelease,
+                prerelease.contains(where: { $0 == .unknown })
+            {
                 return nil
             }
         } else {
             // not pre-release identifier has been found
-            self.prerelease = nil
+            prerelease = nil
         }
 
         // extract build-meta-data identifier if available
         if
             versionSplitBuild.indices.contains(1),
-            let buildSubstring = versionSplitBuild.last {
-            self.build = String(buildSubstring)
+            let buildSubstring = versionSplitBuild.last
+        {
+            build = String(buildSubstring)
                 .split(separator: ".")
                 .map(String.init)
                 .compactMap {
@@ -197,13 +202,14 @@ public struct Version: Sendable, SemanticVersionComparable {
             // finding an .unkown element means that the given string is not conform to `SemVer` since it is no
             // alphaNumeric or a digit
             if
-                let build = self.build,
-                build.contains(where: { $0 == .unknown }) {
+                let build,
+                build.contains(where: { $0 == .unknown })
+            {
                 return nil
             }
         } else {
             // no build-meta-data has been found
-            self.build = nil
+            build = nil
         }
     }
 }
@@ -212,9 +218,11 @@ public struct Version: Sendable, SemanticVersionComparable {
 
 public extension Version {
     /// An initial version representing the string `0.0.0`.
-    static var initial: Version = Version(major: 0, minor: 0, patch: 0)
+    static var initial: Version = .init(major: 0, minor: 0, patch: 0)
 }
 
+// MARK: CustomDebugStringConvertible
+
 extension Version: CustomDebugStringConvertible {
     public var debugDescription: String { absoluteString }
 }
diff --git a/Tests/VersionCompareTests/SemanticVersionComparableTests.swift b/Tests/VersionCompareTests/SemanticVersionComparableTests.swift
index 0aed96a..981179c 100644
--- a/Tests/VersionCompareTests/SemanticVersionComparableTests.swift
+++ b/Tests/VersionCompareTests/SemanticVersionComparableTests.swift
@@ -30,7 +30,7 @@ final class SemanticVersionComparableTests: XCTestCase {
             Version(1, nil, nil, [.prerelease]): Version(1, 0, 0, ["prerelease"])
         ]
 
-        testData.forEach { lhs, rhs in
+        for (lhs, rhs) in testData {
             XCTAssertEqual(lhs, rhs, "Expected \(lhs) to be equal to \(rhs)")
             XCTAssertFalse(lhs > rhs, "Expected \(lhs) to be greater than \(rhs)")
             XCTAssertFalse(lhs < rhs, "Expected \(lhs) to be lesser than \(rhs)")
@@ -57,13 +57,13 @@ final class SemanticVersionComparableTests: XCTestCase {
             Version("300.0+master"): Version("300.0+develop")
         ]
 
-        validTestData.forEach { lhs, rhs in
+        for (lhs, rhs) in validTestData {
             XCTAssertTrue(lhs === rhs, "Expected \(lhs) to be equal to \(rhs)")
             XCTAssertFalse(lhs > rhs, "Expected \(lhs) to be greater than \(rhs)")
             XCTAssertFalse(lhs < rhs, "Expected \(lhs) to be lesser than \(rhs)")
         }
 
-        invalidTestData.forEach { lhs, rhs in
+        for (lhs, rhs) in invalidTestData {
             XCTAssertFalse(lhs === rhs, "Expected \(lhs) to be equal to \(rhs)")
         }
     }
@@ -85,7 +85,7 @@ final class SemanticVersionComparableTests: XCTestCase {
             Version("5-alpha.23+500"): Version("5-alpha.beta+200")
         ]
 
-        testData.forEach { lhs, rhs in
+        for (lhs, rhs) in testData {
             // less
             XCTAssertTrue(lhs < rhs, "Expected \(lhs.absoluteString) to be less to \(rhs.absoluteString)!")
             XCTAssertTrue(lhs <= rhs, "Expected \(lhs.absoluteString) to be less or equal to \(rhs.absoluteString)!")
@@ -112,44 +112,44 @@ final class SemanticVersionComparableTests: XCTestCase {
     }
 
     func testCompatibility() {
-        let versionAA: Version = Version("1.0.0")
-        let versionAB: Version = Version("1.1.0")
-        let versionAC: Version = Version("1.1.1")
-        let versionAD: Version = Version("1.0.1")
-        let versionAE: Version = Version("1.6238746")
-        let versionAF: Version = Version("1")
+        let versionAA = Version("1.0.0")
+        let versionAB = Version("1.1.0")
+        let versionAC = Version("1.1.1")
+        let versionAD = Version("1.0.1")
+        let versionAE = Version("1.6238746")
+        let versionAF = Version("1")
         let versionAs: [Version] = [versionAA, versionAB, versionAC, versionAD, versionAE, versionAF]
 
-        let versionBA: Version = Version("2.0.0")
-        let versionBB: Version = Version("2.1.0")
-        let versionBC: Version = Version("2.1.1")
-        let versionBD: Version = Version("2.0.1")
-        let versionBE: Version = Version("2.3875")
-        let versionBF: Version = Version("2")
+        let versionBA = Version("2.0.0")
+        let versionBB = Version("2.1.0")
+        let versionBC = Version("2.1.1")
+        let versionBD = Version("2.0.1")
+        let versionBE = Version("2.3875")
+        let versionBF = Version("2")
         let versionBs: [Version] = [versionBA, versionBB, versionBC, versionBD, versionBE, versionBF]
 
         // compatible
-        versionAs.forEach { first in
-            versionAs.forEach { second in
+        for first in versionAs {
+            for second in versionAs {
                 XCTAssertTrue(first.isCompatible(with: second))
             }
         }
 
-        versionBs.forEach { first in
-            versionBs.forEach { second in
+        for first in versionBs {
+            for second in versionBs {
                 XCTAssertTrue(first.isCompatible(with: second))
             }
         }
 
         // incompatible
-        versionAs.forEach { first in
-            versionBs.forEach { second in
+        for first in versionAs {
+            for second in versionBs {
                 XCTAssertFalse(first.isCompatible(with: second))
             }
         }
 
-        versionBs.forEach { first in
-            versionAs.forEach { second in
+        for first in versionBs {
+            for second in versionAs {
                 XCTAssertFalse(first.isCompatible(with: second))
             }
         }
@@ -181,7 +181,7 @@ final class SemanticVersionComparableTests: XCTestCase {
             (Version("1.0.0-alpha+1"), Version("1.0.0"), VersionCompareResult.prerelease)
         ]
 
-        testData.forEach { data in
+        for data in testData {
             let versionOne: Version = data.0
             let versionTwo: Version = data.1
             let compareResult: VersionCompareResult = versionOne.compare(with: versionTwo)
diff --git a/Tests/VersionCompareTests/VersionTests.swift b/Tests/VersionCompareTests/VersionTests.swift
index e12fdc7..23eb7b6 100644
--- a/Tests/VersionCompareTests/VersionTests.swift
+++ b/Tests/VersionCompareTests/VersionTests.swift
@@ -1,5 +1,5 @@
 //
-//  SemanticVersionComparableTests.swift
+//  VersionTests.swift
 //  VersionCompareTests
 //
 //  Created by Marius Felkner on 01.01.21.
@@ -95,15 +95,15 @@ final class VersionTests: XCTestCase {
 
     func testValidConstruction() {
         // swiftlint:disable force_unwrapping
-        validVersionData.forEach {
-            let version: Version? = Version($0.0)
-            XCTAssertNotNil(version, "Expected object from string `\($0.0)` not to be nil!")
-            XCTAssertEqual(version!.coreString, $0.1, "Expected versionCode to be \($0.1), is: \(version!.coreString)")
+        for validVersionData in validVersionData {
+            let version: Version? = Version(validVersionData.0)
+            XCTAssertNotNil(version, "Expected object from string `\(validVersionData.0)` not to be nil!")
+            XCTAssertEqual(version!.coreString, validVersionData.1, "Expected versionCode to be \(validVersionData.1), is: \(version!.coreString)")
             XCTAssertEqual(version!.debugDescription, version!.description)
-            if let expectedExtension = $0.2 {
+            if let expectedExtension = validVersionData.2 {
                 XCTAssertEqual(
                     version!.extensionString,
-                    $0.2,
+                    validVersionData.2,
                     "Expected extension to be \(expectedExtension), is: \(version!.extensionString ?? "nil")"
                 )
             } else {
@@ -113,16 +113,16 @@ final class VersionTests: XCTestCase {
         // swiftlint:enable force_unwrapping
 
         // test string literal
-        validVersionData.forEach {
+        for validVersionData in validVersionData {
             // equivalent to `let version: Version = ""`
-            let version: Version = Version(stringLiteral: $0.0)
-            XCTAssertNotNil(version, "Expected object from string `\($0.0)` not to be nil!")
-            XCTAssertEqual(version.coreString, $0.1, "Expected versionCode to be \($0.1), is: \(version.coreString)")
+            let version = Version(stringLiteral: validVersionData.0)
+            XCTAssertNotNil(version, "Expected object from string `\(validVersionData.0)` not to be nil!")
+            XCTAssertEqual(version.coreString, validVersionData.1, "Expected versionCode to be \(validVersionData.1), is: \(version.coreString)")
             XCTAssertEqual(version.debugDescription, version.description)
-            if let expectedExtension = $0.2 {
+            if let expectedExtension = validVersionData.2 {
                 XCTAssertEqual(
                     version.extensionString,
-                    $0.2,
+                    validVersionData.2,
                     "Expected extension to be \(expectedExtension), is: \(version.extensionString ?? "nil")"
                 )
             } else {
@@ -131,16 +131,16 @@ final class VersionTests: XCTestCase {
         }
 
         // test string interpolation
-        validVersionData.forEach {
+        for validVersionData in validVersionData {
             // equivalent to `let version: Version = ""`
-            let version: Version = "\($0.0)"
-            XCTAssertNotNil(version, "Expected object from string `\($0.0)` not to be nil!")
-            XCTAssertEqual(version.coreString, $0.1, "Expected versionCode to be \($0.1), is: \(version.coreString)")
+            let version: Version = "\(validVersionData.0)"
+            XCTAssertNotNil(version, "Expected object from string `\(validVersionData.0)` not to be nil!")
+            XCTAssertEqual(version.coreString, validVersionData.1, "Expected versionCode to be \(validVersionData.1), is: \(version.coreString)")
             XCTAssertEqual(version.debugDescription, version.description)
-            if let expectedExtension = $0.2 {
+            if let expectedExtension = validVersionData.2 {
                 XCTAssertEqual(
                     version.extensionString,
-                    $0.2,
+                    validVersionData.2,
                     "Expected extension to be \(expectedExtension), is: \(version.extensionString ?? "nil")"
                 )
             } else {
@@ -150,13 +150,13 @@ final class VersionTests: XCTestCase {
     }
 
     func testMemberwiseConstruction() {
-        let versionA: Version = Version(major: 1, minor: 2, patch: 3, prerelease: [.alpha])
+        let versionA = Version(major: 1, minor: 2, patch: 3, prerelease: [.alpha])
         XCTAssertEqual(versionA.absoluteString, "1.2.3-alpha", "Expected version to be `1.2.3-alpha`, is: \(versionA)!")
 
-        let versionB: Version = Version(major: 125)
+        let versionB = Version(major: 125)
         XCTAssertEqual(versionB, "125.0.0")
 
-        let versionC: Version = Version(
+        let versionC = Version(
             major: 1,
             minor: 2,
             patch: 3,
@@ -166,14 +166,14 @@ final class VersionTests: XCTestCase {
                 .digits("300"),
                 "test"
             ]
-            )
+        )
         XCTAssertEqual(
             versionC.absoluteString,
             "1.2.3-alpha.release+exp.300.test",
             "Expected version to be `1.2.3-alpha.release+exp.300.test`, is: \(versionC)!"
         )
 
-        let versionD: Version = Version(
+        let versionD = Version(
             major: 1,
             minor: 2,
             patch: 3,
@@ -188,8 +188,8 @@ final class VersionTests: XCTestCase {
     }
 
     func testInvalidConstruction() {
-        invalidVersionData.forEach {
-            XCTAssertNil(Version($0), "Expected object from string `\($0)` to be nil!")
+        for invalidVersionData in invalidVersionData {
+            XCTAssertNil(Version(invalidVersionData), "Expected object from string `\(invalidVersionData)` to be nil!")
         }
     }
 
diff --git a/Tests/VersionCompareTests/XCTestManifests.swift b/Tests/VersionCompareTests/XCTestManifests.swift
index 48675b3..ceced4d 100644
--- a/Tests/VersionCompareTests/XCTestManifests.swift
+++ b/Tests/VersionCompareTests/XCTestManifests.swift
@@ -1,8 +1,8 @@
 import XCTest
 
 #if !canImport(ObjectiveC)
-// swiftlint:disable:next missing_docs
-public func allTests() -> [XCTestCaseEntry] {
-    []
-}
+    // swiftlint:disable:next missing_docs
+    public func allTests() -> [XCTestCaseEntry] {
+        []
+    }
 #endif