Specifying language extensions
patrykz at cse.unsw.edu.au
Thu Feb 2 19:11:31 EST 2006
One issue that pains me with Haskell 98 is that it does nothing about
one of its
original stated goals as a programming language.
I've always been very fond of pointing out that Haskell has been
designed as a
language for EXPERIMENTATION with language features, and therefore the
mind-boggling number of extensions in GHC is a good thing, not a bad
This will NOT change with Haskell' - we already know that at least
feature which is in high demand (functional dependencies) is far from
However, the language, at the current point, does nothing towards
keeping track of the language extensions in use by a particular piece
To make things worse, many extension require lexical and/or syntactic
changes to the language. Some extensions in the past proved to be
and not all compilers implement all extensions.
So, looking at a particular piece of code, how do we know which compiler
it can be compiled with, and which command-line flags do we pass to
compiler? The answer is, simply, we don't.
Currently, we do this by introducing ugly GHC-specific pragmas, comments
in the documentation, and a plethora of similar half-measures.
I would like to propose a language feature to address this concern
for all. I know that a similar proposal has been circulated on the
mailing list in the past, but to the best of my knowledge, none of
tickets addresses this problem.
Add explicit syntax for documenting language extensions required by a
* Current language does not provide a uniform extension mechanism.
* Pragmas (as currently used in GHC) are NOT suitable for this.
by their design they are COMMENTS, and therefore should have no
the language semantics. Unrecognized pragmas should be ignorable
warnings, while, currently, if you omit the GHC options pragma
for a module
that requires some syntactic extension, you will receive
thousands of lexical
and syntactic errors completely unrelated to your extension.
* I /strongly/ believe that compiler pragmas should ONLY be used for
extensions (such as INLINE, various SPECIALIZE, etc.) that have
on the program semantics.
Add an "extension" clause to the language.
To avoid introduction of a new keyword, I propose to use the
module -> [extensions;] "module" modid [exports] "where" body
extensions -> extension_1 ; ... ; extension_n
extension -> "import" "extension" varid [extparam_1 ... extparam_n]
extparam -> varid | conid | literal
A module using some GHC woo-hah extension would look like:
import extension GHC "woo-hah!"
module Foo ...
Or, if an extension is common enough:
import extension fundeps
module Foo ...
This is a very conservative syntax. It does not support grouping,
renaming of extensions (as previously circulated on the haskell
which I personally believe would be very a bad idea. I want to be
able to look
at a piece of Haskell code and tell immediately which extensions it
without being forced to browse through the included modules, etc.
Extensions would NOT be exported by a module that uses that
extension, but would
have to be specified separately by each module that uses the
by that extension. For example, one often hides uses of unboxed
dependencies, etc, behind a curtain of abstract data types, and
such data type
implemented using non-standard features can be happily used within
Haskell programs. On the other hand, if an extension is visible in
exported by a module, it has to be named explicitly (with "import
by any module importing that interface.
Extensions could be parametized, since I can readily imagine
would require such a thing. I would also recommend in the standard
compiler groups its own extensions under a common name (for
example, GHC, HUGS,
JHC, NHC, etc.) until they are in sufficiently common use to be
independently (such as fundeps), at which stage there should
probably be a
corresponding addendum to the standard for that extension.
Specifying extensions before the "module" keyword ensures that the
parser can find them before parsing of the actual module. I
bare modules without the "module" keyword cannot specify any
therefore must be written in pure Haskell'.
The standard itself should not define any extensions and state that
standard grammar and semantics describes the base language in
any "import extension" clauses.
Each extension, including FFI, should be described in a separate
* Addresses a pending language design goal.
* Useful for automatic documentation tools such as Haddock, which
even generate a hyperlink from an extension name to the relevant
addendum when available.
* Simple to implement.
* Neat syntax.
* Backwards-compatible (introduces no keyword polution.)
* Makes all information required to compile a program available
in the source code, rather than in ad-hoc places such as command-
Cabal package descriptions, documentation, comments, pragmas and
* Returns all comments (including pragmas) to their original code as
semantically-neutral annotations on the source program.
* Some implementation hassles. The compiler must use either a
parser and lexer (I believe most do already) or else parse the
until it finds the "module" keyword collecting the extension
and then parse the actual module using an appropriate parser and
lexer chosen according to the specified extensions.
What do people think? I would like to throw the idea around on the
list before entering it into the ticket system.
More information about the Haskell-prime