Aliasing current module qualifier

Simon Peyton Jones simonpj at
Tue Sep 30 18:20:17 UTC 2014

If there is to be such a language feature, I strongly feel it should be via something like
               module Long.Name.M( f, g, h ) as K where ...

I do not want to try to piggy-back on the possible meaning of a self-import; it’s just asking for trouble, as Iavor points out.

Using “as M” in the module header would be simple.  It is easy to explain and fairly easy to implement.   I don’t think there are any knock-on complications.  So if enough people want it, and someone is prepared to implement it (with a language extension flag of course), then I’d be OK with that.   I’m unsure that it’s worth the effort, but I’m happy to let users decide.


From: Glasgow-haskell-users [mailto:glasgow-haskell-users-bounces at] On Behalf Of Iavor Diatchki
Sent: 30 September 2014 13:18
To: john at
Cc: GHC Users Mailing List; ghc-devs; Herbert Valerio Riedel
Subject: Re: Aliasing current module qualifier


What semantics are you using for recursive modules?  As far as I see, if you take a least fixed point semantics (e.g. as described in "A Formal Specification for the Haskell 98 Module System", ) this program is incorrect as the module does not export anything.

While this may seem a bit counter intuitive at first, this semantics has the benefit of being precise, easily specified, and uniform (e.g it does not require any special treatment of the " current " module).  As an example, consider the following variation of your program, where I just moved the definition in a sperate (still recursive) module:

module A (M.x) where
  import B as M

module B (M.x) where
  import A as M
  x = True

I think that it'd be quite confusing if a single recursive module worked differently then a larger recursive group, but it is not at all obvious why B should export 'x'.  And for those who like this kind of puzzle: what should happen if 'A' also had a definition for 'x'?

On Sep 29, 2014 11:02 PM, "John Meacham" <john at<mailto:john at>> wrote:
You don't need a new language construct, what i do is:

     module AnnoyinglyLongModuleName (M.length, M.null) where

    import AnnoyinglongLongModuleName as M

I think ghc would need to be extended a little to make this convienient as it doesn't handle recursive module imports as transparently.


On Mon, Sep 29, 2014 at 8:47 AM, Brandon Allbery <allbery.b at<mailto:allbery.b at>> wrote:
On Mon, Sep 29, 2014 at 4:19 AM, Herbert Valerio Riedel <hvr at<mailto:hvr at>> wrote:
Now it'd be great if I could do the following instead:

    module AnnoyinglyLongModuleName (M.length, M.null) where

    import AnnoyinglyLongModuleName as M -- <- does not work

I think if I wanted this syntax, I'd go for:

    module AnnoyinglyLongModuleName as M where ...

brandon s allbery kf8nh                               sine nomine associates
allbery.b at<mailto:allbery.b at>                                  ballbery at<mailto:ballbery at>
unix, openafs, kerberos, infrastructure, xmonad

Glasgow-haskell-users mailing list
Glasgow-haskell-users at<mailto:Glasgow-haskell-users at>

John Meacham -

ghc-devs mailing list
ghc-devs at<mailto:ghc-devs at>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the Glasgow-haskell-users mailing list