X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fusing.xml;h=f81b1c8122cd55b8a78ac1e41ab510e42b111606;hb=eb51c44142ecd9dea175d9632f16cc75a44476f5;hp=72f53b740b18cbf7284c8adc5c5f825bdad668bf;hpb=2f4e21c6f741995e20cc3b53b109ff9edf18eb3c;p=ghc-hetmet.git diff --git a/docs/users_guide/using.xml b/docs/users_guide/using.xml index 72f53b7..f81b1c8 100644 --- a/docs/users_guide/using.xml +++ b/docs/users_guide/using.xml @@ -310,7 +310,7 @@ module X where Dependency-generation mode. In this mode, GHC can be used to generate dependency information suitable for use in a Makefile. See . + linkend="makefile-dependencies"/>. @@ -839,7 +839,17 @@ ghc -c Foo.hs : - Turns on all warning options. + Turns on all warning options that indicate potentially + suspicious code. The warnings that are + not enabled by + are: + + + + + + + @@ -905,6 +915,31 @@ ghc -c Foo.hs + : + + + implicit prelude, warning + Have the compiler warn if the Prelude is implicitly + imported. This happens unless either the Prelude module is + explicitly imported with an import ... Prelude ... + line, or this implicit import is disabled (either by + or a + LANGUAGE NoImplicitPrelude pragma). + + Note that no warning is given for syntax that implicitly + refers to the Prelude, even if + would change whether it refers to the Prelude. + For example, no warning is given when + 368 means + Prelude.fromInteger (368::Prelude.Integer) + (where Prelude refers to the actual Prelude module, + regardless of the imports of the module being compiled). + + This warning is off by default. + + + + : @@ -1006,7 +1041,8 @@ f foo = foo { x = 6 } If you would like GHC to check that every top-level function/value has a type signature, use the - option. This + option. As part of + the warning GHC also reports the inferred type. The option is off by default. @@ -1024,7 +1060,7 @@ f foo = foo { x = 6 } in the inadvertent cyclic definition let x = ... x ... in. - Consequently, this option does + Consequently, this option will complain about cyclic recursive definitions. @@ -1135,6 +1171,20 @@ f "2" = 2 + : + + + monomorphism restriction, warning + Have the compiler warn/inform you where in your source + the Haskell Monomorphism Restriction is applied. If applied silently + the MR can give rise to unexpected behaviour, so it can be helpful + to have an explicit warning that it is being applied. + + This warning is off by default. + + + + : @@ -1368,7 +1418,7 @@ f "2" = 2 Exception.assert in source code (in other words, rewriting Exception.assert p e to e (see ). This flag is turned on by + linkend="assertions"/>). This flag is turned on by . @@ -1435,6 +1485,50 @@ f "2" = 2 + + + + + Turn off the "state hack" whereby any lambda with a + State# token as argument is considered to be + single-entry, hence it is considered OK to inline things inside + it. This can improve performance of IO and ST monad code, but it + runs the risk of reducing sharing. + + + + + + + + + + Tells GHC to omit all inessential information from the interface file + generated for the module being compiled (say M). This means that a module + importing M will see only the types of the functions that M exports, but not + their unfoldings, strictness info, etc. Hence, for example, + no function exported by M will be inlined + into an importing module. The benefit is that modules that import M will + need to be recompiled less often (only when M's exports change their type, + not when they change their implementation). + + + + + + + + + + + Tells GHC to ignore all inessential information when reading interface files. + That is, even if M.hi contains unfolding or strictness information + for a function, GHC will ignore that information. + + + + + : strict constructor fields @@ -1457,7 +1551,7 @@ f "2" = 2 - + @@ -1475,7 +1569,7 @@ f "2" = 2 - : + : inlining, controlling unfolding, controlling @@ -1501,7 +1595,7 @@ f "2" = 2 - : + inlining, controlling @@ -1523,7 +1617,7 @@ f "2" = 2 &phases; - + Using Concurrent Haskell Concurrent Haskellusing @@ -1553,7 +1647,7 @@ f "2" = 2 - + Using SMP parallelism parallelism