RequestLifetimeTracking forwardRequests: Duplicate keys were found in Dictionary about rxfeedback.swift HOT 6 CLOSED

struct ClassesStateMachine{
   //This is the State
         ...    
}

extension ClassesStateMachine {
    typealias FeedbackLoop = (Driver<ClassesStateMachine>) -> Signal<ClassesStateMachine.Event>

    struct Feedback {

	//This is the system driver, a reduced version of it
        static func statemachineFeedbackDriver(_ interactor: ClassesInteractorImp) -> Driver<ClassesStateMachine> {
		
		return Driver.system(initialState: ClassesStateMachine.initialState,
				     reduce: ClassesStateMachine.reduce,
				     feedback:
						Feedback.uiFeedback(interactor),
						Feedback.processInteractions(interactor))
        }


        //This is the feedback that will analyze the state and respond with a service execution. E.g. when the user interacts with the screen, like tapping a button to execute some logic in the backend.
	//It returns a Set of Statemachine to avoid cancelling pending services of previous loops (i.e. interactios generated in previous Statemachines)
        private static func processInteractions(_ interactor: ClassesInteractorImp) -> ClassesStateMachine.FeedbackLoop {

            let interactionToProcess : (ClassesStateMachine) -> Set<ClassesStateMachine> = { statemachine in
                if statemachine.interactionToProcess != nil {
                    return Set([statemachine])
                }
                return Set()
            }

            let processInteraction : (ClassesStateMachine) -> Signal<ClassesStateMachine.Event> = { (statemachine) in
                return interactor.executeInteraction(of:statemachine)
            }

            return react(requests: interactionToProcess, effects: processInteraction)
        }

	//This binds te UI with the state
        private static func uiFeedback(_ interactor : ClassesInteractorImp) -> ClassesStateMachine.FeedbackLoop {

            return bind {[unowned interactor] stateMachine in

                let subscriptions = [
                    stateMachine.drive(interactor.presenter.statemachineInput),
                ]

                let events : [Signal<ClassesStateMachine.Event>] = [ interactor.viewController.userEvents]

                return Bindings(subscriptions: subscriptions, events: events)
            }
        }
    }
}

extension ClassesInteractorImp {

    //An interaction is an action that the user can perform on the screen, containing the necessary data to execute a service
    func executeInteraction( of statemachine:ClassesStateMachine) -> Signal<ClassesStateMachine.Event> {

        guard let interaction = statemachine.interactionToProcess else {fatalError("The statemachine must have an interaction")}

        let service = self.service(for:interaction, of: statemachine)

        return service.asSignal(onErrorRecover: { .just( ClassesStateMachine.Event.didFail(interaction, error:$0)) })
    }

    //This will perform a service, i.e. talk to the backend, and create an event when the response is obtained.
    func service(for interaction: ClassesStateMachine.Interaction, of statemachine: ClassesStateMachine) -> Observable<ClassesStateMachine.Event>{

        switch interaction {

        case .doSomething :
            return doSomething(with: statemachine) // talks to the backend to doSomething and returns an Event in response

            ...
        }
}

struct ClassesStateMachine {
    var id : Int
}

extension ClassesStateMachine: Equatable {}
func == (lhs: ClassesStateMachine, rhs: ClassesStateMachine) -> Bool {
    return lhs.id == rhs.id
}