0b3faa4105a9ef99e94f3f6f346f8db4b8ddfc6b
[ghc.git] / docs / users_guide / using-warnings.rst
1 .. _options-sanity:
2
3 Warnings and sanity-checking
4 ----------------------------
5
6 .. index::
7    single: sanity-checking options
8    single: warnings
9
10 GHC has a number of options that select which types of non-fatal error
11 messages, otherwise known as warnings, can be generated during
12 compilation. By default, you get a standard set of warnings which are
13 generally likely to indicate bugs in your program. These are:
14 ``-fwarn-overlapping-patterns``, ``-fwarn-warnings-deprecations``,
15 ``-fwarn-deprecated-flags``, ``-fwarn-unrecognised-pragmas``,
16 ``-fwarn-missed-specialisations``, ``-fwarn-duplicate-constraints``,
17 ``-fwarn-duplicate-exports``, ``-fwarn-overflowed-literals``,
18 ``-fwarn-empty-enumerations``, ``-fwarn-missing-fields``,
19 ``-fwarn-missing-methods``, ``-fwarn-wrong-do-bind``,
20 ``-fwarn-unsupported-calling-conventions``,
21 ``-fwarn-dodgy-foreign-imports``, ``-fwarn-inline-rule-shadowing``,
22 ``-fwarn-unsupported-llvm-version``, ``-fwarn-context-quantification``,
23 and ``-fwarn-tabs``. The following flags are simple ways to select
24 standard “packages” of warnings:
25
26 ``-W``
27     .. index::
28        single: -W option
29
30     Provides the standard warnings plus ``-fwarn-unused-binds``,
31     ``-fwarn-unused-matches``, ``-fwarn-unused-imports``,
32     ``-fwarn-incomplete-patterns``, ``-fwarn-dodgy-exports``, and
33     ``-fwarn-dodgy-imports``.
34
35 ``-Wall``
36     .. index::
37        single: -Wall
38
39     Turns on all warning options that indicate potentially suspicious
40     code. The warnings that are *not* enabled by ``-Wall`` are
41     ``-fwarn-incomplete-uni-patterns``,
42     ``-fwarn-incomplete-record-updates``,
43     ``-fwarn-monomorphism-restriction``, ``-fwarn-auto-orphans``,
44     ``-fwarn-implicit-prelude``, ``-fwarn-missing-local-sigs``,
45     ``-fwarn-missing-exported-sigs``, ``-fwarn-missing-import-lists``
46     and ``-fwarn-identities``.
47
48 ``-w``
49     .. index::
50        single: -w
51
52     Turns off all warnings, including the standard ones and those that
53     ``-Wall`` doesn't enable.
54
55 ``-Werror``
56     .. index::
57        single: -Werror
58
59     Makes any warning into a fatal error. Useful so that you don't miss
60     warnings when doing batch compilation.
61
62 ``-Wwarn``
63     .. index::
64        single: -Wwarn
65
66     Warnings are treated only as warnings, not as errors. This is the
67     default, but can be useful to negate a ``-Werror`` flag.
68
69 The full set of warning options is described below. To turn off any
70 warning, simply give the corresponding ``-fno-warn-...`` option on the
71 command line.
72
73 ``-fwarn-typed-holes``
74     .. index::
75        single: -fwarn-typed-holes
76        single: warnings
77
78     Determines whether the compiler reports typed holes warnings. Has no
79     effect unless typed holes errors are deferred until runtime. See
80     :ref:`typed-holes` and :ref:`defer-type-errors`
81
82     This warning is on by default.
83
84 ``-fwarn-type-errors``
85     .. index::
86        single: -fwarn-type-errors
87        single: warnings
88
89     Causes a warning to be reported when a type error is deferred until
90     runtime. See :ref:`defer-type-errors`
91
92     This warning is on by default.
93
94 ``-fdefer-type-errors``
95     .. index::
96        single: -fdefer-type-errors
97        single: warnings
98
99     Defer as many type errors as possible until runtime. At compile time
100     you get a warning (instead of an error). At runtime, if you use a
101     value that depends on a type error, you get a runtime error; but you
102     can run any type-correct parts of your code just fine. See
103     :ref:`defer-type-errors`
104
105 ``-fdefer-typed-holes``
106     .. index::
107        single: -fdefer-typed-holes
108        single: warnings
109
110     Defer typed holes errors until runtime. This will turn the errors
111     produced by :ref:`typed holes <typed-holes>` into warnings. Using a value
112     that depends on a typed hole produces a runtime error, the same as
113     ``-fdefer-type-errors`` (which implies this option). See :ref:`typed-holes`
114     and :ref:`defer-type-errors`.
115
116     Implied by ``-fdefer-type-errors``. See also ``-fwarn-typed-holes``.
117
118 ``-fwarn-partial-type-signatures``
119     .. index::
120        single: -fwarn-partial-type-signatures
121        single: warnings
122
123     Determines whether the compiler reports holes in partial type
124     signatures as warnings. Has no effect unless
125     ``-XPartialTypeSignatures`` is enabled, which controls whether
126     errors should be generated for holes in types or not. See
127     :ref:`partial-type-signatures`.
128
129     This warning is on by default.
130
131 ``-fhelpful-errors``
132     .. index::
133        single: -fhelpful-errors
134        single: warnings
135
136     When a name or package is not found in scope, make suggestions for
137     the name or package you might have meant instead.
138
139     This option is on by default.
140
141 ``-fwarn-unrecognised-pragmas``
142     .. index::
143        single: -fwarn-unrecognised-pragmas
144        single: warnings
145        single: pragmas
146
147     Causes a warning to be emitted when a pragma that GHC doesn't
148     recognise is used. As well as pragmas that GHC itself uses, GHC also
149     recognises pragmas known to be used by other tools, e.g.
150     ``OPTIONS_HUGS`` and ``DERIVE``.
151
152     This option is on by default.
153
154 ``-fwarn-missed-specialisations``, ``-fwarn-all-missed-specialisations``
155     .. index::
156        single: -fwarn-missed-specialisations
157        single: -fwarn-all-missed-specialisations
158        single: warnings
159        single: pragmas
160
161     Emits a warning if GHC cannot specialise a function that is imported
162     and overloaded, usually because the function needs an ``INLINEABLE``
163     pragma.. The "all" form reports all such situations. The "non-all"
164     form only reports when the situation arises during specialisation of
165     an imported function; presumably teh latter was marked
166     ``INLINEABLE`` so that it would specialise but if it, in turn, calls
167     other functions that are not specialised you won't get the
168     performance boost you expect.
169
170     ``-fwarn-missed-specialisations`` is on by default;
171     ``-fwarn-all-missed-specialisations`` is implied by ``-Wall``.
172
173 ``-fwarn-warnings-deprecations``
174     .. index::
175        single: -fwarn-warnings-deprecations
176        single: warnings
177        single: deprecations
178
179     Causes a warning to be emitted when a module, function or type with
180     a ``WARNING`` or ``DEPRECATED pragma`` is used. See
181     :ref:`warning-deprecated-pragma` for more details on the pragmas.
182
183     This option is on by default.
184
185 ``-fwarn-amp``
186     .. index::
187        single: -fwarn-amp
188        single: AMP
189        single: Applicative-Monad Proposal
190
191     Causes a warning to be emitted when a definition is in conflict with
192     the AMP (Applicative-Monad proosal), namely: 1. Instance of Monad
193     without Applicative; 2. Instance of MonadPlus without Alternative;
194     3. Custom definitions of join/pure/<\*>
195
196     This option is on by default.
197
198 ``-fwarn-deprecated-flags``
199     .. index::
200        single: -fwarn-deprecated-flags
201        single: deprecated-flags
202
203     Causes a warning to be emitted when a deprecated command-line flag
204     is used.
205
206     This option is on by default.
207
208 ``-fwarn-unsupported-calling-conventions``
209     .. index::
210        single: -fwarn-unsupported-calling-conventions
211
212     Causes a warning to be emitted for foreign declarations that use
213     unsupported calling conventions. In particular, if the ``stdcall``
214     calling convention is used on an architecture other than i386 then
215     it will be treated as ``ccall``.
216
217 ``-fwarn-dodgy-foreign-imports``
218     .. index::
219        single: -fwarn-dodgy-foreign-imports
220
221     Causes a warning to be emitted for foreign imports of the following
222     form:
223
224     ::
225
226         foreign import "f" f :: FunPtr t
227
228     on the grounds that it probably should be
229
230     ::
231
232         foreign import "&f" f :: FunPtr t
233
234     The first form declares that \`f\` is a (pure) C function that takes
235     no arguments and returns a pointer to a C function with type \`t\`,
236     whereas the second form declares that \`f\` itself is a C function
237     with type \`t\`. The first declaration is usually a mistake, and one
238     that is hard to debug because it results in a crash, hence this
239     warning.
240
241 ``-fwarn-dodgy-exports``
242     .. index::
243        single: -fwarn-dodgy-exports
244
245     Causes a warning to be emitted when a datatype ``T`` is exported
246     with all constructors, i.e. ``T(..)``, but is it just a type
247     synonym.
248
249     Also causes a warning to be emitted when a module is re-exported,
250     but that module exports nothing.
251
252 ``-fwarn-dodgy-imports``
253     .. index::
254        single: -fwarn-dodgy-imports
255
256     Causes a warning to be emitted in the following cases:
257
258     -  When a datatype ``T`` is imported with all constructors, i.e.
259        ``T(..)``, but has been exported abstractly, i.e. ``T``.
260
261     -  When an ``import`` statement hides an entity that is not
262        exported.
263
264 ``-fwarn-overflowed-literals``
265     .. index::
266        single: -fwarn-overflowed-literals
267
268     Causes a warning to be emitted if a literal will overflow, e.g.
269     ``300 :: Word8``.
270
271 ``-fwarn-empty-enumerations``
272     .. index::
273        single: -fwarn-empty-enumerations
274
275     Causes a warning to be emitted if an enumeration is empty, e.g.
276     ``[5 .. 3]``.
277
278 ``-fwarn-lazy-unlifted-bindings``
279     .. index::
280        single: -fwarn-lazy-unlifted-bindings
281
282     This flag is a no-op, and will be removed in GHC 7.10.
283
284 ``-fwarn-duplicate-constraints``
285     .. index::
286        single: -fwarn-duplicate-constraints
287        single: duplicate constraints, warning
288
289     Have the compiler warn about duplicate constraints in a type
290     signature. For example
291
292     ::
293
294         f :: (Eq a, Show a, Eq a) => a -> a
295
296     The warning will indicate the duplicated ``Eq a`` constraint.
297
298     This option is now deprecated in favour of
299     ``-fwarn-redundant-constraints``.
300
301 ``-fwarn-redundant-constraints``
302     .. index::
303        single: -fwarn-redundant-constraints
304        single: redundant constraints, warning
305
306     Have the compiler warn about redundant constraints in a type
307     signature. In particular:
308
309     -  A redundant constraint within the type signature itself:
310
311        ::
312
313             f :: (Eq a, Ord a) => a -> a
314
315        The warning will indicate the redundant ``Eq a`` constraint: it
316        is subsumed by the ``Ord a`` constraint.
317
318     -  A constraint in the type signature is not used in the code it
319        covers:
320
321        ::
322
323             f :: Eq a => a -> a -> Bool
324             f x y = True
325
326        The warning will indicate the redundant ``Eq a`` constraint: : it
327        is not used by the definition of ``f``.)
328
329     Similar warnings are given for a redundant constraint in an instance
330     declaration.
331
332     This option is on by default. As usual you can suppress it on a
333     per-module basis with ``-fno-warn-redundant-constraints``.
334     Occasionally you may specifically want a function to have a more
335     constrained signature than necessary, perhaps to leave yourself
336     wiggle-room for changing the implementation without changing the
337     API. In that case, you can suppress the warning on a per-function
338     basis, using a call in a dead binding. For example:
339
340     ::
341
342         f :: Eq a => a -> a -> Bool
343         f x y = True
344         where
345             _ = x == x  -- Suppress the redundant-constraint warning for (Eq a)
346
347     Here the call to ``(==)`` makes GHC think that the ``(Eq a)``
348     constraint is needed, so no warning is issued.
349
350 ``-fwarn-duplicate-exports``
351     .. index::
352        single: -fwarn-duplicate-exports
353        single: duplicate exports, warning
354        single: export lists, duplicates
355
356     Have the compiler warn about duplicate entries in export lists. This
357     is useful information if you maintain large export lists, and want
358     to avoid the continued export of a definition after you've deleted
359     (one) mention of it in the export list.
360
361     This option is on by default.
362
363 ``-fwarn-hi-shadowing``
364     .. index::
365        single: -fwarn-hi-shadowing
366        single: shadowing; interface files
367
368     Causes the compiler to emit a warning when a module or interface
369     file in the current directory is shadowing one with the same module
370     name in a library or other directory.
371
372 ``-fwarn-identities``
373     .. index::
374        single: -fwarn-identities
375
376     Causes the compiler to emit a warning when a Prelude numeric
377     conversion converts a type T to the same type T; such calls are
378     probably no-ops and can be omitted. The functions checked for are:
379     ``toInteger``, ``toRational``, ``fromIntegral``, and ``realToFrac``.
380
381 ``-fwarn-implicit-prelude``
382     .. index::
383        single: -fwarn-implicit-prelude
384        single: implicit prelude, warning
385
386     Have the compiler warn if the Prelude is implicitly imported. This
387     happens unless either the Prelude module is explicitly imported with
388     an ``import ... Prelude ...`` line, or this implicit import is
389     disabled (either by ``-XNoImplicitPrelude`` or a
390     ``LANGUAGE NoImplicitPrelude`` pragma).
391
392     Note that no warning is given for syntax that implicitly refers to
393     the Prelude, even if ``-XNoImplicitPrelude`` would change whether it
394     refers to the Prelude. For example, no warning is given when ``368``
395     means ``Prelude.fromInteger (368::Prelude.Integer)`` (where
396     ``Prelude`` refers to the actual Prelude module, regardless of the
397     imports of the module being compiled).
398
399     This warning is off by default.
400
401 ``-fwarn-incomplete-patterns``, ``-fwarn-incomplete-uni-patterns``
402     .. index::
403        single: -fwarn-incomplete-patterns
404        single: -fwarn-incomplete-uni-patterns
405        single: incomplete patterns, warning
406        single: patterns, incomplete
407
408     The option ``-fwarn-incomplete-patterns`` warns about places where a
409     pattern-match might fail at runtime. The function ``g`` below will
410     fail when applied to non-empty lists, so the compiler will emit a
411     warning about this when ``-fwarn-incomplete-patterns`` is enabled.
412
413     ::
414
415         g [] = 2
416
417     This option isn't enabled by default because it can be a bit noisy,
418     and it doesn't always indicate a bug in the program. However, it's
419     generally considered good practice to cover all the cases in your
420     functions, and it is switched on by ``-W``.
421
422     The flag ``-fwarn-incomplete-uni-patterns`` is similar, except that
423     it applies only to lambda-expressions and pattern bindings,
424     constructs that only allow a single pattern:
425
426     ::
427
428         h = \[] -> 2
429         Just k = f y
430
431 ``-fwarn-incomplete-record-updates``
432     .. index::
433        single: -fwarn-incomplete-record-updates
434        single: incomplete record updates, warning
435        single: record updates, incomplete
436
437     The function ``f`` below will fail when applied to ``Bar``, so the
438     compiler will emit a warning about this when
439     ``-fwarn-incomplete-record-updates`` is enabled.
440
441     ::
442
443         data Foo = Foo { x :: Int }
444                  | Bar
445
446         f :: Foo -> Foo
447         f foo = foo { x = 6 }
448
449     This option isn't enabled by default because it can be very noisy,
450     and it often doesn't indicate a bug in the program.
451
452 ``-fwarn-missing-fields``
453     .. index::
454        single: -fwarn-missing-fields
455        single: missing fields, warning
456        single: fields, missing
457
458     This option is on by default, and warns you whenever the
459     construction of a labelled field constructor isn't complete, missing
460     initialisers for one or more fields. While not an error (the missing
461     fields are initialised with bottoms), it is often an indication of a
462     programmer error.
463
464 ``-fwarn-missing-import-lists``
465     .. index::
466        single: -fwarn-import-lists
467        single: missing import lists, warning
468        single: import lists, missing
469
470     This flag warns if you use an unqualified ``import`` declaration
471     that does not explicitly list the entities brought into scope. For
472     example
473
474     ::
475
476         module M where
477           import X( f )
478           import Y
479           import qualified Z
480           p x = f x x
481
482     The ``-fwarn-import-lists`` flag will warn about the import of ``Y``
483     but not ``X`` If module ``Y`` is later changed to export (say)
484     ``f``, then the reference to ``f`` in ``M`` will become ambiguous.
485     No warning is produced for the import of ``Z`` because extending
486     ``Z``\'s exports would be unlikely to produce ambiguity in ``M``.
487
488 ``-fwarn-missing-methods``
489     .. index::
490        single: -fwarn-missing-methods
491        single: missing methods, warning
492        single: methods, missing
493
494     This option is on by default, and warns you whenever an instance
495     declaration is missing one or more methods, and the corresponding
496     class declaration has no default declaration for them.
497
498     The warning is suppressed if the method name begins with an
499     underscore. Here's an example where this is useful:
500
501     ::
502
503         class C a where
504             _simpleFn :: a -> String
505             complexFn :: a -> a -> String
506             complexFn x y = ... _simpleFn ...
507
508     The idea is that: (a) users of the class will only call
509     ``complexFn``; never ``_simpleFn``; and (b) instance declarations
510     can define either ``complexFn`` or ``_simpleFn``.
511
512     The ``MINIMAL`` pragma can be used to change which combination of
513     methods will be required for instances of a particular class. See
514     :ref:`minimal-pragma`.
515
516 ``-fwarn-missing-signatures``
517     .. index::
518        single: -fwarn-missing-signatures
519        single: type signatures, missing
520
521     If you would like GHC to check that every top-level function/value
522     has a type signature, use the ``-fwarn-missing-signatures`` option.
523     As part of the warning GHC also reports the inferred type. The
524     option is off by default.
525
526 ``-fwarn-missing-exported-sigs``
527     .. index::
528        single: -fwarn-missing-exported-sigs
529        single: type signatures, missing
530
531     If you would like GHC to check that every exported top-level
532     function/value has a type signature, but not check unexported
533     values, use the ``-fwarn-missing-exported-sigs`` option. This option
534     takes precedence over ``-fwarn-missing-signatures``. As part of the
535     warning GHC also reports the inferred type. The option is off by
536     default.
537
538 ``-fwarn-missing-local-sigs``
539     .. index::
540        single: -fwarn-missing-local-sigs
541        single: type signatures, missing
542
543     If you use the ``-fwarn-missing-local-sigs`` flag GHC will warn you
544     about any polymorphic local bindings. As part of the warning GHC
545     also reports the inferred type. The option is off by default.
546
547 ``-fwarn-name-shadowing``
548     .. index::
549        single: -fwarn-name-shadowing
550        single: shadowing, warning
551
552     This option causes a warning to be emitted whenever an inner-scope
553     value has the same name as an outer-scope value, i.e. the inner
554     value shadows the outer one. This can catch typographical errors
555     that turn into hard-to-find bugs, e.g., in the inadvertent capture
556     of what would be a recursive call in
557     ``f = ... let f = id in ... f ...``.
558
559     The warning is suppressed for names beginning with an underscore.
560     For example
561
562     ::
563
564         f x = do { _ignore <- this; _ignore <- that; return (the other) }
565
566 ``-fwarn-orphans, -fwarn-auto-orphans``
567     .. index::
568        single: -fwarn-orphans
569        single: -fwarn-auto-orphans
570        single: orphan instances, warning
571        single: orphan rules, warning
572
573     These flags cause a warning to be emitted whenever the module
574     contains an "orphan" instance declaration or rewrite rule. An
575     instance declaration is an orphan if it appears in a module in which
576     neither the class nor the type being instanced are declared in the
577     same module. A rule is an orphan if it is a rule for a function
578     declared in another module. A module containing any orphans is
579     called an orphan module.
580
581     The trouble with orphans is that GHC must pro-actively read the
582     interface files for all orphan modules, just in case their instances
583     or rules play a role, whether or not the module's interface would
584     otherwise be of any use. See :ref:`orphan-modules` for details.
585
586     The flag ``-fwarn-orphans`` warns about user-written orphan rules or
587     instances. The flag ``-fwarn-auto-orphans`` warns about
588     automatically-generated orphan rules, notably as a result of
589     specialising functions, for type classes (``Specialise``) or
590     argument values (``-fspec-constr``).
591
592 ``-fwarn-overlapping-patterns``
593     .. index::
594        single: -fwarn-overlapping-patterns
595        single: overlapping patterns, warning
596        single: patterns, overlapping
597
598     By default, the compiler will warn you if a set of patterns are
599     overlapping, e.g.,
600
601     ::
602
603         f :: String -> Int
604         f []     = 0
605         f (_:xs) = 1
606         f "2"    = 2
607
608     where the last pattern match in ``f`` won't ever be reached, as the
609     second pattern overlaps it. More often than not, redundant patterns
610     is a programmer mistake/error, so this option is enabled by default.
611
612 ``-fwarn-tabs``
613     .. index::
614        single: -fwarn-tabs
615        single: tabs, warning
616
617     Have the compiler warn if there are tabs in your source file.
618
619 ``-fwarn-type-defaults``
620     .. index::
621        single: -fwarn-type-defaults
622        single: defaulting mechanism, warning
623
624     Have the compiler warn/inform you where in your source the Haskell
625     defaulting mechanism for numeric types kicks in. This is useful
626     information when converting code from a context that assumed one
627     default into one with another, e.g., the ‘default default’ for
628     Haskell 1.4 caused the otherwise unconstrained value ``1`` to be
629     given the type ``Int``, whereas Haskell 98 and later defaults it to
630     ``Integer``. This may lead to differences in performance and
631     behaviour, hence the usefulness of being non-silent about this.
632
633     This warning is off by default.
634
635 ``-fwarn-monomorphism-restriction``
636     .. index::
637        single: -fwarn-monomorphism-restriction
638        single: monomorphism restriction, warning
639
640     Have the compiler warn/inform you where in your source the Haskell
641     Monomorphism Restriction is applied. If applied silently the MR can
642     give rise to unexpected behaviour, so it can be helpful to have an
643     explicit warning that it is being applied.
644
645     This warning is off by default.
646
647 ``-fwarn-unticked-promoted-constructors``
648     .. index::
649        single: -fwarn-unticked-promoted-constructors
650        single: promoted constructor, warning
651
652     Warn if a promoted data constructor is used without a tick preceding
653     its name.
654
655     For example:
656
657     ::
658
659         data Nat = Succ Nat | Zero
660
661         data Vec n s where
662           Nil  :: Vec Zero a
663           Cons :: a -> Vec n a -> Vec (Succ n) a
664
665     Will raise two warnings because ``Zero`` and ``Succ`` are not
666     written as ``'Zero`` and ``'Succ``.
667
668     This warning is is enabled by default in ``-Wall`` mode.
669
670 ``-fwarn-unused-binds``
671     .. index::
672        single: -fwarn-unused-binds
673        single: unused binds, warning
674        single: binds, unused
675
676     Report any function definitions (and local bindings) which are
677     unused. An alias for
678
679     -  ``-fwarn-unused-top-binds``
680     -  ``-fwarn-unused-local-binds``
681     -  ``-fwarn-unused-pattern-binds``
682
683 ``-fwarn-unused-top-binds``
684     .. index::
685        single: -fwarn-unused-top-binds
686        single: unused binds, warning
687        single: binds, unused
688
689     Report any function definitions which are unused.
690
691     More precisely, warn if a binding brings into scope a variable that
692     is not used, except if the variable's name starts with an
693     underscore. The "starts-with-underscore" condition provides a way to
694     selectively disable the warning.
695
696     A variable is regarded as "used" if
697
698     -  It is exported, or
699
700     -  It appears in the right hand side of a binding that binds at
701        least one used variable that is used
702
703     For example
704
705     ::
706
707         module A (f) where
708         f = let (p,q) = rhs1 in t p  -- No warning: q is unused, but is locally bound
709         t = rhs3                     -- No warning: f is used, and hence so is t
710         g = h x                      -- Warning: g unused
711         h = rhs2                     -- Warning: h is only used in the
712                                      -- right-hand side of another unused binding
713         _w = True                    -- No warning: _w starts with an underscore
714
715 ``-fwarn-unused-local-binds``
716     .. index::
717        single: -fwarn-unused-local-binds
718        single: unused binds, warning
719        single: binds, unused
720
721     Report any local definitions which are unused. For example
722
723     ::
724
725         module A (f) where
726         f = let (p,q) = rhs1 in t p  -- Warning: q is unused
727         g = h x                      -- No warning: g is unused, but is a top-level binding
728
729 ``-fwarn-unused-pattern-binds``
730     .. index::
731        single: -fwarn-unused-pattern-binds
732        single: unused binds, warning
733        single: binds, unused
734
735     Warn if a pattern binding binds no variables at all, unless it is a
736     lone, possibly-banged, wild-card pattern. For example:
737
738     ::
739
740         Just _ = rhs3    -- Warning: unused pattern binding
741         (_, _) = rhs4    -- Warning: unused pattern binding
742         _  = rhs3        -- No warning: lone wild-card pattern
743         !_ = rhs4        -- No warning: banged wild-card pattern; behaves like seq
744
745     The motivation for allowing lone wild-card patterns is they are not
746     very different from ``_v = rhs3``, which elicits no warning; and
747     they can be useful to add a type constraint, e.g. ``_ = x::Int``. A
748     lone banged wild-card pattern is useful as an alternative (to
749     ``seq``) way to force evaluation.
750
751 ``-fwarn-unused-imports``
752     .. index::
753        single: -fwarn-unused-imports
754        single: unused imports, warning
755        single: imports, unused
756
757     Report any modules that are explicitly imported but never used.
758     However, the form ``import M()`` is never reported as an unused
759     import, because it is a useful idiom for importing instance
760     declarations, which are anonymous in Haskell.
761
762 ``-fwarn-unused-matches``
763     .. index::
764        single: -fwarn-unused-matches
765        single: unused matches, warning
766        single: matches, unused
767
768     Report all unused variables which arise from pattern matches,
769     including patterns consisting of a single variable. For instance
770     ``f x y = []`` would report ``x`` and ``y`` as unused. The warning
771     is suppressed if the variable name begins with an underscore, thus:
772
773     ::
774
775         f _x = True
776
777 ``-fwarn-unused-do-bind``
778     .. index::
779        single: -fwarn-unused-do-bind
780        single: unused do binding, warning
781        single: do binding, unused
782
783     Report expressions occurring in ``do`` and ``mdo`` blocks that
784     appear to silently throw information away. For instance
785     ``do { mapM popInt xs ; return 10 }`` would report the first
786     statement in the ``do`` block as suspicious, as it has the type
787     ``StackM [Int]`` and not ``StackM ()``, but that ``[Int]`` value is
788     not bound to anything. The warning is suppressed by explicitly
789     mentioning in the source code that your program is throwing
790     something away:
791
792     ::
793
794         do { _ <- mapM popInt xs ; return 10 }
795
796     Of course, in this particular situation you can do even better:
797
798     ::
799
800         do { mapM_ popInt xs ; return 10 }
801
802 ``-fwarn-context-quantification``
803     .. index::
804        single: -fwarn-context-quantification
805        single: implicit context quantification, warning
806        single: context, implicit quantification
807
808     Report if a variable is quantified only due to its presence in a
809     context (see :ref:`universal-quantification`). For example,
810
811     ::
812
813         type T a = Monad m => a -> f a
814
815     It is recommended to write this polymorphic type as
816
817     ::
818
819         type T a = forall m. Monad m => a -> f a
820
821     instead.
822
823 ``-fwarn-wrong-do-bind``
824     .. index::
825        single: -fwarn-wrong-do-bind
826        single: apparently erroneous do binding, warning
827        single: do binding, apparently erroneous
828
829     Report expressions occurring in ``do`` and ``mdo`` blocks that
830     appear to lack a binding. For instance
831     ``do { return (popInt 10) ; return 10 }`` would report the first
832     statement in the ``do`` block as suspicious, as it has the type
833     ``StackM (StackM Int)`` (which consists of two nested applications
834     of the same monad constructor), but which is not then "unpacked" by
835     binding the result. The warning is suppressed by explicitly
836     mentioning in the source code that your program is throwing
837     something away:
838
839     ::
840
841         do { _ <- return (popInt 10) ; return 10 }
842
843     For almost all sensible programs this will indicate a bug, and you
844     probably intended to write:
845
846     ::
847
848         do { popInt 10 ; return 10 }
849
850 ``-fwarn-inline-rule-shadowing``
851     .. index::
852        single: -fwarn-inline-rule-shadowing
853
854     Warn if a rewrite RULE might fail to fire because the function might
855     be inlined before the rule has a chance to fire. See
856     :ref:`rules-inline`.
857
858 If you're feeling really paranoid, the ``-dcore-lint`` option is a good choice.
859 It turns on heavyweight intra-pass sanity-checking within GHC. (It checks GHC's
860 sanity, not yours.)
861