[Haskell-cafe] Syntax extension - adding import support to let/where bindings

[Yuras Shumovich]

Hello,

Haskell definitely needs better namespace story, so +1.

On Wed, 2015-08-05 at 11:28 +0100, Oliver Charles wrote:
> Hi all,
> 
> I'm sure this has come up before, but a quick bit of Googling didn't 
> reveal
> any prior discussions (if you known any, let me know), so I'm kicking 
> off a
> new discussion.

Probably this blog post will be interesting for you:
http://blog.haskell-exists.com/yuras/posts/namespaces-modules-qualified
-imports-and-a-constant-pain.html

> 
> I find myself wanting to be able to say something like:
> 
> foo = ...
>   where import Something.Specific

Then GHC will need to parse all the source code in order to build
dependency tree. Also people may want to build dependency tree in their
minds too, it is easier with global imports (in the module header.)
What about the next:

-- In the module header:
import qualified Something.Specific as Specific
...
-- Somewhere else:
foo = ...
  where import Specific -- Note: importing by module alias

Thanks,
Yuras

> 
> The result would be to import the contents of Something.Specific into 
> the
> scope of foo and its other where bindings, but not import into the 
> rest of
> the module that foo is defined in. As a motivating example, I'm 
> currently
> working on building some HTML in Haskell, and the amount of symbols 
> that
> come into scope is huge, when you have a DSL for both CSS and HTML - 
> the
> real pain point being that you get symbols that often conflict.
> 
> Here's an example of something that doesn't type-check currently
> 
> image =
>   img [ width 50, style [ width (px 50) ] ]
> 
> width here is both a symbol in the HTML DSL and the CSS DSL, but to 
> get
> this to type check I need to write something like
> 
> image =
>   img [ HTML.width 50, style [ CSS.width (CSS.px 50) ] ]
> 
> That's not particularly bad here, the really pain is repeatedly 
> having to
> do this for every single symbol I'm using. I'd prefer to be able to 
> write
> 
> image =
>   let css = let import CSS in [ width (px 50) ]
>   in let import HTML in img [ width 50, style css ]
> 
> This is a little bit of a contrived rewrite, but hopefully it shows 
> you
> what I'd like to be able to do. Please don't fixate too much on this
> example, it's only intended to illustrate the idea. When defining a 
> large
> amount of inline styles I think this pays off - I import once to 
> bring all
> the symbols I need into scope, rather than having to qualify every 
> symbol.
> 
> In reality, it will lead to me writing code like:
> 
> myDocument = html
>   where html =
>           div [ style containerStyle ]
>               [ div [ style rowStyle ] "Hello"
>               , div [ style rowStyle ] "World!" ]
>           where import HTML
>         containerStyle =
>           [ backgroundColor ..., padding ..., margin ... ]
>           where import CSS
>         rowStyle =
>           [ backgroundColor ..., padding ..., margin ... ]
>           where import CSS
> 
> At present the suggestion is a syntax error, so I'm hoping that part 
> won't
> be too controversial.
> 
> Thoughts?
> *ocharles*