isDeepEqual and negation in guard can break type

[dartess]

I get never for first isDeepEqual argument and I can't use it:

type Foo = {
    bar: string;
}

function reset(bar: string) {}

function effect(oldValue: Foo, newValue: Foo) {
    if (!R.isDeepEqual(oldValue, newValue)) {
        reset(oldValue.bar);
                    // ^ Property 'bar' does not exist on type 'never'.(2339)
    }
}

demo: https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBAKjgQwM5wEpwGZQiOAcigFMQSATZQgbgCg6YBPMEuAMQgjgF44BvOnGFwARsigAuOKhhRgAOwDm9AL4NsAVwUBjGMAgK4pVCRgAKcVJlzFSgJQD1dLbv2G4JbNhJ7zEABsKADVkAM0SaU4IABo4BRIAd1DwyI4uR0EROGBsOHMAQgwAOmBUABESEjAAUQBHTTD-IJSIuITksIj7TKFskRMzZpCukmKre3ps9VUgA

[Brodzko]

Hmm, R.isDeepEqual returns data is Foo in your case. Negating it, I would expect that "data is not Foo", which would mean never actually sounds correct 🤔 Though I'm pretty sure Typescript cannot reasonably negate type predicates.

Interestingly enough though, the above works with the data-last case, if it helps you as a quick workaround. Not sure why though.

function effect(oldValue: Foo, newValue: Foo) {
    if (!R.isDeepEqual(oldValue)(newValue)) {
        reset(oldValue.bar);
           // ^? is now `Foo`
    }
}

Updated TS Playground

[dartess]

Two variables can be of the same type and not be strictly equivalent.
Drawing conclusions about the type of a variable based on the strict equality of its value in this case does not sound correct, imo.
I would suggest removing the typeguard here.

[dartess]

quick workaround

Thanks, but it didn't work for me, IRL I use both values in code :)

[eranhirsch]

Thanks for reporting this; that's a good observation I missed when converting it to a narrowing type. I'll see if I can come up with a fix that would still support some narrowing where it works with typescript.

[Brodzko]

Two variables can be of the same type and not be strictly equivalent.

Drawing conclusions about the type of a variable based on the strict equality of its value in this case does not sound correct, imo.

I think the point was that if two objects are deeply equal, they necessarily are of the same type (since we don't have named types in TS).

Say oldValue was Foo but newValue was Foo | Bar. In that case, if R.deepEquals(oldValue, newValue), it makes total sense to expect newValue to be narrowed to Foo.

Rather than loosening the return type to boolean, I'd prefer fixing this to behave correctly, if possible.

[TkDodo]

🎉 This issue has been resolved in version 1.58.2 🎉

The release is available on:

• npm package (@latest dist-tag)
• GitHub release

Your semantic-release bot 📦🚀