diff --git a/.github/workflows/swift-tests.yaml b/.github/workflows/swift-tests.yaml
index d322710..8e1d00d 100644
--- a/.github/workflows/swift-tests.yaml
+++ b/.github/workflows/swift-tests.yaml
@@ -9,8 +9,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - name: Select Xcode 16.4
-      run: sudo xcode-select -s /Applications/Xcode_16.4.app/Contents/Developer
+    - name: Select Xcode 26.0
+      run: sudo xcode-select -s /Applications/Xcode_26.app/Contents/Developer
     - name: Build
       run: swift build -v
     - name: Run tests
diff --git a/README.md b/README.md
index f50f92f..acb424b 100644
--- a/README.md
+++ b/README.md
@@ -4,10 +4,13 @@ A Swift package that provides elegant state management for asynchronous operatio
 
 ## Overview
 
-AsyncLoad provides two main components for handling asynchronous operations:
+AsyncLoad provides components for handling asynchronous operations:
 - `AsyncLoad<T>`: For loading data operations
-- `AsyncAction<T>`: For action-based operations  
+- `AsyncAction<T>`: For action-based operations
+- `CachedAsyncLoad<T>`: For loading operations that preserve cached data during refreshes
+- `CachedAsyncAction<T>`: For actions that preserve cached data during retries
 - `AsyncLoadView`: A SwiftUI view component for displaying async states
+- `CachedAsyncLoadView`: A SwiftUI view component for cached async states
 
 ## Requirements
 
@@ -25,7 +28,7 @@ Add AsyncLoad to your project by adding the following to your `Package.swift`:
 
 ```swift
 dependencies: [
-    .package(url: "https://github.com/yourusername/AsyncLoad", from: "1.0.0")
+    .package(url: "https://github.com/diamirio/AsyncLoad", from: "1.0.0")
 ]
 ```
 
