Continuous clock...or not continuous clock? That is the question. - Hamlet

[nashysolutions]

Description

I have an issue with continuous clock in the following small snippet of code.

public final class Arbitrator<Value: Equatable> {
    
    @Dependency(\.continuousClock) var continuousClock
    
    private var currentTask: Task<Void, Never>?
    private var previousValue: Value?
    private let debounceInterval: TimeInterval
    
    public var ruling: @MainActor (Value) -> Void = { _ in }
    
    public init(debounceInterval: TimeInterval) {
        self.debounceInterval = debounceInterval
    }
    
    public func disclose(_ newValue: Value) {
        currentTask?.cancel()
        currentTask = Task { [weak self] in
            guard let self else { return }
            try? await continuousClock.sleep(for: .seconds(debounceInterval))
            if newValue != self.previousValue {
                await self.ruling(newValue)
                self.previousValue = newValue
            }
        }
    }
}

When running the following test

func testDebouncing() throws {
    
    // Given - an arbitrator
    
    let arbitrator = Arbitrator<String>(debounceInterval: 1)
    
    var outcome: String?
    var count: Int = 0
    
    arbitrator.ruling = { coalesced in
        count += 1
        outcome = coalesced
    }
    
    // When - we discolse several input values
    // in quick succession
    
    withDependencies {
        $0.continuousClock = .immediate
    } operation: {
        arbitrator.disclose("H")
        arbitrator.disclose("He")
        arbitrator.disclose("Hel")
        arbitrator.disclose("Hell")
        arbitrator.disclose("Hello")
    }
    
    // Then - only one ruling is provided
    
    XCTAssertTrue(count == 1)
    
    // And - the ruling is the last value disclosed
    
    XCTAssertEqual(outcome, "Hello")
}

If I remove main actor, and restart Xcode, I sometimes see the following.

Please submit a bug report (https://swift.org/contributing/#reporting-bugs) and include the crash backtrace.
Stack dump:
/// massive dump
Command SwiftCompile failed with a nonzero exit code

👆 Massive dump parsed via ChatGPT

ChatGPT 🤖

The provided log details a crash in the Swift compiler while trying to build the "swift-toolbox-pro" project. Here are the highlights that you should pay particular attention to:

Look into the code around lines 50 to 52 in "ArbitratorTests.swift". The issue might be related to the specific code block indicated in the log, specifically the part involving the continuousClock property._

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

No error. Test passes.

Actual behavior

Error. Test fails.

Steps to reproduce

1. Copy paste the above code.
2. Run

Dependencies version information

0.6.0

Destination operating system

iOS 17

Xcode version information

Version 15.0 beta 5 (15A5209g)

Swift Compiler version information

swift-driver version: 1.87 Apple Swift version 5.9 (swiftlang-5.9.0.124.4 clang-1500.0.38.1)

[mbrandonw]

Hi @nashysolutions, when I run the code you provided I get a different set of errors:

🛑 XCTAssertTrue failed
🛑 XCTAssertEqual failed: ("nil") is not equal to ("Optional("Hello")")

Can you provide a project that demonstrates the behavior you are seeing?

Also I don't think this is an issue with the library so I am going to convert to a discussion.

[mbrandonw]

I'm not sure why .immediate is not working. It certainly did at some point, that's why it's in the library. Perhaps it's a regression in a recent Swift. It seems to crash the compiler in both Swift 5.8 and 5.9:

@available(iOS 16.0, *)
func foo() {
  let c: any Clock<Duration> = .immediate        // ❌
  let c: any Clock<Duration> = ImmediateClock()  // ✅
}

[stephencelis]

Due to a Swift bug, .immediate works for some types but not any types, so if you have an API that takes a some Clock<Duration>, you can pass .immediate to it, but if it takes an any, you must specify ImmediateClock.

I tried to find the issue on the Swift repo but couldn't track it down. It might be worth a file if it's not tracked anywhere.

[nashysolutions]

Thanks @stephencelis

[stephencelis]

For reference, here's the issue: swiftlang/swift#60552

[nashysolutions]

Avoiding the clock for now. The following works well.

import Foundation
import Combine
import Dependencies

public final class Arbitrator<Value: Equatable> {
    
    private var subject: PassthroughSubject<Value, Never>
    private var subscription: AnyCancellable?
    private var previousValue: Value?
    
    public var ruling: (Value) -> Void = { _ in }
    
    public init(debounceInterval: TimeInterval) {
        subject = PassthroughSubject()
        
        @Dependency(\.mainRunLoop) var mainRunLoop
        
        subscription = subject
            .debounce(for: .seconds(debounceInterval), scheduler: mainRunLoop)
            .sink { [weak self] newValue in
                guard let self else {
                    return
                }
                if newValue != previousValue {
                    ruling(newValue)
                    previousValue = newValue
                }
            }
    }
    
    public func disclose(_ newValue: Value) {
        subject.send(newValue)
    }
}

I think the above approach using Task was flawed anyway.