A value is not fixed in `case ~ of` - haskell

Question

My situation:
In my code, a value xID seems to be variable in case ~ of structure.
import Debug.Trace
data I = I
{ iID :: Int } deriving Show
data C = C
{ i :: I} deriving Show
x = I 0
aC2 = C (I 2)
aC3 = C (I 3)
aC5 = C (I 5)
xID = iID x
cConverter aC =
trace ((show cIID) ++ (if cIID == xID then "==" else "/=") ++ (show xID) ++ " when " ++ (show x)) $
"Point: " ++ pID
where
pID :: String
pID =
case cIID of
xID -> trace ((show cIID) ++ (if cIID == xID then "==" else "/=") ++ (show xID) ++ " when " ++ (show x)) "X"
_ -> show cIID
cIID = iID . i $ aC
-- xID = iID x
What I expect
I expected that when I run cConverter aC2, I'll get "2" because 2 in aC2 = C (I 2) is not equal to 0 in x = I 0.
What happens
However, I've faced the strange result when I run cConvert aC2 like:
Main> cConverter aC2
"2/=0 when I {iID = 0}
Point: 2==2 when I {iID = 0}
X"
Why I get "X" instead of "2"?
More precisely, Why xID is 2 when cIID is 2, and xID is 3 when cIID is 3?
I think xID always be 0 in this code, but does xID means something other when I use this in the condition of the case?
Clear sample
Here is more clear code without debugging message
data I = I
{ iID :: Int } deriving Show
data C = C
{ i :: I} deriving Show
x = I 0
aC2 = C (I 2)
aC3 = C (I 3)
aC5 = C (I 5)
xID = iID x
cConverter aC =
"Point: " ++ pID
where
pID :: String
pID =
case cIID of
xID -> "X"
_ -> show cIID
cIID = iID . i $ aC
-- xID = iID x
Point 1
GHCi warns me like:
Bug.hs:22:7: Warning:
Pattern match(es) are overlapped
In a case alternative: _ -> ...
It seems to be xID overlaps _.
But why xID overlaps hole?
Anyway, I avoid this problem by using a guard instead of case.
However, I could not understand what happens with my code.

Answer 1

The case
case cIID of
xID -> ...
_ -> ...
introduces a new local variable named xID, which is unrelated to the global xID. Further, since it is a variable it catches everything: the branch _ -> ... will never be taken.
Use this instead:
case cIID of
xID' | xID' == xID -> ...
_ -> ...
or, more simply,
if cIID == xID
then ...
else ...
About "why" it works in this way:
Consider the code
foo :: Either Int String -> Int
foo e = case e of
Left x -> x
Right y -> length y
This is a nice total function: it will always return an Int whatever is the value of the argument e.
Now suppose I add to the code, much later on,
x :: Int
x = 42
This should NOT break foo! Yet, if the x in Left x is now interpreted to be 42, then function foo will crash on e.g. Left 43.
For this reason, pattern matching always introduces new variables, it never performs equality checks with pre-existing variables. To do that, use a guard like x | x == y -> ....