@@ -118,6 +121,101 @@ class FormViewModel {
 }
 ```
 
+### CachedAsyncLoad<T>
+
+An enhanced version of AsyncLoad that preserves cached data during loading and error states.
+
+```swift
+public enum CachedAsyncLoad<T>: Equatable {
+    case none                    // Initial state
+    case loading(T? = nil)       // Loading with optional cached data
+    case error(T? = nil, Error)  // Error with optional cached data
+    case loaded(T)               // Successfully loaded with data
+}
+```
+
+#### Properties
+
+- `isLoading: Bool` - Returns true if the state is `.loading`
+- `item: T?` - Returns the loaded item if state is `.loaded`, nil otherwise
+- `error: Error?` - Returns the error if state is `.error`, nil otherwise
+
+#### Example Usage
+
+```swift
+import AsyncLoad
+
+@Observable
+class CachedDataViewModel {
+    var userProfile: CachedAsyncLoad<User> = .none
+
+    func loadUserProfile(id: String) async {
+        // Start loading while preserving any existing data
+        if case .loaded(let existingUser) = userProfile {
+            userProfile = .loading(existingUser)
+        } else {
+            userProfile = .loading()
+        }
+
+        do {
+            let user = try await userService.fetchUser(id: id)
+            userProfile = .loaded(user)
+        } catch {
+            // Preserve existing data even during error
+            let existingUser = userProfile.item
+            userProfile = .error(existingUser, error)
+        }
+    }
+}
+```
+
+### CachedAsyncAction<T>
+
+Similar to AsyncAction but preserves cached data during loading and error states.
+
+```swift
+public enum CachedAsyncAction<T>: Equatable {
+    case none                    // Initial state
+    case loading(T? = nil)       // Action in progress with optional cached data
+    case error(T? = nil, Error)  // Action failed with optional cached data
+    case success(T)              // Action completed successfully
+}
+```
+
+#### Properties
+
+- `isLoading: Bool` - Returns true if the state is `.loading`
+- `item: T?` - Returns the success result if state is `.success`, nil otherwise
+- `error: Error?` - Returns the error if state is `.error`, nil otherwise
+
+#### Example Usage
+
+```swift
+import AsyncLoad
+
+@Observable
+class CachedFormViewModel {
+    var submitAction: CachedAsyncAction<SubmitResponse> = .none
+
+    func submitForm(data: FormData) async {
+        // Preserve previous successful response during retry
+        if case .success(let previousResponse) = submitAction {
+            submitAction = .loading(previousResponse)
+        } else {
+            submitAction = .loading()
+        }
+
+        do {
+            let response = try await apiService.submit(data)
+            submitAction = .success(response)
+        } catch {
+            let previousResponse = submitAction.item
+            submitAction = .error(previousResponse, error)
+        }
+    }
+}
+```
+
 ### AsyncLoadView
 
 A SwiftUI view component that automatically handles the display of different async states.
@@ -182,16 +280,19 @@ struct UserProfileView: View {
 ## Features
 
 - **Type-safe**: Generic enums ensure type safety for your data
-- **Equatable**: Both AsyncLoad and AsyncAction conform to Equatable for easy state comparison
-- **SwiftUI Integration**: AsyncLoadView provides seamless integration with SwiftUI
+- **Equatable**: All async state enums conform to Equatable for easy state comparison
+- **SwiftUI Integration**: AsyncLoadView and CachedAsyncLoadView provide seamless integration with SwiftUI
 - **Error Handling**: Built-in error state management
 - **Loading States**: Automatic loading state handling with progress indicators
+- **Cached Data**: CachedAsyncLoad and CachedAsyncAction preserve data during refreshes and errors
 - **Flexible UI**: Customizable content and error views
 
 ## Best Practices
 
 1. **Use AsyncLoad for data fetching** operations (GET requests, loading content)
 2. **Use AsyncAction for user actions** (POST/PUT/DELETE requests, form submissions)
-3. **Always handle all states** in your UI to provide good user experience
-4. **Use AsyncLoadView** for simple cases to reduce boilerplate code
-5. **Reset states** appropriately (e.g., set to `.none` when appropriate)
+3. **Use CachedAsyncLoad** when you want to preserve data during refreshes or show stale data during errors
+4. **Use CachedAsyncAction** when you want to preserve previous results during action retries
+5. **Always handle all states** in your UI to provide good user experience
+6. **Use AsyncLoadView and CachedAsyncLoadView** for simple cases to reduce boilerplate code
+7. **Reset states** appropriately (e.g., set to `.none` when appropriate)
diff --git a/Sources/AsyncLoad/AsyncLoad/AsyncAction.swift b/Sources/AsyncLoad/AsyncLoad/AsyncAction.swift
index 3da666f..215b3d8 100644
--- a/Sources/AsyncLoad/AsyncLoad/AsyncAction.swift
+++ b/Sources/AsyncLoad/AsyncLoad/AsyncAction.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-public enum AsyncAction<T>: Equatable {
+public enum AsyncAction<T: Sendable>: Equatable, Sendable {
     case none
     case loading
     case error(Error)
@@ -45,4 +45,34 @@ public enum AsyncAction<T>: Equatable {
             false
         }
     }
+    
+    public static func == (lhs: AsyncAction<T>, rhs: AsyncAction<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            true
+        case (.loading, .loading):
+            true
+        case (.error, .error):
+            true
+        case let (.success(lhsItem), .success(rhsItem)):
+            lhsItem == rhsItem
+        default:
+            false
+        }
+    }
+    
+    public static func != (lhs: AsyncAction<T>, rhs: AsyncAction<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            false
+        case (.loading, .loading):
+            false
+        case (.error, .error):
+            false
+        case let (.success(lhsItem), .success(rhsItem)):
+            lhsItem != rhsItem
+        default:
+            true
+        }
+    }
 }
diff --git a/Sources/AsyncLoad/AsyncLoad/AsyncLoad.swift b/Sources/AsyncLoad/AsyncLoad/AsyncLoad.swift
index 0297b92..2fb48f9 100644
--- a/Sources/AsyncLoad/AsyncLoad/AsyncLoad.swift
+++ b/Sources/AsyncLoad/AsyncLoad/AsyncLoad.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-public enum AsyncLoad<T>: Equatable {
+public enum AsyncLoad<T: Sendable>: Equatable, Sendable {
     case none
     case loading
     case error(Error)
@@ -45,4 +45,34 @@ public enum AsyncLoad<T>: Equatable {
             false
         }
     }
+    
+    public static func == (lhs: AsyncLoad<T>, rhs: AsyncLoad<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            true
+        case (.loading, .loading):
+            true
+        case (.error, .error):
+            true
+        case let (.loaded(lhsItem), .loaded(rhsItem)):
+            lhsItem == rhsItem
+        default:
+            false
+        }
+    }
+    
+    public static func != (lhs: AsyncLoad<T>, rhs: AsyncLoad<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            false
+        case (.loading, .loading):
+            false
+        case (.error, .error):
+            false
+        case let (.loaded(rhsItem), .loaded(lhsItem)):
+            lhsItem != rhsItem
+        default:
+            true
+        }
+    }
 }
diff --git a/Sources/AsyncLoad/AsyncLoad/AsyncLoadView.swift b/Sources/AsyncLoad/AsyncLoad/AsyncLoadView.swift
index bf2d30a..c57ef83 100644
--- a/Sources/AsyncLoad/AsyncLoad/AsyncLoadView.swift
+++ b/Sources/AsyncLoad/AsyncLoad/AsyncLoadView.swift
@@ -2,7 +2,11 @@ import Foundation
 #if canImport(SwiftUI)
 import SwiftUI
 
-public struct AsyncLoadView<Item, Content: View, ErrorContent: View>: View {
+public struct AsyncLoadView<
+    Item: Sendable,
+    Content: View,
+    ErrorContent: View
+>: View {
     let state: AsyncLoad<Item>
 
     @ViewBuilder
diff --git a/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncAction.swift b/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncAction.swift
index c4488c7..162cc58 100644
--- a/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncAction.swift
+++ b/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncAction.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-public enum CachedAsyncAction<T>: Equatable {
+public enum CachedAsyncAction<T: Sendable>: Equatable, Sendable {
     case none
     case loading(T? = nil)
     case error(T? = nil, Error)
@@ -45,4 +45,34 @@ public enum CachedAsyncAction<T>: Equatable {
             false
         }
     }
+    
+    public static func == (lhs: CachedAsyncAction<T>, rhs: CachedAsyncAction<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            true
+        case let (.loading(lhsItem), .loading(rhsItem)):
+            lhsItem == rhsItem
+        case let (.error(lhsItem, _), .error(rhsItem, _)):
+            lhsItem == rhsItem
+        case let (.success(lhsItem), .success(rhsItem)):
+            lhsItem == rhsItem
+        default:
+            false
+        }
+    }
+    
+    public static func != (lhs: CachedAsyncAction<T>, rhs: CachedAsyncAction<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            false
+        case let (.loading(lhsItem), .loading(rhsItem)):
+            lhsItem != rhsItem
+        case let (.error(lhsItem, _), .error(rhsItem, _)):
+            lhsItem != rhsItem
+        case let (.success(lhsItem), .success(rhsItem)):
+            lhsItem != rhsItem
+        default:
+            false
+        }
+    }
 }
diff --git a/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoad.swift b/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoad.swift
index 92cfa9a..6e79f1c 100644
--- a/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoad.swift
+++ b/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoad.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-public enum CachedAsyncLoad<T>: Equatable {
+public enum CachedAsyncLoad<T: Sendable>: Equatable, Sendable {
     case none
     case loading(T? = nil)
     case error(T? = nil, Error)
@@ -45,4 +45,34 @@ public enum CachedAsyncLoad<T>: Equatable {
             false
         }
     }
+    
+    public static func == (lhs: CachedAsyncLoad<T>, rhs: CachedAsyncLoad<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            true
+        case let (.loading(lhsItem), .loading(rhsItem)):
+            lhsItem == rhsItem
+        case let (.error(lhsItem, _), .error(rhsItem, _)):
+            lhsItem == rhsItem
+        case let (.loaded( lhsItem), .loaded(rhsItem)):
+            lhsItem == rhsItem
+        default:
+            false
+        }
+    }
+    
+    public static func != (lhs: CachedAsyncLoad<T>, rhs: CachedAsyncLoad<T>) -> Bool where T : Equatable {
+        switch (lhs, rhs) {
+        case (.none, .none):
+            true
+        case let (.loading(lhsItem), .loading(rhsItem)):
+            lhsItem != rhsItem
+        case let (.error(lhsItem, _), .error(rhsItem, _)):
+            lhsItem != rhsItem
+        case let (.loaded( lhsItem), .loaded(rhsItem)):
+            lhsItem != rhsItem
+        default:
+            false
+        }
+    }
 }
diff --git a/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoadView.swift b/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoadView.swift
index e1803ca..03c6e9b 100644
--- a/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoadView.swift
+++ b/Sources/AsyncLoad/CachedAsyncLoad/CachedAsyncLoadView.swift
@@ -3,7 +3,7 @@ import Foundation
 import SwiftUI
 
 public struct CachedAsyncLoadView<
-    Item,
+    Item: Sendable,
     Content: View,
     ErrorContent: View,
     LoadingContent: View
diff --git a/Tests/AsyncLoadTests/AsyncActionEquatableItemTests.swift b/Tests/AsyncLoadTests/AsyncActionEquatableItemTests.swift
new file mode 100644
index 0000000..602e927
--- /dev/null
+++ b/Tests/AsyncLoadTests/AsyncActionEquatableItemTests.swift
@@ -0,0 +1,43 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test equatable AsyncAction")
+struct AsyncActionEquatableItemTests {
+    @Test<[AsyncActionParameter<String>]>("Should be equal <String>", arguments: [
+        .init(.none, .none),
+        .init(.loading, .loading),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+        .init(.success("some"), .success("some")),
+    ])
+    func equalString(param: AsyncActionParameter<String>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+    
+    @Test<[AsyncActionParameter<String>]>("Should not be equal <String>", arguments: [
+        .init(.success("some"), .success("other")),
+        .init(.error(TestingError.some), .success("other")),
+    ])
+    func nonEqualString(param: AsyncActionParameter<String>) async throws {
+        #expect(param.action1 != param.action2)
+    }
+    
+    @Test<[AsyncActionParameter<User>]>("Should be equal <User>", arguments: [
+        .init(.none, .none),
+        .init(.loading, .loading),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+        .init(.success(User(name: "some")), .success(User(name: "some"))),
+    ])
+    func equalUser(param: AsyncActionParameter<User>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+    
+    @Test<[AsyncActionParameter<User>]>("Should not be equal <User>", arguments: [
+        .init(.success(User(name: "some")), .success(User(name: "other"))),
+        .init(.error(TestingError.some), .success(User(name: "some"))),
+    ])
+    func nonEqualuser(param: AsyncActionParameter<User>) async throws {
+        #expect(param.action1 != param.action2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/AsyncActionNonEquatableItemTests.swift b/Tests/AsyncLoadTests/AsyncActionNonEquatableItemTests.swift
new file mode 100644
index 0000000..c5b45dd
--- /dev/null
+++ b/Tests/AsyncLoadTests/AsyncActionNonEquatableItemTests.swift
@@ -0,0 +1,26 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test non-equatable AsyncAction")
+struct AsyncActionNonEquatableItemTests {
+    @Test<[AsyncActionParameter<NonEquatableItem>]>("Should be equal (structural)", arguments: [
+        .init(.none, .none),
+        .init(.loading, .loading),
+        .init(.success(NonEquatableItem(name: "Hello")), .success(NonEquatableItem(name: "Different"))),
+        .init(.success(NonEquatableItem(name: "Some")), .success(NonEquatableItem(name: "Other"))),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+    ])
+    func structuralEquality(param: AsyncActionParameter<NonEquatableItem>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+
+    @Test<[AsyncActionParameter<User>]>("Should be equal (mixed types)", arguments: [
+        .init(.loading, .loading),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+    ])
+    func mixedTypeEquality(param: AsyncActionParameter<User>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/AsyncLoadEquatableItemTests.swift b/Tests/AsyncLoadTests/AsyncLoadEquatableItemTests.swift
new file mode 100644
index 0000000..d0a44fa
--- /dev/null
+++ b/Tests/AsyncLoadTests/AsyncLoadEquatableItemTests.swift
@@ -0,0 +1,43 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test equatable AsyncLoad")
+struct AsyncLoadEquatableItemTests {
+    @Test<[AsyncLoadParameter<String>]>("Should be equal <String>", arguments: [
+        .init(.none, .none),
+        .init(.loading, .loading),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+        .init(.loaded("some"), .loaded("some")),
+    ])
+    func equalString(param: AsyncLoadParameter<String>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+
+    @Test<[AsyncLoadParameter<String>]>("Should not be equal <String>", arguments: [
+        .init(.loaded("Some"), .loaded("Other")),
+        .init(.error(TestingError.some), .loaded("some")),
+    ])
+    func nonEqualString(param: AsyncLoadParameter<String>) async throws {
+        #expect(param.load1 != param.load2)
+    }
+
+    @Test<[AsyncLoadParameter<User>]>("Should be equal <User>", arguments: [
+        .init(.none, .none),
+        .init(.loading, .loading),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+        .init(.loaded(User(name: "some")), .loaded(User(name: "some"))),
+    ])
+    func equalUser(param: AsyncLoadParameter<User>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+
+    @Test<[AsyncLoadParameter<User>]>("Should not be equal <User>", arguments: [
+        .init(.loaded(User(name: "Alex")), .loaded(User(name: "Daniel"))),
+        .init(.error(TestingError.some), .loaded(User(name: "some"))),
+    ])
+    func nonEqualUser(param: AsyncLoadParameter<User>) async throws {
+        #expect(param.load1 != param.load2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/AsyncLoadNonEquatableItemTests.swift b/Tests/AsyncLoadTests/AsyncLoadNonEquatableItemTests.swift
new file mode 100644
index 0000000..9281991
--- /dev/null
+++ b/Tests/AsyncLoadTests/AsyncLoadNonEquatableItemTests.swift
@@ -0,0 +1,26 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test non-equatable AsyncLoad")
+struct AsyncLoadNonEquatableItemTests {
+    @Test<[AsyncLoadParameter<NonEquatableItem>]>("Should be equal (structural)", arguments: [
+        .init(.none, .none),
+        .init(.loading, .loading),
+        .init(.loaded(NonEquatableItem(name: "Hello")), .loaded(NonEquatableItem(name: "Different"))),
+        .init(.loaded(NonEquatableItem(name: "Some")), .loaded(NonEquatableItem(name: "Other"))),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+    ])
+    func structuralEquality(param: AsyncLoadParameter<NonEquatableItem>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+
+    @Test<[AsyncLoadParameter<User>]>("Should be equal (mixed types)", arguments: [
+        .init(.loading, .loading),
+        .init(.error(TestingError.some), .error(TestingError.some)),
+        .init(.error(TestingError.some), .error(TestingError.other)),
+    ])
+    func mixedTypeEquality(param: AsyncLoadParameter<User>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/AsyncLoadTests.swift b/Tests/AsyncLoadTests/AsyncLoadTests.swift
deleted file mode 100644
index 1cbecb5..0000000
--- a/Tests/AsyncLoadTests/AsyncLoadTests.swift
+++ /dev/null
@@ -1,56 +0,0 @@
-import Testing
-@testable import AsyncLoad
-
-enum TestingError: Error {
-    case some
-}
-
-@Test func testAsyncLoadEquatable() async throws {
-    var load1: AsyncLoad<String> = .none
-    var load2: AsyncLoad<String> = .none
-    
-    #expect(load1 == load2)
-    
-    load1 = .loading
-    load2 = .loading
-    
-    #expect(load1 == load2)
-    
-    load1 = .loaded("some")
-    load2 = .loaded("other")
-    
-    #expect(load1 == load2)
-    
-    load1 = .error(TestingError.some)
-    load2 = .error(TestingError.some)
-    
-    #expect(load1 == load2)
-}
-
-
-@Test func testCachedAsyncLoadEquatable() async throws {
-    var load1: CachedAsyncLoad<String> = .none
-    var load2: CachedAsyncLoad<String> = .none
-    
-    #expect(load1 == load2)
-    
-    load1 = .loading()
-    load2 = .loading()
-    
-    #expect(load1 == load2)
-    
-    load1 = .loaded("some")
-    load2 = .loaded("other")
-    
-    #expect(load1 == load2)
-
-    load1 = .loading("some")
-    load2 = .loading("other")
-    
-    #expect(load1 == load2)
-    
-    load1 = .error("some", TestingError.some)
-    load2 = .error(nil, TestingError.some)
-    
-    #expect(load1 == load2)
-}
diff --git a/Tests/AsyncLoadTests/CachedAsyncActionEquatableItemTests.swift b/Tests/AsyncLoadTests/CachedAsyncActionEquatableItemTests.swift
new file mode 100644
index 0000000..25fb8a9
--- /dev/null
+++ b/Tests/AsyncLoadTests/CachedAsyncActionEquatableItemTests.swift
@@ -0,0 +1,48 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test equatable CachedAsyncAction")
+struct CachedAsyncActionEquatableItemTests {
+    @Test<[CachedAsyncActionParameter<String>]>("Should be equal <String>", arguments: [
+        .init(.none, .none),
+        .init(.loading(), .loading()),
+        .init(.success("some"), .success("some")),
+        .init(.loading("some"), .loading("some")),
+        .init(.error("some", TestingError.some), .error("some", TestingError.some)),
+    ])
+    func equalString(param: CachedAsyncActionParameter<String>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+
+    @Test<[CachedAsyncActionParameter<String>]>("Should not be equal <String>", arguments: [
+        .init(.success("Other"), .success("Other1")),
+        .init(.loading("some"), .loading("other")),
+        .init(.error(nil, TestingError.some), .error("some", TestingError.some)),
+        .init(.error(nil, TestingError.some), .error("some", TestingError.other)),
+        .init(.error("some", TestingError.some), .error(nil, TestingError.some)),
+    ])
+    func nonEqualString(param: CachedAsyncActionParameter<String>) async throws {
+        #expect(param.action1 != param.action2)
+    }
+
+    @Test<[CachedAsyncActionParameter<User>]>("Should be equal <User>", arguments: [
+        .init(.none, .none),
+        .init(.loading(), .loading()),
+        .init(.success(User(name: "some")), .success(User(name: "some"))),
+        .init(.loading(User(name: "some")), .loading(User(name: "some"))),
+        .init(.error(User(name: "some"), TestingError.some), .error(User(name: "some"), TestingError.some)),
+    ])
+    func equalUser(param: CachedAsyncActionParameter<User>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+
+    @Test<[CachedAsyncActionParameter<User>]>("Should not be equal <User>", arguments: [
+        .init(.success(User(name: "Alex")), .success(User(name: "Daniel"))),
+        .init(.loading(User(name: "Alex")), .loading(User(name: "Daniel"))),
+        .init(.error(nil, TestingError.some), .error(User(name: "some"), TestingError.some)),
+        .init(.error(User(name: "Alex"), TestingError.some), .error(User(name: "Daniel"), TestingError.some)),
+    ])
+    func nonEqualUser(param: CachedAsyncActionParameter<User>) async throws {
+        #expect(param.action1 != param.action2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/CachedAsyncActionNonEquatableItemTests.swift b/Tests/AsyncLoadTests/CachedAsyncActionNonEquatableItemTests.swift
new file mode 100644
index 0000000..e369b89
--- /dev/null
+++ b/Tests/AsyncLoadTests/CachedAsyncActionNonEquatableItemTests.swift
@@ -0,0 +1,19 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test non-equatable CachedAsyncAction")
+struct CachedAsyncActionNonEquatableItemTests {
+    @Test<[CachedAsyncActionParameter<NonEquatableItem>]>("Should be equal (structural)", arguments: [
+        .init(.none, .none),
+        .init(.loading(), .loading()),
+        .init(.success(NonEquatableItem(name: "Hello")), .success(NonEquatableItem(name: "Different"))),
+        .init(.success(NonEquatableItem(name: "Some")), .success(NonEquatableItem(name: "Other"))),
+        .init(.loading(NonEquatableItem(name: "Some")), .loading(NonEquatableItem(name: "Other"))),
+        .init(.error(nil, TestingError.some), .error(nil, TestingError.some)),
+        .init(.error(nil, TestingError.some), .error(NonEquatableItem(name: "Hello"), TestingError.other)),
+        .init(.error(NonEquatableItem(name: "Hello"), TestingError.some), .error(NonEquatableItem(name: "World"), TestingError.some)),
+    ])
+    func structuralEquality(param: CachedAsyncActionParameter<NonEquatableItem>) async throws {
+        #expect(param.action1 == param.action2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/CachedAsyncLoadEquatableItemTests.swift b/Tests/AsyncLoadTests/CachedAsyncLoadEquatableItemTests.swift
new file mode 100644
index 0000000..e554e38
--- /dev/null
+++ b/Tests/AsyncLoadTests/CachedAsyncLoadEquatableItemTests.swift
@@ -0,0 +1,48 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test equatable CachedAsyncLoad")
+struct CachedAsyncLoadEquatableItemTests {
+    @Test<[CachedAsyncLoadParameter<String>]>("Should be equal <String>", arguments: [
+        .init(.none, .none),
+        .init(.loading(), .loading()),
+        .init(.loaded("some"), .loaded("some")),
+        .init(.loading("some"), .loading("some")),
+        .init(.error("some", TestingError.some), .error("some", TestingError.some)),
+    ])
+    func equalString(param: CachedAsyncLoadParameter<String>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+
+    @Test<[CachedAsyncLoadParameter<String>]>("Should not be equal <String>", arguments: [
+        .init(.loaded("Other"), .loaded("Other1")),
+        .init(.loading("some"), .loading("other")),
+        .init(.error(nil, TestingError.some), .error("some", TestingError.some)),
+        .init(.error(nil, TestingError.some), .error("some", TestingError.other)),
+        .init(.error("some", TestingError.some), .error(nil, TestingError.some)),
+    ])
+    func nonEqualString(param: CachedAsyncLoadParameter<String>) async throws {
+        #expect(param.load1 != param.load2)
+    }
+
+    @Test<[CachedAsyncLoadParameter<User>]>("Should be equal <User>", arguments: [
+        .init(.none, .none),
+        .init(.loading(), .loading()),
+        .init(.loaded(User(name: "some")), .loaded(User(name: "some"))),
+        .init(.loading(User(name: "some")), .loading(User(name: "some"))),
+        .init(.error(User(name: "some"), TestingError.some), .error(User(name: "some"), TestingError.some)),
+    ])
+    func equalUser(param: CachedAsyncLoadParameter<User>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+
+    @Test<[CachedAsyncLoadParameter<User>]>("Should not be equal <User>", arguments: [
+        .init(.loaded(User(name: "Alex")), .loaded(User(name: "Daniel"))),
+        .init(.loading(User(name: "Alex")), .loading(User(name: "Daniel"))),
+        .init(.error(nil, TestingError.some), .error(User(name: "some"), TestingError.some)),
+        .init(.error(User(name: "Alex"), TestingError.some), .error(User(name: "Daniel"), TestingError.some)),
+    ])
+    func nonEqualUser(param: CachedAsyncLoadParameter<User>) async throws {
+        #expect(param.load1 != param.load2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/CachedAsyncLoadNonEquatableItemTests.swift b/Tests/AsyncLoadTests/CachedAsyncLoadNonEquatableItemTests.swift
new file mode 100644
index 0000000..c55af85
--- /dev/null
+++ b/Tests/AsyncLoadTests/CachedAsyncLoadNonEquatableItemTests.swift
@@ -0,0 +1,19 @@
+import Testing
+@testable import AsyncLoad
+
+@Suite("Test non-equatable CachedAsyncLoad")
+struct CachedAsyncLoadNonEquatableItemTests {
+    @Test<[CachedAsyncLoadParameter<NonEquatableItem>]>("Should be equal (structural)", arguments: [
+        .init(.none, .none),
+        .init(.loading(), .loading()),
+        .init(.loaded(NonEquatableItem(name: "Hello")), .loaded(NonEquatableItem(name: "Different"))),
+        .init(.loaded(NonEquatableItem(name: "Some")), .loaded(NonEquatableItem(name: "Other"))),
+        .init(.loading(NonEquatableItem(name: "Some")), .loading(NonEquatableItem(name: "Other"))),
+        .init(.error(nil, TestingError.some), .error(nil, TestingError.some)),
+        .init(.error(nil, TestingError.some), .error(NonEquatableItem(name: "Hello"), TestingError.other)),
+        .init(.error(NonEquatableItem(name: "Hello"), TestingError.some), .error(NonEquatableItem(name: "World"), TestingError.some)),
+    ])
+    func structuralEquality(param: CachedAsyncLoadParameter<NonEquatableItem>) async throws {
+        #expect(param.load1 == param.load2)
+    }
+}
diff --git a/Tests/AsyncLoadTests/Utils.swift b/Tests/AsyncLoadTests/Utils.swift
new file mode 100644
index 0000000..b3cdbb0
--- /dev/null
+++ b/Tests/AsyncLoadTests/Utils.swift
@@ -0,0 +1,59 @@
+import Foundation
+@testable import AsyncLoad
+
+enum TestingError: Error {
+    case some
+    case other
+}
+
+final class NonEquatableItem: Sendable {
+    let name: String
+    
+    init(name: String) {
+        self.name = name
+    }
+}
+
+struct User: Equatable {
+    let name: String
+}
+
+struct AsyncActionParameter<T: Sendable> {
+    let action1: AsyncAction<T>
+    let action2: AsyncAction<T>
+    
+    init(_ action1: AsyncAction<T>, _ action2: AsyncAction<T>) {
+        self.action1 = action1
+        self.action2 = action2
+    }
+}
+
+struct AsyncLoadParameter<T: Sendable> {
+    let load1: AsyncLoad<T>
+    let load2: AsyncLoad<T>
+
+    init(_ load1: AsyncLoad<T>, _ load2: AsyncLoad<T>) {
+        self.load1 = load1
+        self.load2 = load2
+    }
+}
+
+struct CachedAsyncActionParameter<T: Sendable> {
+    let action1: CachedAsyncAction<T>
+    let action2: CachedAsyncAction<T>
+
+    init(_ action1: CachedAsyncAction<T>, _ action2: CachedAsyncAction<T>) {
+        self.action1 = action1
+        self.action2 = action2
+    }
+}
+
+struct CachedAsyncLoadParameter<T: Sendable> {
+    let load1: CachedAsyncLoad<T>
+    let load2: CachedAsyncLoad<T>
+    
+    init(_ load1: CachedAsyncLoad<T>, _ load2: CachedAsyncLoad<T>) {
+        self.load1 = load1
+        self.load2 = load2
+    }
+}