MonoTask

Callback signature for receiving task execution results

Callback-based execution block signature for traditional async patterns

Swift async/await execution block signature for modern async patterns

Create MonoTask with callback-based execution (traditional async pattern)

Perfect for wrapping existing callback-based APIs like URLSession, Core Data, etc.

Example:

let networkTask = MonoTask<Data>(
    retry: .count(count: 3, intervalProxy: .exponentialBackoff(initialTimeInterval: 1.0)),
    resultExpireDuration: 300.0 // 5 minutes
) { callback in
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            callback(.failure(error))
        } else if let data = data {
            callback(.success(data))
        }
    }.resume()
}

Create MonoTask with async/await execution (modern async pattern)

Perfect for wrapping modern async APIs and Swift concurrency patterns.

Example:

let apiTask = MonoTask<APIResponse>(
    retry: .count(count: 2, intervalProxy: .fixed(timeInterval: 2.0)),
    resultExpireDuration: 60.0 // 1 minute
) {
    do {
        let response = try await APIClient.shared.fetchData()
        return .success(response)
    } catch {
        return .failure(error)
    }
}

Execute task without waiting for result (fire-and-forget)

Useful when you want to trigger execution but don’t need the result immediately. The task will still benefit from caching and execution merging.

Example:

// Pre-warm cache
task.justExecute()

// Later, this will likely return cached result
let result = await task.asyncExecute()

Execute task with callback-based result handling

Perfect for integrating with callback-based code or when you need to handle results in a specific queue context.

Example:

task.execute { result in
    switch result {
    case .success(let data):
        print("Got data: \(data)")
    case .failure(let error):
        print("Error: \(error)")
    }
}

Execute task with async/await and return Result type

This is the recommended method for modern Swift code. Returns a Result type which allows explicit error handling without exceptions.

Example:

let result = await task.asyncExecute()
switch result {
case .success(let data):
    // Handle success
    updateUI(with: data)
case .failure(let error):
    // Handle error
    showErrorMessage(error)
}

Execute task with async/await and throw on failure

Convenient when you want to use Swift’s error throwing mechanism. Will throw the underlying error if execution fails.

Example:

do {
    let data = try await task.executeThrows()
    // Handle success case directly
    updateUI(with: data)
} catch {
    // Handle any errors
    showErrorMessage(error)
}

Get currently cached result without triggering execution

Returns the cached result if available and not expired, otherwise nil. This property respects TTL and will return nil for expired results.

Thread Safety: This property is thread-safe and can be called from any queue

Use Cases:

• Check if data is available without triggering a potentially expensive operation
• Display cached data immediately while triggering background refresh
• Implement cache-first UI patterns

Example:

// Show cached data immediately if available
if let cached = task.currentResult {
    updateUI(with: cached)
} else {
    showLoadingSpinner()
}

// Trigger fresh execution
task.execute { result in
    hideLoadingSpinner()
    // Handle result...
}

Indicates whether the task is currently executing.

Thread-safe. Returns true while an execution is in progress (i.e., there are registered callbacks waiting for completion), and false when the task is idle.

Strategy for handling ongoing execution when clearing cached results

Defines how to handle a running task when clearResult() is called.

MonoTask-specific errors

Manually invalidate cached result with fine-grained control over ongoing execution

This method provides powerful cache management capabilities:

Execution State Handling:

• If task is idle: Simply clears cache, optionally starts fresh execution
• If task is executing: Applies the chosen strategy for ongoing execution

Strategy Details:

• .cancel: Immediately cancels execution and notifies all callbacks with error
• .restart: Lets execution complete, then starts fresh execution
• .allowCompletion: Lets execution complete normally, just clears cache

Thread Safety: Fully thread-safe, can be called from any queue

Use Cases:

// Force fresh data (cancel ongoing request)
task.clearResult(ongoingExecutionStrategy: .cancel)

// Clear cache but let current request complete
task.clearResult(ongoingExecutionStrategy: .allowCompletion)

// Clear cache and ensure fresh execution
task.clearResult(ongoingExecutionStrategy: .restart, shouldRestartWhenIDLE: true)