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