Cancellable stored for every executed action

[robinmayerhofer]

Everytime an action is executed, a new AnyCancellable is stored in the cancellables of the Reactor. This can lead to evergrowing memory usage. (10k actions lead to ~3.6 MB increased memory usage), see here

For reference: ReactorKit creates the state stream only once and uses a custom observable type that takes actions.

The ReactorKit approach would solve the described issue for the SwiftUIReactor framework.

Example test showing increasing memory consumption:

import XCTest
import Combine
@testable import SwiftUIReactor

final class TestMemoryConsumption: XCTestCase {
    func testMemoryConsumption() {
        let reactor = CountingReactor()

        var cancellables = Set<AnyCancellable>()

        print("MB after", getMegabytesUsed())

        let amount = 10000
        for _ in 0..<amount {
            Just(CountingReactor.Action.countUp)
                .sink(receiveValue: reactor.action)
                .store(in: &cancellables)
        }

        cancellables = Set()
        sleep(3)
        print("MB after", getMegabytesUsed())
    }
    func mach_task_self() -> task_t {
        return mach_task_self_
    }

    func getMegabytesUsed() -> Float {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout.size(ofValue: info) / MemoryLayout<integer_t>.size)
        let kerr = withUnsafeMutablePointer(to: &info) { infoPtr in
            return infoPtr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { (machPtr: UnsafeMutablePointer<integer_t>) in
                return task_info(
                    mach_task_self(),
                    task_flavor_t(MACH_TASK_BASIC_INFO),
                    machPtr,
                    &count
                )
            }
        }
        guard kerr == KERN_SUCCESS else {
            fatalError()
        }
        return Float(info.resident_size) / (1024 * 1024)
    }
}

final class CountingReactor: Reactor {

    enum Action {
        case countUp
    }

    enum Mutation {
        case countUp
    }

    struct State {
        var currentCount: Int
    }

    var cancellables: Set<AnyCancellable> = []

    var state: State = State(currentCount: 0)

    func mutate(action: Action) -> AnyPublisher<Mutation, Never> {
        return Just(Mutation.countUp).eraseToAnyPublisher()
    }

    func reduce(mutation: Mutation) {
        var newState = state

        switch mutation {
        case .countUp:
            newState.currentCount += 1
        }

        state = newState
    }

}

The code for getMegabytesUsed() is taken from the Apple Developer Forums.