How to set up a multi-level cache with Carlos?

Use the .compose() method to chain levels, like MemoryCacheLevel().compose(DiskCacheLevel()).compose(NetworkFetcher()), creating a pipeline that falls back from memory to disk to network, as shown in the usage examples.

Carlos vs Kingfisher: which is better for image caching?

Kingfisher is specialized for image downloading and caching with built-in features like placeholders, while Carlos is a general-purpose, composable system; choose Kingfisher for straightforward image needs, Carlos for complex, type-safe cache pipelines.

Does Carlos support background fetching or offline storage?

Carlos supports disk caching via DiskCacheLevel for offline storage, but background fetching requires integration with iOS background tasks, as the library focuses on cache composition rather than system-level features.

How to handle errors in Carlos cache operations?

Errors are propagated through Combine publishers, allowing you to use .sink with receiveCompletion to handle failures, such as disk write errors or transformation failures, as demonstrated in the creating requests section.

Can I use Carlos with SwiftUI or only UIKit?

Carlos is framework-agnostic and uses Combine, so it works with both SwiftUI and UIKit, though you'll need to adapt its asynchronous publishers to SwiftUI's data flow, such as using @Published or ObservableObject.

What are the performance costs of using request pooling?

Request pooling improves performance by reducing duplicate operations, but it adds overhead for key hashing and management; the benefit outweighs the cost for expensive fetches, but it might be unnecessary for fast cache levels.

Open-Awesome

Carlos

MITSwift1.2.1

A simple but flexible cache library for iOS and watchOS apps, written in Swift with a functional programming approach.

GitHub

636 stars33 forks0 contributors

What is Carlos?

Carlos is a Swift library for building custom cache layers in iOS and watchOS applications. It provides a composable, type-safe system for combining memory, disk, and network caching with transformations and conditional logic. It solves the problem of managing complex caching strategies with clean, functional code.

Target Audience

iOS and watchOS developers who need flexible, type-safe caching solutions beyond simple key-value stores, particularly those building apps with complex data fetching and caching requirements.

Value Proposition

Developers choose Carlos for its functional programming approach, which allows for highly composable and type-safe cache pipelines, reducing boilerplate and enabling advanced features like request pooling, conditional caching, and seamless transformations.

Overview

A simple but flexible cache

Use Cases

Best For

Building multi-level cache pipelines with memory, disk, and network layers
Implementing type-safe caching with custom key and value transformations
Reducing redundant network requests through request pooling
Creating conditional caching logic based on app settings or key properties
Handling batch data fetching with partial or complete success requirements
Managing cache behavior in response to system memory warnings

Not Ideal For

Projects needing a simple, out-of-the-box cache without custom pipeline assembly
Teams developing for iOS versions below 13 or watchOS below 6
Developers uncomfortable with Swift's type system and functional programming concepts
Apps where caching is minimal and could be handled by basic solutions like URLCache

Pros & Cons

Pros

Composable Architecture

Allows combining multiple cache levels like memory, disk, and network into pipelines with automatic fallback, enabling complex strategies as shown in the usage examples.

Type-Safe Transformations

Supports key and value transformations using OneWayTransformationBox and TwoWayTransformationBox, ensuring compile-time safety when integrating different cache types.

Efficient Request Handling

Implements request pooling to group concurrent requests for the same key, avoiding duplicate expensive operations like network fetches, as detailed in the pooling requests section.

Built-in Cache Levels

Includes ready-to-use memory, disk, network fetcher, and NSUserDefaults caches, speeding up initial setup for common caching needs.

Cons

Steep Learning Curve

Requires understanding of functional programming patterns like monoidal composition and Swift's type system, which can be daunting for developers not experienced with these concepts.

Platform Limitations

Only supports iOS 13+ and watchOS 6+ due to the migration to Combine, excluding apps that need to target older operating systems, as stated in the breaking changes section.

Complex Setup Overhead

Building custom cache pipelines involves multiple steps like key transformations and conditioning, which adds boilerplate compared to simpler caching libraries.

Frequently Asked Questions

Related Projects

HanekeSwift

A lightweight generic cache for iOS written in Swift with extra love for images.

Stars5,157

Forks580

Last commit5 years ago

Cache

:package: Nothing but Cache.

Stars3,145

Forks356

Last commit10 months ago

Disk

Easily persist structs, images, and data on iOS

Stars3,114

Forks172

Last commit1 year ago

PINCache

Fast, non-deadlocking parallel object cache for iOS, tvOS and OS X

Stars2,691

Forks365

Last commit7 days ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub