Proposal: Scoping rule change
iavor.diatchki at gmail.com
Wed Jul 25 18:46:13 CEST 2012
I also think that this is a good idea.
To address Manuel's nitpick, here is an example that would break if
`I` starts exporting `foo`.
module M(foo) where
foo = True
To Ganesh's point: I think that this change would be useful, even if
one is willing to list all names in all imports explicitly, because it
makes it possible to leave off qualifiers on names defined in the
current module, which reduces clutter. Here is an example that I run
into quite often:
module Data.MyList (empty) where
import Text.PrettyPrint as P (empty)
empty = 
singleton x = x : Data.MyList.empty
singleton x = x : empty -- using new scoping rule
ppList = ... P.empty ... -- We only need to qualify imported things
Note that with the new scoping rule we wouldn't need to ever use the
current module as a qualifier, which is kind of nice, especially since
we have no way to give it a shorter name (like we can for imports).
On Mon, Jul 23, 2012 at 5:28 PM, Lennart Augustsson
<lennart at augustsson.net> wrote:
> It's not often that one gets the chance to change something as
> fundamental as the scoping rules of a language. Nevertheless, I would
> like to propose a change to Haskell's scoping rules.
> The change is quite simple. As it is, top level entities in a module
> are in the same scope as all imported entities. I suggest that this
> is changed to that the entities from the module are in an inner scope
> and do not clash with imported identifiers.
> Why? Consider the following snippet
> module M where
> import I
> foo = True
> Assume this compiles. Now change the module I so it exports something
> called foo. After this change the module M no longer compiles since
> (under the current scoping rules) the imported foo clashes with the
> foo in M.
> Pros: Module compilation becomes more robust under library changes.
> Fewer imports with hiding are necessary.
> Cons: There's the chance that you happen to define a module identifier
> with the same name as something imported. This will typically lead to
> a type error, but there is a remote chance it could have the same
> Implementation status: The Mu compiler has used the scoping rule for
> several years now and it works very well in practice.
> -- Lennart
> Haskell-prime mailing list
> Haskell-prime at haskell.org
More information about the Haskell-prime