<indexterm><primary>GHC, using</primary></indexterm>
<indexterm><primary>using GHC</primary></indexterm>
- <para>GHC can work in one of three “modes”:</para>
-
- <variablelist>
- <varlistentry>
- <term><cmdsynopsis><command>ghc</command>
- <arg choice=plain>--interactive</arg>
- </cmdsynopsis></term>
- <indexterm><primary>interactive mode</primary>
- </indexterm>
- <indexterm><primary>ghci</primary>
- </indexterm>
- <listitem>
- <para>Interactive mode, which is also available as
- <command>ghci</command>. Interactive mode is described in
- more detail in <xref linkend="ghci">.</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><cmdsynopsis><command>ghc</command>
- <arg choice=plain>--make</arg>
- </cmdsynopsis></term>
- <indexterm><primary>make mode</primary>
- </indexterm>
- <indexterm><primary><option>--make</option></primary>
- </indexterm>
- <listitem>
- <para>In this mode, GHC will build a multi-module Haskell
- program automatically, figuring out dependencies for itself.
- If you have a straightforward Haskell program, this is
- likely to be much easier, and faster, than using
- <command>make</command>.</para>
- </listitem>
- </varlistentry>
+ <para>GHC can work in one of three “modes”:</para>
+
+ <variablelist>
+ <varlistentry>
+ <term><cmdsynopsis><command>ghc</command>
+ <arg choice=plain>––interactive</arg>
+ </cmdsynopsis></term>
+ <indexterm><primary>interactive mode</primary>
+ </indexterm>
+ <indexterm><primary>ghci</primary>
+ </indexterm>
+ <listitem>
+ <para>Interactive mode, which is also available as
+ <command>ghci</command>. Interactive mode is described in
+ more detail in <xref linkend="ghci">.</para>
+ </listitem>
+ </varlistentry>
- <varlistentry>
- <term><cmdsynopsis>
- <command>ghc</command>
- <group>
- <arg>-E</arg>
- <arg>-C</arg>
- <arg>-S</arg>
- <arg>-c</arg>
- </group>
- </cmdsynopsis></term>
- <indexterm><primary><option>--make</option></primary>
- </indexterm>
- <listitem>
- <para>This is the traditional batch-compiler mode, in which
+ <varlistentry>
+ <term><cmdsynopsis><command>ghc</command>
+ <arg choice=plain>––make</arg>
+ </cmdsynopsis></term>
+ <indexterm><primary>make mode</primary>
+ </indexterm>
+ <indexterm><primary><option>––make</option></primary>
+ </indexterm>
+ <listitem>
+ <para>In this mode, GHC will build a multi-module Haskell
+ program automatically, figuring out dependencies for itself.
+ If you have a straightforward Haskell program, this is likely
+ to be much easier, and faster, than using
+ <command>make</command>.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term><cmdsynopsis>
+ <command>ghc</command>
+ <group>
+ <arg>-E</arg>
+ <arg>-C</arg>
+ <arg>-S</arg>
+ <arg>-c</arg>
+ </group>
+ </cmdsynopsis></term>
+ <indexterm><primary><option>-E</option></primary></indexterm>
+ <indexterm><primary><option>-C</option></primary></indexterm>
+ <indexterm><primary><option>-S</option></primary></indexterm>
+ <indexterm><primary><option>-c</option></primary></indexterm>
+ <listitem>
+ <para>This is the traditional batch-compiler mode, in which
GHC can compile source files one at a time, or link objects
together into an executable.</para>
- </listitem>
- </varlistentry>
- </variablelist>
-
+ </listitem>
+ </varlistentry>
+ </variablelist>
+
<sect1>
<title>Options overview</title>
<variablelist>
<varlistentry>
- <term><literal>-help</literal></term>
- <term><literal>-?</literal></term>
- <indexterm><primary><literal>-?</literal></primary></indexterm>
- <indexterm><primary><literal>-help</literal></primary></indexterm>
+ <term><option>––help</option></term>
+ <term><option>-?</option></term>
+ <indexterm><primary><option>-?</option></primary></indexterm>
+ <indexterm><primary><option>––help</option></primary></indexterm>
<listitem>
<para>Cause GHC to spew a long usage message to standard
output and then exit.</para>
</varlistentry>
<varlistentry>
- <term><literal>-v</literal></term>
- <indexterm><primary><literal>-v</literal></primary></indexterm>
+ <term><option>-v</option></term>
+ <indexterm><primary><option>-v</option></primary></indexterm>
<listitem>
<para>The <option>-v</option> option makes GHC
<emphasis>verbose</emphasis>: it reports its version number
</varlistentry>
<varlistentry>
- <term><literal>-v</literal><replaceable>n</replaceable></term>
+ <term><option>-v</option><replaceable>n</replaceable></term>
<indexterm><primary><option>-v</option></primary></indexterm>
<listitem>
<para>To provide more control over the compiler's verbosity,
<variablelist>
<varlistentry>
- <term><literal>-v0</literal></term>
+ <term><option>-v0</option></term>
<listitem>
<para>Disable all non-essential messages (this is the
default).</para>
</varlistentry>
<varlistentry>
- <term><literal>-v1</literal></term>
+ <term><option>-v1</option></term>
<listitem>
<para>Minimal verbosity: print one line per
compilation (this is the default when
- <option>--make</option> or
- <option>--interactive</option> is on).</para>
+ <option>––make</option> or
+ <option>––interactive</option> is on).</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><literal>-v2</literal></term>
+ <term><option>-v2</option></term>
<listitem>
<para>Print the name of each compilation phase as it
is executed. (equivalent to
</varlistentry>
<varlistentry>
- <term><literal>-v3</literal></term>
+ <term><option>-v3</option></term>
<listitem>
<para>The same as <option>-v2</option>, except that in
addition the full command line (if appropriate) for
</varlistentry>
<varlistentry>
- <term><literal>-v4</literal></term>
+ <term><option>-v4</option></term>
<listitem>
<para>The same as <option>-v3</option> except that the
intermediate program representation after each
</varlistentry>
<varlistentry>
- <term><literal>--version</literal></term>
- <indexterm><primary><literal>--version</literal></primary></indexterm>
+ <term><option>-V</option></term>
+ <term><option>––version</option></term>
+ <indexterm><primary><option>-V</option></primary></indexterm>
+ <indexterm><primary><option>––version</option></primary></indexterm>
<listitem>
<para>Print a one-line string including GHC's version number.</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><literal>--numeric-version</literal></term>
- <indexterm><primary><literal>--numeric-version</literal></primary></indexterm>
+ <term><option>––numeric-version</option></term>
+ <indexterm><primary><option>––numeric-version</option></primary></indexterm>
<listitem>
<para>Print GHC's numeric version number only.</para>
</listitem>
</varlistentry>
+
+ <varlistentry>
+ <term><option>––print-libdir</option></term>
+ <indexterm><primary><option>––print-libdir</option></primary></indexterm>
+ <listitem>
+ <para>Print the path to GHC's library directory. This is
+ the top of the directory tree containing GHC's libraries,
+ interfaces, and include files (usually something like
+ <literal>/usr/local/lib/ghc-5.04</literal> on Unix). This
+ is the value of
+ <literal>$libdir</literal><indexterm><primary><literal>libdir</literal></primary>
+ </indexterm>in the package configuration file (see <xref
+ linkend="packages">).</para>
+ </listitem>
+ </varlistentry>
+
</variablelist>
</sect1>
<sect1 id="make-mode">
- <title>Using <command>ghc</command> <option>--make</option></title>
+ <title>Using <command>ghc</command> <option>––make</option></title>
- <indexterm><primary><option>--make</option></primary>
+ <indexterm><primary><option>––make</option></primary>
</indexterm>
<indexterm><primary>separate compilation</primary>
</indexterm>
- <para>When given the <option>--make</option> option, GHC will
+ <para>When given the <option>––make</option> option, GHC will
build a multi-module Haskell program by following dependencies
from a single root module (usually <literal>Main</literal>). For
example, if your <literal>Main</literal> module is in a file
the program like this:</para>
<screen>
-ghc --make Main.hs
+ghc ––make Main.hs
</screen>
- <para>The command line must contain one source file or module
- name; GHC will figure out all the modules in the program by
- following the imports from this initial module. It will then
- attempt to compile each module which is out of date, and finally
- if the top module is <literal>Main</literal>, the program
+ <para>The command line may contain any number of source file names
+ or module names; GHC will figure out all the modules in the
+ program by following the imports from these initial modules. It
+ will then attempt to compile each module which is out of date, and
+ finally if there is a <literal>Main</literal> module, the program
will also be linked into an executable.</para>
- <para>The main advantages to using <literal>ghc --make</literal>
+ <para>The main advantages to using <literal>ghc ––make</literal>
over traditional <literal>Makefile</literal>s are:</para>
<itemizedlist>
<para>GHC doesn't have to be restarted for each compilation,
which means it can cache information between compilations.
Compiling a muli-module program with <literal>ghc
- --make</literal> can be up to twice as fast as running
+ ––make</literal> can be up to twice as fast as running
<literal>ghc</literal> individually on each source
file.</para>
</listitem>
</itemizedlist>
<para>Any of the command-line options described in the rest of
- this chapter can be used with <option>--make</option>, but note
+ this chapter can be used with <option>––make</option>, but note
that any options you give on the command line will apply to all
the source files compiled, so if you want any options to apply to
a single source file only, you'll need to use an
linkend="source-file-options">).</para>
<para>If the program needs to be linked with additional objects
- (say, some auxilliary C code), these can be specified on the
- command line as usual.</para>
+ (say, some auxilliary C code), then the object files can be
+ given on the command line and GHC will include them when linking
+ the executable.</para>
+
+ <para>Note that GHC can only follow dependencies if it has the
+ source file available, so if your program includes a module for
+ which there is no source file, even if you have an object and an
+ interface file for the module, then GHC will complain. The
+ exception to this rule is for package modules, which may or may
+ not have source files.</para>
+
+ <para>The source files for the program don't all need to be in the
+ same directory; the <option>-i</option> option can be used to add
+ directories to the search path (see <xref
+ linkend="search-path">).</para>
+
</sect1>
<Sect1 id="options-order">
- <title>GHC without <option>--make</option></title>
+ <title>GHC without <option>––make</option></title>
- <para>Without <option>--make</option>, GHC will compile one or
+ <para>Without <option>––make</option>, GHC will compile one or
more source files given on the command line.</para>
<para>The first phase to run is determined by each input-file
standard output.</para>
</sect1>
- <sect1 id="options-output">
- <title>Re-directing the compilation output(s)</title>
-
- <indexterm><primary>output-directing options</primary></indexterm>
- <indexterm><primary>redirecting compilation output</primary></indexterm>
-
-
- <variablelist>
- <varlistentry>
- <term><literal>-o</literal></term>
- <indexterm><primary><literal>-o</literal></primary></indexterm>
- <listitem>
- <para>GHC's compiled output normally goes into a
- <filename>.hc</filename>, <filename>.o</filename>, etc.,
- file, depending on the last-run compilation phase. The
- option <option>-o foo</option><IndexTerm><Primary>-o
- option</Primary></IndexTerm> re-directs the output of that
- last-run phase to file <filename>foo</filename>.</para>
-
- <para>Note: this “feature” can be
- counterintuitive: <command>ghc -C -o foo.o foo.hs</command>
- will put the intermediate C code in the file
- <filename>foo.o</filename>, name notwithstanding!</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><literal>-odir</literal></term>
- <indexterm><primary><literal>-odir</literal></primary></indexterm>
- <listitem>
- <para>The <option>-o</option> option isn't of much use if
- you have <emphasis>several</emphasis> input files…
- Non-interface output files are normally put in the same
- directory as their corresponding input file came from. You
- may specify that they be put in another directory using the
- <option>-odir <dir></option><IndexTerm><Primary>-odir
- <dir> option</Primary></IndexTerm> (the “Oh,
- dear” option). For example:</para>
-
-<Screen>
-% ghc -c parse/Foo.hs parse/Bar.hs gurgle/Bumble.hs -odir `arch`
-</Screen>
-
- <para>The output files, <filename>Foo.o</filename>,
- <filename>Bar.o</filename>, and
- <filename>Bumble.o</filename> would be put into a
- subdirectory named after the architecture of the executing
- machine (<filename>sun4</filename>,
- <filename>mips</filename>, etc). The directory must already
- exist; it won't be created.</para>
-
- <para>Note that the <option>-odir</option> option does
- <emphasis>not</emphasis> affect where the interface files
- are put. In the above example, they would still be put in
- <filename>parse/Foo.hi</filename>,
- <filename>parse/Bar.hi</filename>, and
- <filename>gurgle/Bumble.hi</filename>.</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><literal>-ohi</literal></term>
- <indexterm><primary><literal>-ohi</literal></primary></indexterm>
- <listitem>
- <para></para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><literal>-osuf</literal></term>
- <term><literal>-hisuf</literal></term>
- <indexterm><primary><literal>-osuf</literal></primary></indexterm>
- <indexterm><primary><literal>-hisuf</literal></primary></indexterm>
- <listitem>
- <para>EXOTICA: The <option>-osuf
- <suffix></option><IndexTerm><Primary>-osuf
- <suffix> option</Primary></IndexTerm> will change the
- <filename>.o</filename> file suffix for object files to
- whatever you specify. (We use this in compiling the
- prelude.).</para>
-
- <para>Similarly, the <option>-hisuf
- <suffix></option><IndexTerm><Primary>-hisuf
- <suffix> option</Primary></IndexTerm> will change the
- <filename>.hi</filename> file suffix for non-system
- interface files (see <XRef LinkEnd="hi-options">).</para>
-
- <para>The <option>-hisuf</option>/<option>-osuf</option>
- game is useful if you want to compile a program with both
- GHC and HBC (say) in the same directory. Let HBC use the
- standard <filename>.hi</filename>/<filename>.o</filename>
- suffixes; add <option>-hisuf g_hi -osuf
- g_o</option> to your <command>make</command> rule for
- GHC compiling…</para>
- </listitem>
- </varlistentry>
- </variablelist>
-
- <sect2 id="keeping-intermediates">
- <title>Keeping Intermediate Files</title>
- <indexterm><primary>intermediate files, saving</primary>
- </indexterm>
- <indexterm><primary><literal>.hc</literal> files, saving</primary>
- </indexterm>
- <indexterm><primary><literal>.s</literal> files, saving</primary>
- </indexterm>
-
-
- <para>The following options are useful for keeping certain
- intermediate files around, when normally GHC would throw these
- away after compilation:</para>
-
- <variablelist>
- <varlistentry>
- <term><literal>-keep-hc-files</literal></term>
- <indexterm>
- <primary><literal>-keep-hc-files</literal></primary>
- </indexterm>
- <listitem>
- <para>Keep intermediate <literal>.hc</literal> files when
- doing <literal>.hs</literal>-to-<literal>.o</literal>
- compilations via C (NOTE: <literal>.hc</literal> files
- aren't generated when using the native code generator, you
- may need to use <literal>-fvia-C</literal> to force them
- to be produced).</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><literal>-keep-s-files</literal></term>
- <indexterm>
- <primary><literal>-keep-s-files</literal></primary>
- </indexterm>
- <listitem>
- <para>Keep intermediate <literal>.s</literal> files.</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><literal>-keep-raw-s-files</literal></term>
- <indexterm>
- <primary><literal>-keep-raw-s-files</literal></primary>
- </indexterm>
- <listitem>
- <para>Keep intermediate <literal>.raw-s</literal> files.
- These are the direct output from the C compiler, before
- GHC does “assembly mangling” to produce the
- <literal>.s</literal> file. Again, these are not produced
- when using the native code generator.</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
- <term><literal>-keep-tmp-files</literal></term>
- <indexterm>
- <primary><literal>-keep-tmp-files</literal></primary>
- </indexterm>
- <indexterm>
- <primary>temporary files</primary>
- <secondary>keeping</secondary>
- </indexterm>
- <listitem>
- <para>Instructs the GHC driver not to delete any of its
- temporary files, which it normally keeps in
- <literal>/tmp</literal> (or possibly elsewhere; see <xref
- linkend="temp-files">). Running GHC with
- <literal>-v</literal> will show you what temporary files
- were generated along the way.</para>
- </listitem>
- </varlistentry>
- </variablelist>
- </sect2>
-
- <sect2 id="temp-files">
- <title>Redirecting temporary files</title>
-
- <indexterm>
- <primary>temporary files</primary>
- <secondary>redirecting</secondary>
- </indexterm>
-
- <variablelist>
- <varlistentry>
- <term><literal>-tmpdir</literal></term>
- <indexterm><primary><literal>-tmpdir</literal></primary></indexterm>
- <listitem>
- <para>If you have trouble because of running out of space
- in <filename>/tmp</filename> (or wherever your
- installation thinks temporary files should go), you may
- use the <option>-tmpdir
- <dir></option><IndexTerm><Primary>-tmpdir
- <dir> option</Primary></IndexTerm> option to specify
- an alternate directory. For example, <option>-tmpdir
- .</option> says to put temporary files in the current
- working directory.</para>
-
- <para>Alternatively, use your <Constant>TMPDIR</Constant>
- environment variable.<IndexTerm><Primary>TMPDIR
- environment variable</Primary></IndexTerm> Set it to the
- name of the directory where temporary files should be put.
- GCC and other programs will honour the
- <Constant>TMPDIR</Constant> variable as well.</para>
-
- <para>Even better idea: Set the
- <Constant>DEFAULT_TMPDIR</Constant> make variable when
- building GHC, and never worry about
- <Constant>TMPDIR</Constant> again. (see the build
- documentation).</para>
- </listitem>
- </varlistentry>
- </variablelist>
- </sect2>
-
- </sect1>
+ &separate;
<sect1 id="options-sanity">
<title>Warnings and sanity-checking</title>
generated during compilation. By default, you get a standard set
of warnings which are generally likely to indicate bugs in your
program. These are:
- <option>-fwarn-overlpapping-patterns</option>,
+ <option>-fwarn-overlapping-patterns</option>,
<option>-fwarn-deprecations</option>,
<option>-fwarn-duplicate-exports</option>,
<option>-fwarn-missing-fields</option>, and
<para>Provides the standard warnings plus
<option>-fwarn-incomplete-patterns</option>,
<option>-fwarn-unused-matches</option>,
- <option>-fwarn-unused-imports</option> and
+ <option>-fwarn-unused-imports</option>,
+ <option>-fwarn-misc</option>, and
<option>-fwarn-unused-binds</option>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-w</option>:</term>
<listitem>
- <IndexTerm><Primary>-w option</Primary></IndexTerm>
+ <IndexTerm><Primary><option>-w</option></Primary></IndexTerm>
<para>Turns off all warnings, including the standard ones.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-Wall</option>:</term>
<listitem>
- <indexterm><primary>-Wall option</primary></indexterm>
+ <indexterm><primary><option>-Wall</option></primary></indexterm>
<para>Turns on all warning options.</para>
</listitem>
</varlistentry>
+ <varlistentry>
+ <term><option>-Werror</option>:</term>
+ <listitem>
+ <indexterm><primary><option>-Werror</option></primary></indexterm>
+ <para>Makes any warning into a fatal error. Useful so that you don't
+ miss warnings when doing batch compilation. </para>
+ </listitem>
+ </varlistentry>
+
</variablelist>
<para>The full set of warning options is described below. To turn
<varlistentry>
<term><option>-fwarn-duplicate-exports</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-duplicate-exports option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-duplicate-exports</option></primary></indexterm>
<indexterm><primary>duplicate exports, warning</primary></indexterm>
<indexterm><primary>export lists, duplicates</primary></indexterm>
<varlistentry>
<term><option>-fwarn-hi-shadowing</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-hi-shadowing option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-hi-shadowing</option></primary></indexterm>
<indexterm><primary>shadowing</primary>
<secondary>interface files</secondary></indexterm>
<varlistentry>
<term><option>-fwarn-incomplete-patterns</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-incomplete-patterns option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-incomplete-patterns</option></primary></indexterm>
<indexterm><primary>incomplete patterns, warning</primary></indexterm>
<indexterm><primary>patterns, incomplete</primary></indexterm>
</varlistentry>
<varlistentry>
+ <term><option>-fwarn-misc</option>:</term>
+ <indexterm><primary><option>-fwarn-misc</option></primary></indexterm>
+ <listitem>
+ <para>Turns on warnings for various harmless but untidy
+ things. This currently includes: importing a type with
+ <literal>(..)</literal> when the export is abstract, and
+ listing duplicate class assertions in a qualified type.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
<term><option>-fwarn-missing-fields</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-missing-fields option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-missing-fields</option></primary></indexterm>
<indexterm><primary>missing fields, warning</primary></indexterm>
<indexterm><primary>fields, missing</primary></indexterm>
<varlistentry>
<term><option>-fwarn-missing-methods</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-missing-methods option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-missing-methods</option></primary></indexterm>
<indexterm><primary>missing methods, warning</primary></indexterm>
<indexterm><primary>methods, missing</primary></indexterm>
an instance declaration is missing one or more methods, and
the corresponding class declaration has no default
declaration for them.</para>
+ <para>The warning is suppressed if the method name
+ begins with an underscore. Here's an example where this is useful:
+ <programlisting>
+ class C a where
+ _simpleFn :: a -> String
+ complexFn :: a -> a -> String
+ complexFn x y = ... _simpleFn ...
+ </programlisting>
+ The idea is that: (a) users of the class will only call <literal>complexFn</literal>;
+ never <literal>_simpleFn</literal>; and (b)
+ instance declarations can define either <literal>complexFn</literal> or <literal>_simpleFn</literal>.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-fwarn-missing-signatures</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-missing-signatures option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-missing-signatures</option></primary></indexterm>
<indexterm><primary>type signatures, missing</primary></indexterm>
<para>If you would like GHC to check that every top-level
<varlistentry>
<term><option>-fwarn-name-shadowing</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-name-shadowing option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-name-shadowing</option></primary></indexterm>
<indexterm><primary>shadowing, warning</primary></indexterm>
<para>This option causes a warning to be emitted whenever an
<varlistentry>
<term><option>-fwarn-overlapping-patterns</option>:</term>
- <indexterm><primary>-fwarn-overlapping-patterns option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-overlapping-patterns</option></primary></indexterm>
<indexterm><primary>overlapping patterns, warning</primary></indexterm>
<indexterm><primary>patterns, overlapping</primary></indexterm>
<listitem>
patterns that can fail, eg. <literal>\(x:xs)->...</literal>.
Normally, these aren't treated as incomplete patterns by
<option>-fwarn-incomplete-patterns</option>.</para>
+ <para>``Lambda-bound patterns'' includes all places where there is a single pattern,
+ including list comprehensions and do-notation. In these cases, a pattern-match
+ failure is quite legitimate, and triggers filtering (list comprehensions) or
+ the monad <literal>fail</literal> operation (monads). For example:
+ <programlisting>
+ f :: [Maybe a] -> [a]
+ f xs = [y | Just y <- xs]
+ </programlisting>
+ Switching on <option>-fwarn-simple-patterns</option> will elicit warnings about
+ these probably-innocent cases, which is why the flag is off by default. </para>
+ <para> The <literal>deriving( Read )</literal> mechanism produces monadic code with
+ pattern matches, so you will also get misleading warnings about the compiler-generated
+ code. (This is arguably a Bad Thing, but it's awkward to fix.)</para>
+
</listitem>
</varlistentry>
<varlistentry>
<term><option>-fwarn-type-defaults</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-type-defaults option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-type-defaults</option></primary></indexterm>
<indexterm><primary>defaulting mechanism, warning</primary></indexterm>
<para>Have the compiler warn/inform you where in your source
the Haskell defaulting mechanism for numeric types kicks
<varlistentry>
<term><option>-fwarn-unused-binds</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-unused-binds option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-unused-binds</option></primary></indexterm>
<indexterm><primary>unused binds, warning</primary></indexterm>
<indexterm><primary>binds, unused</primary></indexterm>
<para>Report any function definitions (and local bindings)
<varlistentry>
<term><option>-fwarn-unused-imports</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-unused-imports option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-unused-imports</option></primary></indexterm>
<indexterm><primary>unused imports, warning</primary></indexterm>
<indexterm><primary>imports, unused</primary></indexterm>
<varlistentry>
<term><option>-fwarn-unused-matches</option>:</term>
<listitem>
- <indexterm><primary>-fwarn-unused-matches option</primary></indexterm>
+ <indexterm><primary><option>-fwarn-unused-matches</option></primary></indexterm>
<indexterm><primary>unused matches, warning</primary></indexterm>
<indexterm><primary>matches, unused</primary></indexterm>
<para>Report all unused variables which arise from pattern
matches, including patterns consisting of a single variable.
For instance <literal>f x y = []</literal> would report
- <VarName>x</VarName> and <VarName>y</VarName> as unused. To
- eliminate the warning, all unused variables can be replaced
- with wildcards.</para>
+ <VarName>x</VarName> and <VarName>y</VarName> as unused. The
+ warning is suppressed if the variable name begins with an underscore, thus:
+ <programlisting>
+ f _x = True
+ </programlisting>
+ </para>
</listitem>
</varlistentry>
</VariableList>
<para>If you're feeling really paranoid, the
- <option>-dcore-lint</option> option<indexterm><primary>-dcore-lint
- option</primary></indexterm> is a good choice. It turns on
- heavyweight intra-pass sanity-checking within GHC. (It checks
- GHC's sanity, not yours.)</para>
+ <option>-dcore-lint</option>
+ option<indexterm><primary><option>-dcore-lint</option></primary></indexterm>
+ is a good choice. It turns on heavyweight intra-pass
+ sanity-checking within GHC. (It checks GHC's sanity, not
+ yours.)</para>
</sect1>
- &separate;
&packages;
<sect1 id="options-optimise">
</varlistentry>
<varlistentry>
- <term><option>-O2-for-C</option>:</term>
- <indexterm><primary>-O2-for-C option</primary></indexterm>
- <indexterm><primary>gcc, invoking with -O2</primary></indexterm>
- <listitem>
- <para>Says to run GCC with <option>-O2</option>, which may
- be worth a few percent in execution speed. Don't forget
- <option>-fvia-C</option>, lest you use the native-code
- generator and bypass GCC altogether!</para>
- </listitem>
- </varlistentry>
-
- <varlistentry>
<term><option>-Ofile <file></option>:</term>
<indexterm><primary>-Ofile <file> option</primary></indexterm>
<indexterm><primary>optimising, customised</primary></indexterm>
<para>We don't use a <option>-O*</option> flag for day-to-day
work. We use <option>-O</option> to get respectable speed;
e.g., when we want to measure something. When we want to go for
- broke, we tend to use <option>-O -fvia-C -O2-for-C</option> (and
- we go for lots of coffee breaks).</para>
+ broke, we tend to use <option>-O -fvia-C</option> (and we go for
+ lots of coffee breaks).</para>
<para>The easiest way to see what <option>-O</option> (etc.)
“really mean” is to run with <option>-v</option>,
</variablelist>
</sect2>
-
+
</sect1>
-
-&phases;
-
-<Sect1 id="sec-using-concurrent">
+
+ &phases;
+
+ <sect1 id="sec-using-concurrent">
<title>Using Concurrent Haskell</title>
-<para>
-<indexterm><primary>Concurrent Haskell—use</primary></indexterm>
-</para>
+ <indexterm><primary>Concurrent Haskell—use</primary></indexterm>
<para>
-GHC (as of version 4.00) supports Concurrent Haskell by default,
-without requiring a special option or libraries compiled in a certain
-way. To get access to the support libraries for Concurrent Haskell
-(i.e. <literal>Concurrent</literal> and friends), use the
-<option>-package concurrent</option> option.
-</para>
+GHC supports Concurrent Haskell by default, without requiring a
+special option or libraries compiled in a certain way. To get access
+to the support libraries for Concurrent Haskell, just import
+<literal>Control.Concurrent</literal> (details are in the accompanying
+library documentation).</para>
<para>
-Three RTS options are provided for modifying the behaviour of the
-threaded runtime system. See the descriptions of
-<option>-C[<us>]</option>, <option>-q</option>, and
-<option>-t<num></option> in <XRef LinkEnd="parallel-rts-opts">.
+RTS options are provided for modifying the behaviour of the threaded
+runtime system. See <XRef LinkEnd="parallel-rts-opts">.
</para>
<para>
-Concurrent Haskell is described in more detail in <XRef
-LinkEnd="sec-Concurrent">.
+Concurrent Haskell is described in more detail in the documentation
+for the <literal>Control.Concurrent</literal> module.
</para>
</Sect1>
</sect1>
&runtime;
+
+<sect1 id="ext-core">
+ <title>Generating and compiling External Core Files</title>
+
+ <indexterm><primary>intermediate code generation</primary></indexterm>
+
+ <para>GHC can dump its optimized intermediate code (said to be in “Core” format)
+ to a file as a side-effect of compilation. Core files, which are given the suffix
+ <filename>.hcr</filename>, can be read and processed by non-GHC back-end
+ tools. The Core format is formally described in <ulink url="http://www.haskell.org/ghc/docs/papers/core.ps.gz"
+ <citetitle>An External Representation for the GHC Core Language</citetitle></ulink>,
+ and sample tools (in Haskell)
+ for manipulating Core files are available in the GHC source distribution
+ directory <literal>/fptools/ghc/utils/ext-core</literal>.
+ Note that the format of <literal>.hcr</literal>
+ files is <emphasis>different</emphasis> (though similar) to the Core output format generated
+ for debugging purposes (<xref linkend="options-debugging">).</para>
+
+ <para>The Core format natively supports notes which you can add to
+ your source code using the <literal>CORE</literal> pragma (see <xref
+ linkend="pragmas">).</para>
+
+ <variablelist>
+
+ <varlistentry>
+ <term><option>-fext-core</option></term>
+ <indexterm>
+ <primary><option>-fext-core</option></primary>
+ </indexterm>
+ <listitem>
+ <para>Generate <literal>.hcr</literal> files.</para>
+ </listitem>
+ </varlistentry>
+
+ </variablelist>
+
+<para>GHC can also read in External Core files as source; just give the <literal>.hcr</literal> file on
+the command line, instead of the <literal>.hs</literal> or <literal>.lhs</literal> Haskell source.
+A current infelicity is that you need to give teh <literal>-fglasgow-exts</literal> flag too, because
+ordinary Haskell 98, when translated to External Core, uses things like rank-2 types.</para>
+</sect1>
+
&debug;
&flags;
projects / ghc-hetmet.git / blobdiff