Any ideas why the reducers are receiving 2 times each action?

[ivangodfather]

So after entering "a" I'm receiving

Called twice also
Called twice
Called twice also
Called twice
received action:
  AppAction.childAction(
    ChildAction.nameChanged("A")
  )
  AppState(
-   childState: ChildState(name: "")
+   childState: ChildState(name: "A")
  )

received action:
  AppAction.childAction(
    ChildAction.nameChanged("A")
  )
  (No state changes)

import ComposableArchitecture
import SwiftUI

@main
struct TestApp: App {
    var body: some Scene {
        WindowGroup {
			ContentView(store: .init(initialState: AppState(), reducer: combinedReducer, environment: AppEnvironment()))
        }
    }
}

struct ContentView: View {
	var store: Store<AppState, AppAction>
	var body: some View {
		WithViewStore(self.store) { viewStore in
			ChildView(store: store.scope(state: \.childState, action: AppAction.childAction))
		}
	}
}

struct ChildView: View {
	var store: Store<ChildState, ChildAction>
	var body: some View {
		WithViewStore(store) { viewStore in
			TextField(
				"Enter name",
				text: viewStore.binding(get: \.name, send: ChildAction.nameChanged)
			)
		}
	}
}


struct AppState: Equatable {
	var childState = ChildState()
}
enum AppAction: Equatable {
	case childAction(ChildAction)
}
struct AppEnvironment {}

let appReducer = Reducer<AppState, AppAction, AppEnvironment> { s, a, e in
	switch a {
	case .childAction(let action):
		print("Called twice also")
		return .none
	}
}

struct ChildState: Equatable {
	var name = ""
}
enum ChildAction: Equatable {
	case nameChanged(String)
}
struct ChildEnvironment {}
let childReducer = Reducer<ChildState, ChildAction, ChildEnvironment> { s, a, e in
	switch a {
	case .nameChanged(let name):
		s.name = name
		print("Called twice")
		return .none
	}
}

let combinedReducer = appReducer.combined(with: childReducer.pullback(state: \.childState, action: /AppAction.childAction, environment: { _ in ChildEnvironment()} ))

[tgrapperon]

That's some standard issue with Textfield and you have the same issue in vanilla SwiftUI:

struct ContentView: View {
  @State var text: String = ""
  var body: some View {
    TextField(
      "",
      text: Binding(
        get: { text },
        set: {
          print("Set:", $0)
          self.text = text
        }
      )
    )
  }
}

In this configuration the binding's setter is activated twice for each key stroke. This is caused by the way UI/NSTextField are wrapped in SwiftUI, and I don't think there is much you can do prevent it.

You can probably mitigate the effect by debouncing the action. Other solutions that would count the actions would make you assume that this behavior is constant, which is not guaranteed. Of course, if this isn't having any side-effect in your project, you can disregard the issue, as this is not caused by something you're doing wrong with TCA.

As an aside, I would recommend to keep a handle to your root store somewhere: if for some reason the WindowGroup reruns its body, your whole app state will be reset. You can keep a reference to the store as a static or top level variable, or in a @State variable that will be preserved in any case this event happens.

[jshier]

I have an extension on Binding where Value: Equatable to ensure the update is fully unique (so it's more applicable to text than removeDuplicates()). This ensures those duplicate updates are always removed.

func uniqueUpdates() -> Self {
    var delta: (current: Value, next: Value)?
    return Binding {
        wrappedValue
    } set: { newValue, transaction in
        guard delta?.current != wrappedValue, delta?.next != newValue else { return }

        delta = (current: wrappedValue, next: newValue)
        self.transaction(transaction).wrappedValue = newValue
    }
}