Why does the identity function sometimes change whether patterns are exhaustive?

Question

Consider this GHCi session:

$ ghci
GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude> :set -Wincomplete-patterns -Wincomplete-uni-patterns
Prelude> foo t | (_, _) <- t = "Foo"
Prelude> bar t | (_, _) <- id t = "Foo"
Prelude> baz x | Just _ <- x = "Yes" | Nothing <- x = "No"
Prelude> qux x | Just _ <- id x = "Yes" | Nothing <- id x = "No"

<interactive>:3:1: warning: [-Wincomplete-patterns]
    Pattern match(es) are non-exhaustive
    In an equation for ‘qux’: Patterns not matched: _
Prelude>

Why is qux considered incomplete by GHC? Do we really know more about id x than we do about x? And why isn't bar also considered incomplete for the same reason that qux is?

Or for a possibly clearer example:

foo f x
  | Just _ <- f x = "Yes"
  | Nothing <- f x = "No"

bar f x = case f x of
  Just _ -> "Yes"
  Nothing -> "No"

As far as I know, those are exactly equivalent, but the former produces the warning and the latter does not.

Answer 1

It looks like GHC doesn't consider identical expressions to be the same value in a pattern guard unless the expression is a single binding:

Prelude> f | Just x <- Just 1 = "foo" | Nothing <- Just 1 = "bar"

<interactive>:5:1: warning: [-Wincomplete-patterns]
    Pattern match(es) are non-exhaustive
    In an equation for ‘f’: Guards do not cover entire pattern space

This is even more silly, in that it's clear the patterns are exhaustive. It can't even branch.

I'd say that this is probably the right way to do things, even if it's weird. It encourages binding the expression to a name, which is helpful for ensuring the expression is only evaluated once. It's certainly a roundabout way of doing it, though.

As for why you're not getting that error in bar, it's because there's only one constructor for pairs. You're matching every possible output of id t, even if it's a computed expression. There's no alternative constructor you haven't matched.