Opened 4 weeks ago

Closed 2 weeks ago

#14395 closed bug (invalid)

Redefining pattern synonym in GHCi triggers "‘p’ is untouchable" error

Reported by: RyanGlScott Owned by:
Priority: normal Milestone:
Component: Compiler (Type checker) Version: 8.2.1
Keywords: PatternSynonyms Cc:
Operating System: Unknown/Multiple Architecture: Unknown/Multiple
Type of failure: None/Unknown Test Case:
Blocked By: Blocking:
Related Tickets: Differential Rev(s):
Wiki Page:

Description

Load this file into GHCi:

{-# LANGUAGE GADTs #-}
{-# LANGUAGE PatternSynonyms #-}
module Bug where

data Foo a where
  FooInt :: Foo Int

pattern Bar :: () => (a ~ Int) => Foo a
pattern Bar = FooInt

And attempt to redefine Bar as follows:

$ /opt/ghc/8.2.1/bin/ghci Bug.hs
GHCi, version 8.2.1: http://www.haskell.org/ghc/  :? for help
Loaded GHCi configuration from /home/rgscott/.ghci
[1 of 1] Compiling Bug              ( Bug.hs, interpreted )
Ok, 1 module loaded.
λ> pattern Bar = Nothing

<interactive>:1:15: error:
    • Couldn't match expected type ‘p’ with actual type ‘Maybe a0’
        ‘p’ is untouchable
          inside the constraints: a ~ Int
          bound by a pattern with pattern synonym:
                     Bar :: forall a. () => a ~ Int => Foo a,
                   in an equation for ‘pattern’
          at <interactive>:1:9-11
      ‘p’ is a rigid type variable bound by
        the inferred type of pattern :: Foo a -> p at <interactive>:1:1-21
      Possible fix: add a type signature for ‘pattern’
    • In the expression: Nothing
      In an equation for ‘pattern’: pattern Bar = Nothing
    • Relevant bindings include
        pattern :: Foo a -> p (bound at <interactive>:1:1)

There are two issues here:

  1. There are several places in the error message that refer to a pattern with no name!
                   in an equation for ‘pattern’
        the inferred type of pattern :: Foo a -> p at <interactive>:1:1-21
    • Relevant bindings include
        pattern :: Foo a -> p (bound at <interactive>:1:1)
  1. Why is this error happening in the first place? The error message mentions the type Foo a -> p, but in pattern Bar = Nothing, there isn't anything that should touch Foo.

Note that this bug does not occur if a slightly different (but ostensibly equivalent) type signature for Bar is given in the original source file:

{-# LANGUAGE GADTs #-}
{-# LANGUAGE PatternSynonyms #-}
module Works where

data Foo a where
  FooInt :: Foo Int

pattern Bar :: Foo Int
pattern Bar = FooInt
λ> pattern Bar = Nothing
λ> :i Bar
pattern Bar :: Foo Int

Change History (2)

comment:1 Changed 2 weeks ago by simonpj

The error message is indeed confusing, but I think what is happening is this

  • You load Bug.hs
  • But the interactive context does not have -XPatternSynonyms
  • So when you say
    pattern Bar = Nothing
    
    GHCi doesn't see pattern as a keyword; it sees it as a perfectly ordinary identifier. So its' as if you had written
    f Bar = Nothing
    
    to define function f.
  • That's why it says, for example
                       in an equation for ‘pattern’
    
    Quite right! This is a function definition for function pattern.

It would be cool if it said "Perhaps you meant to use PatternSynonuyms" but I don't really see where to put such a test.

Anyway I think it's a case of: not a bug, just a confusing error message.

comment:2 Changed 2 weeks ago by RyanGlScott

Resolution: invalid
Status: newclosed

I'll be darned—you're absolutely right, I just lucked out with pattern Bar :: Foo Int and managed to get pattern Bar = Nothing (or really, f Bar = Nothing) to compile even in the absence of PatternSynonyms.

Note: See TracTickets for help on using tickets.