Implement deriving strategies
[ghc.git] / utils / mkUserGuidePart / Options / Language.hs
1 module Options.Language where
2
3 import Types
4
5 languageOptions :: [Flag]
6 languageOptions =
7 [ flag { flagName = "-fconstraint-solver-iterations=⟨n⟩"
8 , flagDescription =
9 "*default: 4.* Set the iteration limit for the type-constraint "++
10 "solver. Typically one iteration suffices; so please "++
11 "yell if you find you need to set it higher than the default. "++
12 "Zero means infinity."
13 , flagType = DynamicFlag
14 }
15 , flag { flagName = "-freduction-depth=⟨n⟩"
16 , flagDescription =
17 "*default: 200.* Set the :ref:`limit for type simplification "++
18 "<undecidable-instances>`. Zero means infinity."
19 , flagType = DynamicFlag
20 }
21 , flag { flagName = "-fcontext-stack=⟨n⟩"
22 , flagDescription =
23 "Deprecated. Use ``-freduction-depth=⟨n⟩`` instead."
24 , flagType = DynamicFlag
25 }
26 , flag { flagName = "-fglasgow-exts"
27 , flagDescription =
28 "Deprecated. Enable most language extensions; "++
29 "see :ref:`options-language` for exactly which ones."
30 , flagType = DynamicFlag
31 , flagReverse = "-fno-glasgow-exts"
32 }
33 , flag { flagName = "-firrefutable-tuples"
34 , flagDescription = "Make tuple pattern matching irrefutable"
35 , flagType = DynamicFlag
36 , flagReverse = "-fno-irrefutable-tuples"
37 }
38 , flag { flagName = "-fpackage-trust"
39 , flagDescription =
40 "Enable :ref:`Safe Haskell <safe-haskell>` trusted package "++
41 "requirement for trustworthy modules."
42 , flagType = DynamicFlag
43 }
44 , flag { flagName = "-ftype-function-depth=⟨n⟩"
45 , flagDescription = "Deprecated. Use ``-freduction-depth=⟨n⟩`` instead."
46 , flagType = DynamicFlag
47 }
48 , flag { flagName = "-XAllowAmbiguousTypes"
49 , flagDescription =
50 "Allow the user to write :ref:`ambiguous types <ambiguity>`, and "++
51 "the type inference engine to infer them."
52 , flagType = DynamicFlag
53 , flagReverse = "-XNoAllowAmbiguousTypes"
54 , flagSince = "7.8.1"
55 }
56 , flag { flagName = "-XArrows"
57 , flagDescription =
58 "Enable :ref:`arrow notation <arrow-notation>` extension"
59 , flagType = DynamicFlag
60 , flagReverse = "-XNoArrows"
61 , flagSince = "6.8.1"
62 }
63 , flag { flagName = "-XApplicativeDo"
64 , flagDescription =
65 "Enable :ref:`Applicative do-notation desugaring <applicative-do>`"
66 , flagType = DynamicFlag
67 , flagReverse = "-XNoApplicativeDo"
68 , flagSince = "8.0.1"
69 }
70 , flag { flagName = "-XAutoDeriveTypeable"
71 , flagDescription =
72 "As of GHC 7.10, this option is not needed, and should not be "++
73 "used. Previously this would automatically :ref:`derive Typeable "++
74 "instances for every datatype and type class declaration "++
75 "<deriving-typeable>`. Implies :ghc-flag:`-XDeriveDataTypeable`."
76 , flagType = DynamicFlag
77 , flagReverse = "-XNoAutoDeriveTypeable"
78 , flagSince = "7.8.1"
79 }
80 , flag { flagName = "-XBangPatterns"
81 , flagDescription = "Enable :ref:`bang patterns <bang-patterns>`."
82 , flagType = DynamicFlag
83 , flagReverse = "-XNoBangPatterns"
84 , flagSince = "6.8.1"
85 }
86 , flag { flagName = "-XBinaryLiterals"
87 , flagDescription =
88 "Enable support for :ref:`binary literals <binary-literals>`."
89 , flagType = DynamicFlag
90 , flagReverse = "-XNoBinaryLiterals"
91 , flagSince = "7.10.1"
92 }
93 , flag { flagName = "-XCApiFFI"
94 , flagDescription =
95 "Enable :ref:`the CAPI calling convention <ffi-capi>`."
96 , flagType = DynamicFlag
97 , flagReverse = "-XNoCAPIFFI"
98 , flagSince = "7.10.1"
99 }
100 , flag { flagName = "-XConstrainedClassMethods"
101 , flagDescription =
102 "Enable :ref:`constrained class methods <class-method-types>`."
103 , flagType = DynamicFlag
104 , flagReverse = "-XNoConstrainedClassMethods"
105 , flagSince = "6.8.1"
106 }
107 , flag { flagName = "-XConstraintKinds"
108 , flagDescription =
109 "Enable a :ref:`kind of constraints <constraint-kind>`."
110 , flagType = DynamicFlag
111 , flagReverse = "-XNoConstraintKinds"
112 , flagSince = "7.4.1"
113 }
114 , flag { flagName = "-XCPP"
115 , flagDescription =
116 "Enable the :ref:`C preprocessor <c-pre-processor>`."
117 , flagType = DynamicFlag
118 , flagReverse = "-XNoCPP"
119 , flagSince = "6.8.1"
120 }
121 , flag { flagName = "-XDataKinds"
122 , flagDescription = "Enable :ref:`datatype promotion <promotion>`."
123 , flagType = DynamicFlag
124 , flagReverse = "-XNoDataKinds"
125 , flagSince = "7.4.1"
126 }
127 , flag { flagName = "-XDefaultSignatures"
128 , flagDescription =
129 "Enable :ref:`default signatures <class-default-signatures>`."
130 , flagType = DynamicFlag
131 , flagReverse = "-XNoDefaultSignatures"
132 , flagSince = "7.2.1"
133 }
134 , flag { flagName = "-XDeriveAnyClass"
135 , flagDescription =
136 "Enable :ref:`deriving for any class <derive-any-class>`."
137 , flagType = DynamicFlag
138 , flagReverse = "-XNoDeriveAnyClass"
139 , flagSince = "7.10.1"
140 }
141 , flag { flagName = "-XDeriveDataTypeable"
142 , flagDescription =
143 "Enable ``deriving`` for the :ref:`Data class "++
144 "<deriving-typeable>`. Implied by :ghc-flag:`-XAutoDeriveTypeable`."
145 , flagType = DynamicFlag
146 , flagReverse = "-XNoDeriveDataTypeable"
147 , flagSince = "6.8.1"
148 }
149 , flag { flagName = "-XDeriveFunctor"
150 , flagDescription =
151 "Enable :ref:`deriving for the Functor class <deriving-extra>`. "++
152 "Implied by :ghc-flag:`-XDeriveTraversable`."
153 , flagType = DynamicFlag
154 , flagReverse = "-XNoDeriveFunctor"
155 , flagSince = "7.10.1"
156 }
157 , flag { flagName = "-XDeriveFoldable"
158 , flagDescription =
159 "Enable :ref:`deriving for the Foldable class <deriving-extra>`. "++
160 "Implied by :ghc-flag:`-XDeriveTraversable`."
161 , flagType = DynamicFlag
162 , flagReverse = "-XNoDeriveFoldable"
163 , flagSince = "7.10.1"
164 }
165 , flag { flagName = "-XDeriveGeneric"
166 , flagDescription =
167 "Enable :ref:`deriving for the Generic class <deriving-typeable>`."
168 , flagType = DynamicFlag
169 , flagReverse = "-XNoDeriveGeneric"
170 , flagSince = "7.2.1"
171 }
172 , flag { flagName = "-XDeriveGeneric"
173 , flagDescription =
174 "Enable :ref:`deriving for the Generic class <deriving-typeable>`."
175 , flagType = DynamicFlag
176 , flagReverse = "-XNoDeriveGeneric"
177 , flagSince = "7.2.1"
178 }
179 , flag { flagName = "-XDeriveLift"
180 , flagDescription =
181 "Enable :ref:`deriving for the Lift class <deriving-lift>`"
182 , flagType = DynamicFlag
183 , flagReverse = "-XNoDeriveLift"
184 , flagSince = "7.2.1"
185 }
186 , flag { flagName = "-XDeriveTraversable"
187 , flagDescription =
188 "Enable :ref:`deriving for the Traversable class <deriving-extra>`. "++
189 "Implies :ghc-flag:`-XDeriveFunctor` and :ghc-flag:`-XDeriveFoldable`."
190 , flagType = DynamicFlag
191 , flagReverse = "-XNoDeriveTraversable"
192 , flagSince = "7.10.1"
193 }
194 , flag { flagName = "-XDerivingStrategies"
195 , flagDescription =
196 "Enables :ref:`deriving strategies <deriving-strategies>`."
197 , flagType = DynamicFlag
198 , flagReverse = "-XNoDerivingStrategies"
199 , flagSince = "8.2.1"
200 }
201 , flag { flagName = "-XDisambiguateRecordFields"
202 , flagDescription =
203 "Enable :ref:`record field disambiguation <disambiguate-fields>`. "++
204 "Implied by :ghc-flag:`-XRecordWildCards`."
205 , flagType = DynamicFlag
206 , flagReverse = "-XNoDisambiguateRecordFields"
207 , flagSince = "6.8.1"
208 }
209 , flag { flagName = "-XEmptyCase"
210 , flagDescription =
211 "Allow :ref:`empty case alternatives <empty-case>`."
212 , flagType = DynamicFlag
213 , flagReverse = "-XNoEmptyCase"
214 , flagSince = "7.8.1"
215 }
216 , flag { flagName = "-XEmptyDataDecls"
217 , flagDescription = "Enable empty data declarations."
218 , flagType = DynamicFlag
219 , flagReverse = "-XNoEmptyDataDecls"
220 , flagSince = "6.8.1"
221 }
222 , flag { flagName = "-XExistentialQuantification"
223 , flagDescription =
224 "Enable :ref:`existential quantification <existential-quantification>`."
225 , flagType = DynamicFlag
226 , flagReverse = "-XNoExistentialQuantification"
227 , flagSince = "6.8.1"
228 }
229 , flag { flagName = "-XExplicitForAll"
230 , flagDescription =
231 "Enable :ref:`explicit universal quantification <explicit-foralls>`."++
232 " Implied by :ghc-flag:`-XScopedTypeVariables`, :ghc-flag:`-XLiberalTypeSynonyms`,"++
233 " :ghc-flag:`-XRankNTypes` and :ghc-flag:`-XExistentialQuantification`."
234 , flagType = DynamicFlag
235 , flagReverse = "-XNoExplicitForAll"
236 , flagSince = "6.12.1"
237 }
238 , flag { flagName = "-XExplicitNamespaces"
239 , flagDescription =
240 "Enable using the keyword ``type`` to specify the namespace of "++
241 "entries in imports and exports (:ref:`explicit-namespaces`). "++
242 "Implied by :ghc-flag:`-XTypeOperators` and :ghc-flag:`-XTypeFamilies`."
243 , flagType = DynamicFlag
244 , flagReverse = "-XNoExplicitNamespaces"
245 , flagSince = "7.6.1"
246 }
247 , flag { flagName = "-XExtendedDefaultRules"
248 , flagDescription =
249 "Use GHCi's :ref:`extended default rules <extended-default-rules>` "++
250 "in a normal module."
251 , flagType = DynamicFlag
252 , flagReverse = "-XNoExtendedDefaultRules"
253 , flagSince = "6.8.1"
254 }
255 , flag { flagName = "-XFlexibleContexts"
256 , flagDescription =
257 "Enable :ref:`flexible contexts <flexible-contexts>`. Implied by "++
258 ":ghc-flag:`-XImplicitParams`."
259 , flagType = DynamicFlag
260 , flagReverse = "-XNoFlexibleContexts"
261 , flagSince = "6.8.1"
262 }
263 , flag { flagName = "-XFlexibleInstances"
264 , flagDescription =
265 "Enable :ref:`flexible instances <instance-rules>`. "++
266 "Implies :ghc-flag:`-XTypeSynonymInstances`. "++
267 "Implied by :ghc-flag:`-XImplicitParams`."
268 , flagType = DynamicFlag
269 , flagReverse = "-XNoFlexibleInstances"
270 , flagSince = "6.8.1"
271 }
272 , flag { flagName = "-XForeignFunctionInterface"
273 , flagDescription =
274 "Enable :ref:`foreign function interface <ffi>`."
275 , flagType = DynamicFlag
276 , flagReverse = "-XNoForeignFunctionInterface"
277 , flagSince = "6.8.1"
278 }
279 , flag { flagName = "-XFunctionalDependencies"
280 , flagDescription =
281 "Enable :ref:`functional dependencies <functional-dependencies>`. "++
282 "Implies :ghc-flag:`-XMultiParamTypeClasses`."
283 , flagType = DynamicFlag
284 , flagReverse = "-XNoFunctionalDependencies"
285 , flagSince = "6.8.1"
286 }
287 , flag { flagName = "-XGADTs"
288 , flagDescription =
289 "Enable :ref:`generalised algebraic data types <gadt>`. "++
290 "Implies :ghc-flag:`-XGADTSyntax` and :ghc-flag:`-XMonoLocalBinds`."
291 , flagType = DynamicFlag
292 , flagReverse = "-XNoGADTs"
293 , flagSince = "6.8.1"
294 }
295 , flag { flagName = "-XGADTSyntax"
296 , flagDescription =
297 "Enable :ref:`generalised algebraic data type syntax <gadt-style>`."
298 , flagType = DynamicFlag
299 , flagReverse = "-XNoGADTSyntax"
300 , flagSince = "7.2.1"
301 }
302 , flag { flagName = "-XGeneralizedNewtypeDeriving"
303 , flagDescription =
304 "Enable :ref:`newtype deriving <newtype-deriving>`."
305 , flagType = DynamicFlag
306 , flagReverse = "-XNoGeneralizedNewtypeDeriving"
307 , flagSince = "6.8.1"
308 }
309 , flag { flagName = "-XGenerics"
310 , flagDescription =
311 "Deprecated, does nothing. No longer enables "++
312 ":ref:`generic classes <generic-classes>`. See also GHC's support "++
313 "for :ref:`generic programming <generic-programming>`."
314 , flagType = DynamicFlag
315 , flagReverse = "-XNoGenerics"
316 , flagSince = "6.8.1"
317 }
318 , flag { flagName = "-XImplicitParams"
319 , flagDescription =
320 "Enable :ref:`Implicit Parameters <implicit-parameters>`. "++
321 "Implies :ghc-flag:`-XFlexibleContexts` and :ghc-flag:`-XFlexibleInstances`."
322 , flagType = DynamicFlag
323 , flagReverse = "-XNoImplicitParams"
324 , flagSince = "6.8.1"
325 }
326 , flag { flagName = "-XNoImplicitPrelude"
327 , flagDescription =
328 "Don't implicitly ``import Prelude``. "++
329 "Implied by :ghc-flag:`-XRebindableSyntax`."
330 , flagType = DynamicFlag
331 , flagReverse = "-XImplicitPrelude"
332 , flagSince = "6.8.1"
333 }
334 , flag { flagName = "-XImpredicativeTypes"
335 , flagDescription =
336 "Enable :ref:`impredicative types <impredicative-polymorphism>`. "++
337 "Implies :ghc-flag:`-XRankNTypes`."
338 , flagType = DynamicFlag
339 , flagReverse = "-XNoImpredicativeTypes"
340 , flagSince = "6.10.1"
341 }
342 , flag { flagName = "-XIncoherentInstances"
343 , flagDescription =
344 "Enable :ref:`incoherent instances <instance-overlap>`. "++
345 "Implies :ghc-flag:`-XOverlappingInstances`."
346 , flagType = DynamicFlag
347 , flagReverse = "-XNoIncoherentInstances"
348 , flagSince = "6.8.1"
349 }
350 , flag { flagName = "-XTypeFamilyDependencies"
351 , flagDescription =
352 "Enable :ref:`injective type families <injective-ty-fams>`. "++
353 "Implies :ghc-flag:`-XTypeFamilies`."
354 , flagType = DynamicFlag
355 , flagReverse = "-XNoTypeFamilyDependencies"
356 , flagSince = "8.0.1"
357 }
358 , flag { flagName = "-XInstanceSigs"
359 , flagDescription =
360 "Enable :ref:`instance signatures <instance-sigs>`."
361 , flagType = DynamicFlag
362 , flagReverse = "-XNoInstanceSigs"
363 , flagSince = "7.10.1"
364 }
365 , flag { flagName = "-XInterruptibleFFI"
366 , flagDescription = "Enable interruptible FFI."
367 , flagType = DynamicFlag
368 , flagReverse = "-XNoInterruptibleFFI"
369 , flagSince = "7.2.1"
370 }
371 , flag { flagName = "-XKindSignatures"
372 , flagDescription =
373 "Enable :ref:`kind signatures <kinding>`. "++
374 "Implied by :ghc-flag:`-XTypeFamilies` and :ghc-flag:`-XPolyKinds`."
375 , flagType = DynamicFlag
376 , flagReverse = "-XNoKindSignatures"
377 , flagSince = "6.8.1"
378 }
379 , flag { flagName = "-XLambdaCase"
380 , flagDescription =
381 "Enable :ref:`lambda-case expressions <lambda-case>`."
382 , flagType = DynamicFlag
383 , flagReverse = "-XNoLambdaCase"
384 , flagSince = "7.6.1"
385 }
386 , flag { flagName = "-XLiberalTypeSynonyms"
387 , flagDescription =
388 "Enable :ref:`liberalised type synonyms <type-synonyms>`."
389 , flagType = DynamicFlag
390 , flagReverse = "-XNoLiberalTypeSynonyms"
391 , flagSince = "6.8.1"
392 }
393 , flag { flagName = "-XMagicHash"
394 , flagDescription =
395 "Allow ``#`` as a :ref:`postfix modifier on identifiers <magic-hash>`."
396 , flagType = DynamicFlag
397 , flagReverse = "-XNoMagicHash"
398 , flagSince = "6.8.1"
399 }
400 , flag { flagName = "-XMonadComprehensions"
401 , flagDescription =
402 "Enable :ref:`monad comprehensions <monad-comprehensions>`."
403 , flagType = DynamicFlag
404 , flagReverse = "-XNoMonadComprehensions"
405 , flagSince = "7.2.1"
406 }
407 , flag { flagName = "-XMonoLocalBinds"
408 , flagDescription =
409 "Enable :ref:`do not generalise local bindings <mono-local-binds>`. "++
410 "Implied by :ghc-flag:`-XTypeFamilies` and :ghc-flag:`-XGADTs`."
411 , flagType = DynamicFlag
412 , flagReverse = "-XNoMonoLocalBinds"
413 , flagSince = "6.12.1"
414 }
415 , flag { flagName = "-XNoMonomorphismRestriction"
416 , flagDescription =
417 "Disable the :ref:`monomorphism restriction <monomorphism>`."
418 , flagType = DynamicFlag
419 , flagReverse = "-XMonomorphismRestriction"
420 , flagSince = "6.8.1"
421 }
422 , flag { flagName = "-XMultiParamTypeClasses"
423 , flagDescription =
424 "Enable :ref:`multi parameter type classes "++
425 "<multi-param-type-classes>`. Implied by "++
426 ":ghc-flag:`-XFunctionalDependencies`."
427 , flagType = DynamicFlag
428 , flagReverse = "-XNoMultiParamTypeClasses"
429 , flagSince = "6.8.1"
430 }
431 , flag { flagName = "-XMultiWayIf"
432 , flagDescription =
433 "Enable :ref:`multi-way if-expressions <multi-way-if>`."
434 , flagType = DynamicFlag
435 , flagReverse = "-XNoMultiWayIf"
436 , flagSince = "7.6.1"
437 }
438 , flag { flagName = "-XNamedFieldPuns"
439 , flagDescription = "Enable :ref:`record puns <record-puns>`."
440 , flagType = DynamicFlag
441 , flagReverse = "-XNoNamedFieldPuns"
442 , flagSince = "6.10.1"
443 }
444 , flag { flagName = "-XNamedWildCards"
445 , flagDescription = "Enable :ref:`named wildcards <named-wildcards>`."
446 , flagType = DynamicFlag
447 , flagReverse = "-XNoNamedWildCards"
448 , flagSince = "7.10.1"
449 }
450 , flag { flagName = "-XNegativeLiterals"
451 , flagDescription =
452 "Enable support for :ref:`negative literals <negative-literals>`."
453 , flagType = DynamicFlag
454 , flagReverse = "-XNoNegativeLiterals"
455 , flagSince = "7.8.1"
456 }
457 , flag { flagName = "-XNPlusKPatterns"
458 , flagDescription = "Enable support for ``n+k`` patterns. "++
459 "Implied by :ghc-flag:`-XHaskell98`."
460 , flagType = DynamicFlag
461 , flagReverse = "-XNoNPlusKPatterns"
462 , flagSince = "6.12.1"
463 }
464 , flag { flagName = "-XNullaryTypeClasses"
465 , flagDescription =
466 "Deprecated, does nothing. :ref:`nullary (no parameter) type "++
467 "classes <nullary-type-classes>` are now enabled using "++
468 ":ghc-flag:`-XMultiParamTypeClasses`."
469 , flagType = DynamicFlag
470 , flagReverse = "-XNoNullaryTypeClasses"
471 , flagSince = "7.8.1"
472 }
473 , flag { flagName = "-XNumDecimals"
474 , flagDescription =
475 "Enable support for 'fractional' integer literals."
476 , flagType = DynamicFlag
477 , flagReverse = "-XNoNumDecimals"
478 , flagSince = "7.8.1"
479 }
480 , flag { flagName = "-XOverlappingInstances"
481 , flagDescription =
482 "Enable :ref:`overlapping instances <instance-overlap>`."
483 , flagType = DynamicFlag
484 , flagReverse = "-XNoOverlappingInstances"
485 , flagSince = "6.8.1"
486 }
487 , flag { flagName = "-XOverloadedLists"
488 , flagDescription =
489 "Enable :ref:`overloaded lists <overloaded-lists>`."
490 , flagType = DynamicFlag
491 , flagReverse = "-XNoOverloadedLists"
492 , flagSince = "7.8.1"
493 }
494 , flag { flagName = "-XOverloadedStrings"
495 , flagDescription =
496 "Enable :ref:`overloaded string literals <overloaded-strings>`."
497 , flagType = DynamicFlag
498 , flagReverse = "-XNoOverloadedStrings"
499 , flagSince = "6.8.1"
500 }
501 , flag { flagName = "-XPackageImports"
502 , flagDescription =
503 "Enable :ref:`package-qualified imports <package-imports>`."
504 , flagType = DynamicFlag
505 , flagReverse = "-XNoPackageImports"
506 , flagSince = "6.10.1"
507 }
508 , flag { flagName = "-XParallelArrays"
509 , flagDescription =
510 "Enable parallel arrays. Implies :ghc-flag:`-XParallelListComp`."
511 , flagType = DynamicFlag
512 , flagReverse = "-XNoParallelArrays"
513 , flagSince = "7.4.1"
514 }
515 , flag { flagName = "-XParallelListComp"
516 , flagDescription =
517 "Enable :ref:`parallel list comprehensions "++
518 "<parallel-list-comprehensions>`. "++
519 "Implied by :ghc-flag:`-XParallelArrays`."
520 , flagType = DynamicFlag
521 , flagReverse = "-XNoParallelListComp"
522 , flagSince = "6.8.1"
523 }
524 , flag { flagName = "-XPartialTypeSignatures"
525 , flagDescription =
526 "Enable :ref:`partial type signatures <partial-type-signatures>`."
527 , flagType = DynamicFlag
528 , flagReverse = "-XNoPartialTypeSignatures"
529 , flagSince = "7.10.1"
530 }
531 , flag { flagName = "-XNoPatternGuards"
532 , flagDescription = "Disable :ref:`pattern guards <pattern-guards>`. "++
533 "Implied by :ghc-flag:`-XHaskell98`."
534 , flagType = DynamicFlag
535 , flagReverse = "-XPatternGuards"
536 , flagSince = "6.8.1"
537 }
538 , flag { flagName = "-XPatternSynonyms"
539 , flagDescription =
540 "Enable :ref:`pattern synonyms <pattern-synonyms>`."
541 , flagType = DynamicFlag
542 , flagReverse = "-XNoPatternSynonyms"
543 , flagSince = "7.10.1"
544 }
545 , flag { flagName = "-XPolyKinds"
546 , flagDescription =
547 "Enable :ref:`kind polymorphism <kind-polymorphism>`. "++
548 "Implies :ghc-flag:`-XKindSignatures`."
549 , flagType = DynamicFlag
550 , flagReverse = "-XNoPolyKinds"
551 , flagSince = "7.4.1"
552 }
553 , flag { flagName = "-XPolymorphicComponents"
554 , flagDescription =
555 "Enable :ref:`polymorphic components for data constructors "++
556 "<universal-quantification>`. Synonym for :ghc-flag:`-XRankNTypes`."
557 , flagType = DynamicFlag
558 , flagReverse = "-XNoPolymorphicComponents"
559 , flagSince = "6.8.1"
560 }
561 , flag { flagName = "-XPostfixOperators"
562 , flagDescription =
563 "Enable :ref:`postfix operators <postfix-operators>`."
564 , flagType = DynamicFlag
565 , flagReverse = "-XNoPostfixOperators"
566 , flagSince = "7.10.1"
567 }
568 , flag { flagName = "-XQuasiQuotes"
569 , flagDescription = "Enable :ref:`quasiquotation <th-quasiquotation>`."
570 , flagType = DynamicFlag
571 , flagReverse = "-XNoQuasiQuotes"
572 , flagSince = "6.10.1"
573 }
574 , flag { flagName = "-XRank2Types"
575 , flagDescription =
576 "Enable :ref:`rank-2 types <universal-quantification>`. "++
577 "Synonym for :ghc-flag:`-XRankNTypes`."
578 , flagType = DynamicFlag
579 , flagReverse = "-XNoRank2Types"
580 , flagSince = "6.8.1"
581 }
582 , flag { flagName = "-XRankNTypes"
583 , flagDescription =
584 "Enable :ref:`rank-N types <universal-quantification>`. "++
585 "Implied by :ghc-flag:`-XImpredicativeTypes`."
586 , flagType = DynamicFlag
587 , flagReverse = "-XNoRankNTypes"
588 , flagSince = "6.8.1"
589 }
590 , flag { flagName = "-XRebindableSyntax"
591 , flagDescription =
592 "Employ :ref:`rebindable syntax <rebindable-syntax>`. "++
593 "Implies :ghc-flag:`-XNoImplicitPrelude`."
594 , flagType = DynamicFlag
595 , flagReverse = "-XNoRebindableSyntax"
596 , flagSince = "7.0.1"
597 }
598 , flag { flagName = "-XRecordWildCards"
599 , flagDescription =
600 "Enable :ref:`record wildcards <record-wildcards>`. "++
601 "Implies :ghc-flag:`-XDisambiguateRecordFields`."
602 , flagType = DynamicFlag
603 , flagReverse = "-XNoRecordWildCards"
604 , flagSince = "6.8.1"
605 }
606 , flag { flagName = "-XRecursiveDo"
607 , flagDescription =
608 "Enable :ref:`recursive do (mdo) notation <recursive-do-notation>`."
609 , flagType = DynamicFlag
610 , flagReverse = "-XNoRecursiveDo"
611 , flagSince = "6.8.1"
612 }
613 , flag { flagName = "-XRoleAnnotations"
614 , flagDescription =
615 "Enable :ref:`role annotations <role-annotations>`."
616 , flagType = DynamicFlag
617 , flagReverse = "-XNoRoleAnnotations"
618 , flagSince = "7.10.1"
619 }
620 , flag { flagName = "-XSafe"
621 , flagDescription =
622 "Enable the :ref:`Safe Haskell <safe-haskell>` Safe mode."
623 , flagType = DynamicFlag
624 , flagSince = "7.2.1"
625 }
626 , flag { flagName = "-XScopedTypeVariables"
627 , flagDescription =
628 "Enable :ref:`lexically-scoped type variables "++
629 "<scoped-type-variables>`."
630 , flagType = DynamicFlag
631 , flagReverse = "-XNoScopedTypeVariables"
632 , flagSince = "6.8.1"
633 }
634 , flag { flagName = "-XStandaloneDeriving"
635 , flagDescription =
636 "Enable :ref:`standalone deriving <stand-alone-deriving>`."
637 , flagType = DynamicFlag
638 , flagReverse = "-XNoStandaloneDeriving"
639 , flagSince = "6.8.1"
640 }
641 , flag { flagName = "-XStaticPointers"
642 , flagDescription =
643 "Enable :ref:`static pointers <static-pointers>`."
644 , flagType = DynamicFlag
645 , flagReverse = "-XNoStaticPointers"
646 , flagSince = "7.10.1"
647 }
648 , flag { flagName = "-XStrictData"
649 , flagDescription =
650 "Enable :ref:`default strict datatype fields <strict-data>`."
651 , flagType = DynamicFlag
652 , flagReverse = "-XNoStrictData"
653 }
654 , flag { flagName = "-XTemplateHaskell"
655 , flagDescription =
656 "Enable :ref:`Template Haskell <template-haskell>`."
657 , flagType = DynamicFlag
658 , flagReverse = "-XNoTemplateHaskell"
659 , flagSince = "6.8.1"
660 }
661 , flag { flagName = "-XTemplateHaskellQuotes"
662 , flagDescription = "Enable quotation subset of "++
663 ":ref:`Template Haskell <template-haskell>`."
664 , flagType = DynamicFlag
665 , flagReverse = "-XNoTemplateHaskellQuotes"
666 , flagSince = "8.0.1"
667 }
668 , flag { flagName = "-XNoTraditionalRecordSyntax"
669 , flagDescription =
670 "Disable support for traditional record syntax "++
671 "(as supported by Haskell 98) ``C {f = x}``"
672 , flagType = DynamicFlag
673 , flagReverse = "-XTraditionalRecordSyntax"
674 , flagSince = "7.4.1"
675 }
676 , flag { flagName = "-XTransformListComp"
677 , flagDescription =
678 "Enable :ref:`generalised list comprehensions "++
679 "<generalised-list-comprehensions>`."
680 , flagType = DynamicFlag
681 , flagReverse = "-XNoTransformListComp"
682 , flagSince = "6.10.1"
683 }
684 , flag { flagName = "-XTrustworthy"
685 , flagDescription =
686 "Enable the :ref:`Safe Haskell <safe-haskell>` Trustworthy mode."
687 , flagType = DynamicFlag
688 , flagSince = "7.2.1"
689 }
690 , flag { flagName = "-XTupleSections"
691 , flagDescription = "Enable :ref:`tuple sections <tuple-sections>`."
692 , flagType = DynamicFlag
693 , flagReverse = "-XNoTupleSections"
694 , flagSince = "7.10.1"
695 }
696 , flag { flagName = "-XTypeFamilies"
697 , flagDescription =
698 "Enable :ref:`type families <type-families>`. "++
699 "Implies :ghc-flag:`-XExplicitNamespaces`, :ghc-flag:`-XKindSignatures`, "++
700 "and :ghc-flag:`-XMonoLocalBinds`."
701 , flagType = DynamicFlag
702 , flagReverse = "-XNoTypeFamilies"
703 , flagSince = "6.8.1"
704 }
705 , flag { flagName = "-XTypeOperators"
706 , flagDescription =
707 "Enable :ref:`type operators <type-operators>`. "++
708 "Implies :ghc-flag:`-XExplicitNamespaces`."
709 , flagType = DynamicFlag
710 , flagReverse = "-XNoTypeOperators"
711 , flagSince = "6.8.1"
712 }
713 , flag { flagName = "-XTypeSynonymInstances"
714 , flagDescription =
715 "Enable :ref:`type synonyms in instance heads "++
716 "<flexible-instance-head>`. Implied by :ghc-flag:`-XFlexibleInstances`."
717 , flagType = DynamicFlag
718 , flagReverse = "-XNoTypeSynonymInstances"
719 , flagSince = "6.8.1"
720 }
721 , flag { flagName = "-XUnboxedTuples"
722 , flagDescription = "Enable :ref:`unboxed tuples <unboxed-tuples>`."
723 , flagType = DynamicFlag
724 , flagReverse = "-XNoUnboxedTuples"
725 , flagSince = "6.8.1"
726 }
727 , flag { flagName ="-XUnboxedSums"
728 , flagDescription = "Enable :ref: `unboxed sums <unboxed-sums>`."
729 , flagType = DynamicFlag
730 , flagReverse = "-XNoUnboxedSums"
731 , flagSince = "8.2.1"
732 }
733 , flag { flagName = "-XUndecidableInstances"
734 , flagDescription =
735 "Enable :ref:`undecidable instances <undecidable-instances>`."
736 , flagType = DynamicFlag
737 , flagReverse = "-XNoUndecidableInstances"
738 , flagSince = "6.8.1"
739 }
740 , flag { flagName = "-XUnicodeSyntax"
741 , flagDescription = "Enable :ref:`unicode syntax <unicode-syntax>`."
742 , flagType = DynamicFlag
743 , flagReverse = "-XNoUnicodeSyntax"
744 , flagSince = "6.8.1"
745 }
746 , flag { flagName = "-XUnliftedFFITypes"
747 , flagDescription = "Enable unlifted FFI types."
748 , flagType = DynamicFlag
749 , flagReverse = "-XNoUnliftedFFITypes"
750 , flagSince = "6.8.1"
751 }
752 , flag { flagName = "-XUnsafe"
753 , flagDescription =
754 "Enable :ref:`Safe Haskell <safe-haskell>` Unsafe mode."
755 , flagType = DynamicFlag
756 , flagSince = "7.4.1"
757 }
758 , flag { flagName = "-XViewPatterns"
759 , flagDescription = "Enable :ref:`view patterns <view-patterns>`."
760 , flagType = DynamicFlag
761 , flagReverse = "-XNoViewPatterns"
762 , flagSince = "6.10.1"
763 }
764 ]