Pattern variables bound by PatternGuards are not accessible in where clause

Consider:

foo :: Int -> Bool
foo a | Just b <- return a = c
  where c = a == b

I get:

test.hs:3:18: Not in scope:  b 

Is there any reason why pattern variables originating from pattern guards should not work in where clauses? Problem is present in GHC HEAD too.

Trac metadata

Trac field	Value
Version	7.10.3
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed weight to 5

added Tbug Trac import labels

Trac metadata

Trac field	Value
TypeOfFailure	OtherFailure → ValidProgramRejected

closed

Right now, GHC works the other way, accepting this:

foo :: Int -> Int
foo x
  | should_add = x + 1
  | otherwise  = x - 1
  where
    should_add = x > 0

I've not checked to see whether this is specified in the Report, but my guess is that it is.

I'm closing as invalid, but do reopen if I've misunderstood.

Trac metadata

Trac field	Value
Resolution	Unresolved → ResolvedInvalid

Replying to [ticket:12188#comment:121478 goldfire]:

Right now, GHC works the other way, accepting this:

foo :: Int -> Int
foo x
| should_add = x + 1
| otherwise  = x - 1
where
should_add = x > 0

I've not checked to see whether this is specified in the Report, but my guess is that it is.

I'm closing as invalid, but do reopen if I've misunderstood.

I am not sure whether we are on the same page. In your example should_add is a boolean guard, it does not establish a new binding.

In my example b is a pattern variable bound by the pattern guard. Your example does not contain such a thing. Your should_add use is morally equivalent to my return (and a) use.

Do you still think this ticket is invalid?

Richard is right. In Haskell

• The patterns of the function definition scope over guards, where clause, and body
• The where clause scopes over the guards, and body.
• The guards scope over the body only

Once could define the language differently, but that's the way it is in Haskell.

You can include let-binding in the guards, if you want:

foo :: Int -> Bool
foo a | Just b <- return a
      , let c = a == b
      = c

Replying to [ticket:12188#comment:121485 simonpj]:

Richard is right. In Haskell

• The patterns of the function definition scope over guards, where clause, and body
• The where clause scopes over the guards, and body.
• The guards scope over the body only

Once could define the language differently, but that's the way it is in Haskell.

Oh, pity. Surely those rules were set in stone when pattern guards weren't a thing yet. Thanks for the let tip, I'll look into it and see how it helps in my case.

You can include let-binding in the guards, if you want:

foo :: Int -> Bool
foo a | Just b <- return a
, let c = a == b
= c

Since a single where block can scope over multiple guarded right-hand sides, it doesn't make sense to have variables bound in a guard be in scope in the body of the where clause anyways.

added Pnormal label