Additional requirement for CasePathIterable protocol

[RoBo-Inc]

public protocol CasePathIterable: CasePathable
where AllCasePaths: Sequence, AllCasePaths.Element == PartialCaseKeyPath<Self>, 
AllCasePaths: CasePathReflectable<Self> {}

Why wouldn’t we add the AllCasePaths: CasePathReflectable<Self> requirement to the CasePathIterable protocol? In practice, this is always the case anyway. So, it’s not even a "requirement" but rather a factual statement. As evidence of this, the entire library still compiles immediately after adding this additional line, without any further adjustments.

If added, it would greatly simplify the following code, making the implementation more straightforward:

extension CasePathIterable {
    public var leafCaseKeyPath: PartialCaseKeyPath<Self> {
        var path: PartialCaseKeyPath<Self> = \.self
        var value: (any CasePathIterable)? = self
        while let next = value?.associatedValue(&path) { value = next }
        return path
    }
    
    private func associatedValue<T>(_ path: inout PartialCaseKeyPath<T>) -> (any CasePathIterable)? {
        Self.allCasePaths.lazy.compactMap { (casePath) -> (any CasePathIterable)? in
            guard let assValue = self[case: casePath] else { return nil }
            path = path.appending(path: casePath)!
            return assValue as? any CasePathIterable
        }.first
    }
}

And, most importantly, more efficient (I'm not quite sure about this though).
This function seems to be very handy in some situations when working with TCA.

Some more details can be found in this Slack post and its 🧵

[stephencelis]

@RoBo-Inc The main reason is backwards compatibility, but we could consider this breaking change (and others) for 2.0, unless you have ideas on how to make this change in a backwards compatible way.

[RoBo-Inc]

Actually there is a way to make this change backwards compatible 😳 Instead of adding a new requirement to CasePathIterable protocol we can just (temporary, till version 2.0) introduce a brand new protocol:

public protocol CasePathSelfReflectable: CasePathable
where AllCasePaths: CasePathReflectable<Self> {}

and adjust the macros so that it also generate conformance for enums to this new protocol as well:

extension MyEnum: CasePaths.CasePathable, CasePaths.CasePathIterable, CasePaths.CasePathSelfReflectable {
}

This will do the trick and this is backwards compatible ✅
In the future, in version 2.0, we could merge the two protocols: CasePathIterable + CasePathSelfReflectable into a single protocol CasePathIterable with additional requirement (as I suggested initially).

Should I prepare the PR? ☺️

[stephencelis]

@RoBo-Inc Is it correct that such a protocol could be introduced in your own project to work around the issue? If so I think that maybe describing the workaround in manual conformance documentation might be preferred over adding surface area to the library that will be removed, especially since it's tough to come up with a good name here.

[RoBo-Inc]

Yeah, let's just wait for 2.0.0 then 😃
Don't forget to include the change to the "2.0.0 to do list" ☺️