[Suggestion] When diffing, printing only what has changed

[tgrapperon]

Hello,
I haven't looked seriously at the code yet, so I don't know if the following feature is easily achievable.
When the type has many fields, printing the difference between two values/instances can still generate a lot of text, even if the changes are minimal. Collections are compacted with “… (xx unchanged)”, but all the other properties are still printed, even if they haven't changed.
Would it be complex to implement some output style such as the output of some diff like:

  [
    [0]: Landmark(
      id: 1001,
      name: "Turtle Rock",
      park: "Joshua Tree National Park",
      state: "California",
      description: "This very large formation lies south of the large Real Hidden Valley parking lot and immediately adjacent to (south of) the picnic areas.",
-     isFavorite: true,
+     isFavorite: false,
      isFeatured: true,
      category: Category.rivers,
      imageName: "turtlerock",
      coordinates: Coordinates(…)
    ),
    … (11 unchanged)
  ]

becomes

  [
    [0]: Landmark(
      … (5 unchanged properties)
-     isFavorite: true,
+     isFavorite: false,
      … (4 unchanged properties)
    ),
    … (11 unchanged)
  ]

or even

  [
    [0]: Landmark(
-     isFavorite: true,
+     isFavorite: false,
      … (9 unchanged properties)
    ),
    … (11 unchanged)
  ]

?

[stephencelis]

@tgrapperon Thanks for starting the discussion! We actually tried this out, but in practice felt that it omitted too much context. We are trying to optimize for readability, and thought it can be helpful to know a bit more about the structure that changed than just the change itself.

In the example above, we can see that the 0-indexed landmark was unfavorited, but we'd have to do some digging to figure out which landmark that was, like if we wanted to know its ID or name, which are readily available in the other version.

In our experience structs usually don't grow too, too big, and so the extra lines of context haven't really "gotten in the way" yet. If you hit a point where you have a struct with 20 fields that may already be a sign that some of these fields could be grouped into their own types.

One thing about your diff that does stand out is the long description string. We automatically truncate unchanged multi-line strings, but we should probably also truncate strings that exceed a certain character count. I'll take a stab at that later today!

[tgrapperon]

Thanks @stephencelis!
Upon further investigation, it seems not as bad as I've experienced a few days ago. Maybe it was the old diffing algorithm in play after all. I'm jumping between Xcode 13 and 12, so it's possible I thought TCA was updated, whereas it wasn't in this version of Xcode.
The diff is from README.md BTW.