Compiler is unable to type-check this expression in reasonable time

[JaapWijnen]

Hey all! Really excited about the upcoming ReducerProtocol. I was migrating to the new stuff when I hit the following compiler error: The compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions

My new reducer looks as follows:

public struct ImageEditor: ReducerProtocol {
    public struct State: Equatable {
        public var settings: SettingsFeature.State
        public var editorMinimalStep: MinimalStep
        
        public var editorStep: Step {
            get {
                switch self.editorMinimalStep {
                case .imageInput(let input):
                    return .imageInput(input)
                case .imageProcessing(let processing):
                    return .imageProcessing(.init(sourceImage: processing.sourceImage, destinationImage: processing.destinationImage, settings: self.settings))
                }
            }
            set {
                switch newValue {
                case .imageInput(let input):
                    self.editorMinimalStep = .imageInput(input)
                case .imageProcessing(let processing):
                    self.editorMinimalStep = .imageProcessing(.init(sourceImage: processing.sourceImage, destinationImage: processing.destinationImage))
                    self.settings = processing.settings
                }
            }
        }
        
        public init(settings: SettingsFeature.State = .init(), editor: MinimalStep = .imageInput(.init())) {
            self.settings = settings
            self.editorMinimalStep = editor
        }
        
        public struct ImageProcessingMinimalState: Equatable {
            var sourceImage: NSImage
            var destinationImage: NSImage
        }
        
        public enum MinimalStep: Equatable {
            case imageInput(ImageInput.State)
            case imageProcessing(ImageProcessingMinimalState)
        }
        
        public enum Step: Equatable {
            case imageInput(ImageInput.State)
            case imageProcessing(ImageProcessing.State)
            
            public init() {
                self = .imageInput(.init())
            }
        }
    }

    public enum Action: Equatable {
        case imageInput(ImageInput.Action)
        case imageProcessing(ImageProcessing.Action)
    }
    
    public var mainQueue: AnySchedulerOf<DispatchQueue>
    public var onDropImage: OnDropImageClient
    public var renderer: RendererClient
    public var colorClamp: ColorClampClient
    
    public init(
        mainQueue: AnySchedulerOf<DispatchQueue>,
        onDropImage: OnDropImageClient,
        renderer: RendererClient,
        colorClamp: ColorClampClient
    ) {
        self.mainQueue = mainQueue
        self.onDropImage = onDropImage
        self.renderer = renderer
        self.colorClamp = colorClamp
    }

    public var body: some ReducerProtocol<State, Action> {
        Scope(state: \.editorStep, action: /.self) {
            Scope(state: \.imageInput, action: /Action.imageInput) {
                ImageInput(mainQueue: mainQueue, onDropImage: onDropImage)
            }
            Scope(state: \.imageProcessing, action: /Action.imageProcessing) {
                ImageProcessing(renderer: renderer, colorClamp: colorClamp)
            }
        }
        Reduce { state, action in
            switch action {
            case .imageInput(.onDropImageCompleted(.success(let image))):
                state.editorMinimalStep = .imageProcessing(.init(sourceImage: image, destinationImage: image))
                return .none
                
            case .imageInput(_):
                return .none
                
            case .imageProcessing(_):
                return .none
            }
        }
    }
}

The problem probably lies with the nested scope I have in there? Maybe this is not possible with the new approach I'm not a 100% sure.

public var body: some ReducerProtocol<State, Action> {
    Scope(state: \State.editorStep, action: /.self) {
        Scope(state: \.imageInput, action: /Action.imageInput) {
            ImageInput(mainQueue: mainQueue, onDropImage: onDropImage)
        }
        Scope(state: \.imageProcessing, action: /Action.imageProcessing) {
            ImageProcessing(renderer: renderer, colorClamp: colorClamp)
        }
    }
    Reduce { ... }
}

When I add a little hint to the reducer's first scope (above) I get the following new error message:
Generic parameter 'Child' could not be inferred (for the first scope) I guess this makes sense, since the two child scopes have 3 generics, ParentState and ParentAction which are equal, but their Child generic is different, ImageInput vs ImageProcessing.

Just wanted to point this out and see if there's any way around this? I can of course apply the parent scope to both reducers individually, but maybe there's a nicer way to go about it?

EDIT: Actually adding Scope to both doesn't work either, since this results in the error: Key path cannot refer to static member 'imageInput'

Scope(state: \State.editorStep, action: /.self) {
    Scope(state: \.imageInput, action: /Action.imageInput) {
        ImageInput(mainQueue: mainQueue, onDropImage: onDropImage)
    }
}

The reason the state looks like this is that. ImageProcessing.State also contains Settings.State but I want to pass this along from higher up to propagate changes made in a different feature. So in this case not 100% sure how to migrate this currently :) Help would be appreciated!

[mbrandonw]

Can you show us what the old style reducer looks like? That might help us understand what it should look like in the new style.

[tgrapperon]

Your Step is an enum, and you're using KeyPaths to scope into cases. The following should probably work:

Scope(state: \State.editorStep, action: /.self) {
    Scope(state: /Step.imageInput, action: /Action.imageInput) {
        ImageInput(mainQueue: mainQueue, onDropImage: onDropImage)
    }
    Scope(state: /Step.imageProcessing, action: /Action.imageProcessing) {
        ImageProcessing(renderer: renderer, colorClamp: colorClamp)
    }
}

[JaapWijnen]

Ah that did the trick thanks @tgrapperon! It even works for the two nested scopes. It just messes a bit with syntax highlighting unfortunately haha. Might be that this could still be improved by using ifCaseLet? But not sure.

[stephencelis]

Hopefully all of these issues will be solved when Swift gets native case path support. Till then we'll have to live with this 😅

If you'd like to dupe a feedback I filed: https://gist.github.com/stephencelis/4b1164de326cae51c5eaff7c752e3542

[tgrapperon]

Yes, this is Xcode highlighting seeing /…/ as a Regex literal. Fortunately, this is only a highlighting issue. It builds fine, even when displaying a SwiftUI Preview. If it really bothers you, you can jump a line before the action:, so the parser don't see two / on the same line.

[JaapWijnen]

@stephencelis how does that work exactly? Through what do you send these and do I add the FB11055523 id?
Also what is the status on a case paths proposal potentially? (is there a status? 😅 )

[stephencelis]

@JaapWijnen You can just reference FB11055523 and copy whatever you want from mine, but you'll have to file a new feedback from scratch. Mine's just a template.