[Separate flags -XDeriveFunctor, -XDeriveFoldable, -XDeriveTraversable
simonpj@microsoft.com**20090528075031
 Ignore-this: b5b6ce32b6d4e847a6f58de17dd1af54
 
 See Trac #2953. This patch implements a distinct flag for each extended
 class that may be automatically derived.  And I updated the user manual
 to reflect the fact that we can now derive Functor, Foldable, Traversable.
 
] {
hunk ./compiler/main/DynFlags.hs 225
+
hunk ./compiler/main/DynFlags.hs 229
+   | Opt_DeriveTraversable
+   | Opt_DeriveFoldable
+
hunk ./compiler/main/DynFlags.hs 1799
+  ( "DeriveTraversable",                Opt_DeriveTraversable, const Supported ),
+  ( "DeriveFoldable",                   Opt_DeriveFoldable, const Supported ),
hunk ./compiler/main/DynFlags.hs 1842
+           , Opt_DeriveFoldable
+           , Opt_DeriveTraversable
hunk ./compiler/typecheck/TcDeriv.lhs 804
-  | cls_key == dataClassKey    	   = Just (cond_mayDeriveDataTypeable `andCond` cond_std `andCond` cond_noUnliftedArgs)
-  | cls_key == functorClassKey 	   = Just (cond_functorOK True)	 -- NB: no cond_std!
-  | cls_key == foldableClassKey	   = Just (cond_functorOK False) -- Functor/Fold/Trav works ok for rank-n types
-  | cls_key == traversableClassKey = Just (cond_functorOK False)
-  | getName cls `elem` typeableClassNames = Just (cond_mayDeriveDataTypeable `andCond` cond_typeableOK)
+  | cls_key == dataClassKey    	   = Just (checkFlag Opt_DeriveDataTypeable `andCond` 
+                                           cond_std `andCond` cond_noUnliftedArgs)
+  | cls_key == functorClassKey 	   = Just (checkFlag Opt_DeriveFunctor `andCond`
+    	                                   cond_functorOK True)	 -- NB: no cond_std!
+  | cls_key == foldableClassKey	   = Just (checkFlag Opt_DeriveFoldable `andCond`
+    	                                   cond_functorOK False) -- Functor/Fold/Trav works ok for rank-n types
+  | cls_key == traversableClassKey = Just (checkFlag Opt_DeriveTraversable `andCond`
+    	                                   cond_functorOK False)
+  | getName cls `elem` typeableClassNames = Just (checkFlag Opt_DeriveDataTypeable `andCond` cond_typeableOK)
hunk ./compiler/typecheck/TcDeriv.lhs 943
-cond_mayDeriveDataTypeable :: Condition
-cond_mayDeriveDataTypeable (dflags, _)
- | dopt Opt_DeriveDataTypeable dflags = Nothing
- | otherwise = Just why
+checkFlag :: DynFlag -> Condition
+checkFlag flag (dflags, _)
+  | dopt flag dflags = Nothing
+  | otherwise        = Just why
hunk ./compiler/typecheck/TcDeriv.lhs 948
-    why  = ptext (sLit "You need -XDeriveDataTypeable to derive an instance for this class")
+    why = ptext (sLit "You need -X") <> text flag_str 
+          <+> ptext (sLit "to derive an instance for this class")
+    flag_str = case [ s | (s, f, _) <- xFlags, f==flag ] of
+                 [s]   -> s
+                 other -> pprPanic "checkFlag" (ppr other)
hunk ./docs/users_guide/glasgow_exts.xml 2685
-<title>Deriving clause for classes <literal>Typeable</literal> and <literal>Data</literal></title>
+<title>Deriving clause for extra classes (<literal>Typeable</literal>, <literal>Data</literal>, etc)</title>
hunk ./docs/users_guide/glasgow_exts.xml 2695
-GHC extends this list with two more classes that may be automatically derived 
-(provided the <option>-XDeriveDataTypeable</option> flag is specified):
-<literal>Typeable</literal>, and <literal>Data</literal>.  These classes are defined in the library
-modules <literal>Data.Typeable</literal> and <literal>Data.Generics</literal> respectively, and the
-appropriate class must be in scope before it can be mentioned in the <literal>deriving</literal> clause.
+GHC extends this list with several more classes that may be automatically derived:
+<itemizedlist>
+<listitem><para> With <option>-XDeriveDataTypeable</option>, you can derive instances of the classes
+<literal>Typeable</literal>, and <literal>Data</literal>, defined in the library
+modules <literal>Data.Typeable</literal> and <literal>Data.Generics</literal> respectively.
hunk ./docs/users_guide/glasgow_exts.xml 2715
+</listitem>
+
+<listitem><para> With <option>-XDeriveFunctor</option>, you can derive instances of 
+the class <literal>Functor</literal>,
+defined in <literal>GHC.Base</literal>.
+</para></listitem>
+
+<listitem><para> With <option>-XDeriveFoldable</option>, you can derive instances of 
+the class <literal>Foldable</literal>,
+defined in <literal>Data.Foldable</literal>.
+</para></listitem>
+
+<listitem><para> With <option>-XDeriveTraversable</option>, you can derive instances of 
+the class <literal>Traversable</literal>,
+defined in <literal>Data.Traversable</literal>.
+</para></listitem>
+</itemizedlist>
+In each case the appropriate class must be in scope before it 
+can be mentioned in the <literal>deriving</literal> clause.
+</para>
}