Implement unboxed sum primitive type
[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 = "-XDisambiguateRecordFields"
195 , flagDescription =
196 "Enable :ref:`record field disambiguation <disambiguate-fields>`. "++
197 "Implied by :ghc-flag:`-XRecordWildCards`."
198 , flagType = DynamicFlag
199 , flagReverse = "-XNoDisambiguateRecordFields"
200 , flagSince = "6.8.1"
201 }
202 , flag { flagName = "-XEmptyCase"
203 , flagDescription =
204 "Allow :ref:`empty case alternatives <empty-case>`."
205 , flagType = DynamicFlag
206 , flagReverse = "-XNoEmptyCase"
207 , flagSince = "7.8.1"
208 }
209 , flag { flagName = "-XEmptyDataDecls"
210 , flagDescription = "Enable empty data declarations."
211 , flagType = DynamicFlag
212 , flagReverse = "-XNoEmptyDataDecls"
213 , flagSince = "6.8.1"
214 }
215 , flag { flagName = "-XExistentialQuantification"
216 , flagDescription =
217 "Enable :ref:`existential quantification <existential-quantification>`."
218 , flagType = DynamicFlag
219 , flagReverse = "-XNoExistentialQuantification"
220 , flagSince = "6.8.1"
221 }
222 , flag { flagName = "-XExplicitForAll"
223 , flagDescription =
224 "Enable :ref:`explicit universal quantification <explicit-foralls>`."++
225 " Implied by :ghc-flag:`-XScopedTypeVariables`, :ghc-flag:`-XLiberalTypeSynonyms`,"++
226 " :ghc-flag:`-XRankNTypes` and :ghc-flag:`-XExistentialQuantification`."
227 , flagType = DynamicFlag
228 , flagReverse = "-XNoExplicitForAll"
229 , flagSince = "6.12.1"
230 }
231 , flag { flagName = "-XExplicitNamespaces"
232 , flagDescription =
233 "Enable using the keyword ``type`` to specify the namespace of "++
234 "entries in imports and exports (:ref:`explicit-namespaces`). "++
235 "Implied by :ghc-flag:`-XTypeOperators` and :ghc-flag:`-XTypeFamilies`."
236 , flagType = DynamicFlag
237 , flagReverse = "-XNoExplicitNamespaces"
238 , flagSince = "7.6.1"
239 }
240 , flag { flagName = "-XExtendedDefaultRules"
241 , flagDescription =
242 "Use GHCi's :ref:`extended default rules <extended-default-rules>` "++
243 "in a normal module."
244 , flagType = DynamicFlag
245 , flagReverse = "-XNoExtendedDefaultRules"
246 , flagSince = "6.8.1"
247 }
248 , flag { flagName = "-XFlexibleContexts"
249 , flagDescription =
250 "Enable :ref:`flexible contexts <flexible-contexts>`. Implied by "++
251 ":ghc-flag:`-XImplicitParams`."
252 , flagType = DynamicFlag
253 , flagReverse = "-XNoFlexibleContexts"
254 , flagSince = "6.8.1"
255 }
256 , flag { flagName = "-XFlexibleInstances"
257 , flagDescription =
258 "Enable :ref:`flexible instances <instance-rules>`. "++
259 "Implies :ghc-flag:`-XTypeSynonymInstances`. "++
260 "Implied by :ghc-flag:`-XImplicitParams`."
261 , flagType = DynamicFlag
262 , flagReverse = "-XNoFlexibleInstances"
263 , flagSince = "6.8.1"
264 }
265 , flag { flagName = "-XForeignFunctionInterface"
266 , flagDescription =
267 "Enable :ref:`foreign function interface <ffi>`."
268 , flagType = DynamicFlag
269 , flagReverse = "-XNoForeignFunctionInterface"
270 , flagSince = "6.8.1"
271 }
272 , flag { flagName = "-XFunctionalDependencies"
273 , flagDescription =
274 "Enable :ref:`functional dependencies <functional-dependencies>`. "++
275 "Implies :ghc-flag:`-XMultiParamTypeClasses`."
276 , flagType = DynamicFlag
277 , flagReverse = "-XNoFunctionalDependencies"
278 , flagSince = "6.8.1"
279 }
280 , flag { flagName = "-XGADTs"
281 , flagDescription =
282 "Enable :ref:`generalised algebraic data types <gadt>`. "++
283 "Implies :ghc-flag:`-XGADTSyntax` and :ghc-flag:`-XMonoLocalBinds`."
284 , flagType = DynamicFlag
285 , flagReverse = "-XNoGADTs"
286 , flagSince = "6.8.1"
287 }
288 , flag { flagName = "-XGADTSyntax"
289 , flagDescription =
290 "Enable :ref:`generalised algebraic data type syntax <gadt-style>`."
291 , flagType = DynamicFlag
292 , flagReverse = "-XNoGADTSyntax"
293 , flagSince = "7.2.1"
294 }
295 , flag { flagName = "-XGeneralizedNewtypeDeriving"
296 , flagDescription =
297 "Enable :ref:`newtype deriving <newtype-deriving>`."
298 , flagType = DynamicFlag
299 , flagReverse = "-XNoGeneralizedNewtypeDeriving"
300 , flagSince = "6.8.1"
301 }
302 , flag { flagName = "-XGenerics"
303 , flagDescription =
304 "Deprecated, does nothing. No longer enables "++
305 ":ref:`generic classes <generic-classes>`. See also GHC's support "++
306 "for :ref:`generic programming <generic-programming>`."
307 , flagType = DynamicFlag
308 , flagReverse = "-XNoGenerics"
309 , flagSince = "6.8.1"
310 }
311 , flag { flagName = "-XImplicitParams"
312 , flagDescription =
313 "Enable :ref:`Implicit Parameters <implicit-parameters>`. "++
314 "Implies :ghc-flag:`-XFlexibleContexts` and :ghc-flag:`-XFlexibleInstances`."
315 , flagType = DynamicFlag
316 , flagReverse = "-XNoImplicitParams"
317 , flagSince = "6.8.1"
318 }
319 , flag { flagName = "-XNoImplicitPrelude"
320 , flagDescription =
321 "Don't implicitly ``import Prelude``. "++
322 "Implied by :ghc-flag:`-XRebindableSyntax`."
323 , flagType = DynamicFlag
324 , flagReverse = "-XImplicitPrelude"
325 , flagSince = "6.8.1"
326 }
327 , flag { flagName = "-XImpredicativeTypes"
328 , flagDescription =
329 "Enable :ref:`impredicative types <impredicative-polymorphism>`. "++
330 "Implies :ghc-flag:`-XRankNTypes`."
331 , flagType = DynamicFlag
332 , flagReverse = "-XNoImpredicativeTypes"
333 , flagSince = "6.10.1"
334 }
335 , flag { flagName = "-XIncoherentInstances"
336 , flagDescription =
337 "Enable :ref:`incoherent instances <instance-overlap>`. "++
338 "Implies :ghc-flag:`-XOverlappingInstances`."
339 , flagType = DynamicFlag
340 , flagReverse = "-XNoIncoherentInstances"
341 , flagSince = "6.8.1"
342 }
343 , flag { flagName = "-XTypeFamilyDependencies"
344 , flagDescription =
345 "Enable :ref:`injective type families <injective-ty-fams>`. "++
346 "Implies :ghc-flag:`-XTypeFamilies`."
347 , flagType = DynamicFlag
348 , flagReverse = "-XNoTypeFamilyDependencies"
349 , flagSince = "8.0.1"
350 }
351 , flag { flagName = "-XInstanceSigs"
352 , flagDescription =
353 "Enable :ref:`instance signatures <instance-sigs>`."
354 , flagType = DynamicFlag
355 , flagReverse = "-XNoInstanceSigs"
356 , flagSince = "7.10.1"
357 }
358 , flag { flagName = "-XInterruptibleFFI"
359 , flagDescription = "Enable interruptible FFI."
360 , flagType = DynamicFlag
361 , flagReverse = "-XNoInterruptibleFFI"
362 , flagSince = "7.2.1"
363 }
364 , flag { flagName = "-XKindSignatures"
365 , flagDescription =
366 "Enable :ref:`kind signatures <kinding>`. "++
367 "Implied by :ghc-flag:`-XTypeFamilies` and :ghc-flag:`-XPolyKinds`."
368 , flagType = DynamicFlag
369 , flagReverse = "-XNoKindSignatures"
370 , flagSince = "6.8.1"
371 }
372 , flag { flagName = "-XLambdaCase"
373 , flagDescription =
374 "Enable :ref:`lambda-case expressions <lambda-case>`."
375 , flagType = DynamicFlag
376 , flagReverse = "-XNoLambdaCase"
377 , flagSince = "7.6.1"
378 }
379 , flag { flagName = "-XLiberalTypeSynonyms"
380 , flagDescription =
381 "Enable :ref:`liberalised type synonyms <type-synonyms>`."
382 , flagType = DynamicFlag
383 , flagReverse = "-XNoLiberalTypeSynonyms"
384 , flagSince = "6.8.1"
385 }
386 , flag { flagName = "-XMagicHash"
387 , flagDescription =
388 "Allow ``#`` as a :ref:`postfix modifier on identifiers <magic-hash>`."
389 , flagType = DynamicFlag
390 , flagReverse = "-XNoMagicHash"
391 , flagSince = "6.8.1"
392 }
393 , flag { flagName = "-XMonadComprehensions"
394 , flagDescription =
395 "Enable :ref:`monad comprehensions <monad-comprehensions>`."
396 , flagType = DynamicFlag
397 , flagReverse = "-XNoMonadComprehensions"
398 , flagSince = "7.2.1"
399 }
400 , flag { flagName = "-XMonoLocalBinds"
401 , flagDescription =
402 "Enable :ref:`do not generalise local bindings <mono-local-binds>`. "++
403 "Implied by :ghc-flag:`-XTypeFamilies` and :ghc-flag:`-XGADTs`."
404 , flagType = DynamicFlag
405 , flagReverse = "-XNoMonoLocalBinds"
406 , flagSince = "6.12.1"
407 }
408 , flag { flagName = "-XNoMonomorphismRestriction"
409 , flagDescription =
410 "Disable the :ref:`monomorphism restriction <monomorphism>`."
411 , flagType = DynamicFlag
412 , flagReverse = "-XMonomorphismRestriction"
413 , flagSince = "6.8.1"
414 }
415 , flag { flagName = "-XMultiParamTypeClasses"
416 , flagDescription =
417 "Enable :ref:`multi parameter type classes "++
418 "<multi-param-type-classes>`. Implied by "++
419 ":ghc-flag:`-XFunctionalDependencies`."
420 , flagType = DynamicFlag
421 , flagReverse = "-XNoMultiParamTypeClasses"
422 , flagSince = "6.8.1"
423 }
424 , flag { flagName = "-XMultiWayIf"
425 , flagDescription =
426 "Enable :ref:`multi-way if-expressions <multi-way-if>`."
427 , flagType = DynamicFlag
428 , flagReverse = "-XNoMultiWayIf"
429 , flagSince = "7.6.1"
430 }
431 , flag { flagName = "-XNamedFieldPuns"
432 , flagDescription = "Enable :ref:`record puns <record-puns>`."
433 , flagType = DynamicFlag
434 , flagReverse = "-XNoNamedFieldPuns"
435 , flagSince = "6.10.1"
436 }
437 , flag { flagName = "-XNamedWildCards"
438 , flagDescription = "Enable :ref:`named wildcards <named-wildcards>`."
439 , flagType = DynamicFlag
440 , flagReverse = "-XNoNamedWildCards"
441 , flagSince = "7.10.1"
442 }
443 , flag { flagName = "-XNegativeLiterals"
444 , flagDescription =
445 "Enable support for :ref:`negative literals <negative-literals>`."
446 , flagType = DynamicFlag
447 , flagReverse = "-XNoNegativeLiterals"
448 , flagSince = "7.8.1"
449 }
450 , flag { flagName = "-XNPlusKPatterns"
451 , flagDescription = "Enable support for ``n+k`` patterns. "++
452 "Implied by :ghc-flag:`-XHaskell98`."
453 , flagType = DynamicFlag
454 , flagReverse = "-XNoNPlusKPatterns"
455 , flagSince = "6.12.1"
456 }
457 , flag { flagName = "-XNullaryTypeClasses"
458 , flagDescription =
459 "Deprecated, does nothing. :ref:`nullary (no parameter) type "++
460 "classes <nullary-type-classes>` are now enabled using "++
461 ":ghc-flag:`-XMultiParamTypeClasses`."
462 , flagType = DynamicFlag
463 , flagReverse = "-XNoNullaryTypeClasses"
464 , flagSince = "7.8.1"
465 }
466 , flag { flagName = "-XNumDecimals"
467 , flagDescription =
468 "Enable support for 'fractional' integer literals."
469 , flagType = DynamicFlag
470 , flagReverse = "-XNoNumDecimals"
471 , flagSince = "7.8.1"
472 }
473 , flag { flagName = "-XOverlappingInstances"
474 , flagDescription =
475 "Enable :ref:`overlapping instances <instance-overlap>`."
476 , flagType = DynamicFlag
477 , flagReverse = "-XNoOverlappingInstances"
478 , flagSince = "6.8.1"
479 }
480 , flag { flagName = "-XOverloadedLists"
481 , flagDescription =
482 "Enable :ref:`overloaded lists <overloaded-lists>`."
483 , flagType = DynamicFlag
484 , flagReverse = "-XNoOverloadedLists"
485 , flagSince = "7.8.1"
486 }
487 , flag { flagName = "-XOverloadedStrings"
488 , flagDescription =
489 "Enable :ref:`overloaded string literals <overloaded-strings>`."
490 , flagType = DynamicFlag
491 , flagReverse = "-XNoOverloadedStrings"
492 , flagSince = "6.8.1"
493 }
494 , flag { flagName = "-XPackageImports"
495 , flagDescription =
496 "Enable :ref:`package-qualified imports <package-imports>`."
497 , flagType = DynamicFlag
498 , flagReverse = "-XNoPackageImports"
499 , flagSince = "6.10.1"
500 }
501 , flag { flagName = "-XParallelArrays"
502 , flagDescription =
503 "Enable parallel arrays. Implies :ghc-flag:`-XParallelListComp`."
504 , flagType = DynamicFlag
505 , flagReverse = "-XNoParallelArrays"
506 , flagSince = "7.4.1"
507 }
508 , flag { flagName = "-XParallelListComp"
509 , flagDescription =
510 "Enable :ref:`parallel list comprehensions "++
511 "<parallel-list-comprehensions>`. "++
512 "Implied by :ghc-flag:`-XParallelArrays`."
513 , flagType = DynamicFlag
514 , flagReverse = "-XNoParallelListComp"
515 , flagSince = "6.8.1"
516 }
517 , flag { flagName = "-XPartialTypeSignatures"
518 , flagDescription =
519 "Enable :ref:`partial type signatures <partial-type-signatures>`."
520 , flagType = DynamicFlag
521 , flagReverse = "-XNoPartialTypeSignatures"
522 , flagSince = "7.10.1"
523 }
524 , flag { flagName = "-XNoPatternGuards"
525 , flagDescription = "Disable :ref:`pattern guards <pattern-guards>`. "++
526 "Implied by :ghc-flag:`-XHaskell98`."
527 , flagType = DynamicFlag
528 , flagReverse = "-XPatternGuards"
529 , flagSince = "6.8.1"
530 }
531 , flag { flagName = "-XPatternSynonyms"
532 , flagDescription =
533 "Enable :ref:`pattern synonyms <pattern-synonyms>`."
534 , flagType = DynamicFlag
535 , flagReverse = "-XNoPatternSynonyms"
536 , flagSince = "7.10.1"
537 }
538 , flag { flagName = "-XPolyKinds"
539 , flagDescription =
540 "Enable :ref:`kind polymorphism <kind-polymorphism>`. "++
541 "Implies :ghc-flag:`-XKindSignatures`."
542 , flagType = DynamicFlag
543 , flagReverse = "-XNoPolyKinds"
544 , flagSince = "7.4.1"
545 }
546 , flag { flagName = "-XPolymorphicComponents"
547 , flagDescription =
548 "Enable :ref:`polymorphic components for data constructors "++
549 "<universal-quantification>`. Synonym for :ghc-flag:`-XRankNTypes`."
550 , flagType = DynamicFlag
551 , flagReverse = "-XNoPolymorphicComponents"
552 , flagSince = "6.8.1"
553 }
554 , flag { flagName = "-XPostfixOperators"
555 , flagDescription =
556 "Enable :ref:`postfix operators <postfix-operators>`."
557 , flagType = DynamicFlag
558 , flagReverse = "-XNoPostfixOperators"
559 , flagSince = "7.10.1"
560 }
561 , flag { flagName = "-XQuasiQuotes"
562 , flagDescription = "Enable :ref:`quasiquotation <th-quasiquotation>`."
563 , flagType = DynamicFlag
564 , flagReverse = "-XNoQuasiQuotes"
565 , flagSince = "6.10.1"
566 }
567 , flag { flagName = "-XRank2Types"
568 , flagDescription =
569 "Enable :ref:`rank-2 types <universal-quantification>`. "++
570 "Synonym for :ghc-flag:`-XRankNTypes`."
571 , flagType = DynamicFlag
572 , flagReverse = "-XNoRank2Types"
573 , flagSince = "6.8.1"
574 }
575 , flag { flagName = "-XRankNTypes"
576 , flagDescription =
577 "Enable :ref:`rank-N types <universal-quantification>`. "++
578 "Implied by :ghc-flag:`-XImpredicativeTypes`."
579 , flagType = DynamicFlag
580 , flagReverse = "-XNoRankNTypes"
581 , flagSince = "6.8.1"
582 }
583 , flag { flagName = "-XRebindableSyntax"
584 , flagDescription =
585 "Employ :ref:`rebindable syntax <rebindable-syntax>`. "++
586 "Implies :ghc-flag:`-XNoImplicitPrelude`."
587 , flagType = DynamicFlag
588 , flagReverse = "-XNoRebindableSyntax"
589 , flagSince = "7.0.1"
590 }
591 , flag { flagName = "-XRecordWildCards"
592 , flagDescription =
593 "Enable :ref:`record wildcards <record-wildcards>`. "++
594 "Implies :ghc-flag:`-XDisambiguateRecordFields`."
595 , flagType = DynamicFlag
596 , flagReverse = "-XNoRecordWildCards"
597 , flagSince = "6.8.1"
598 }
599 , flag { flagName = "-XRecursiveDo"
600 , flagDescription =
601 "Enable :ref:`recursive do (mdo) notation <recursive-do-notation>`."
602 , flagType = DynamicFlag
603 , flagReverse = "-XNoRecursiveDo"
604 , flagSince = "6.8.1"
605 }
606 , flag { flagName = "-XRelaxedPolyRec"
607 , flagDescription =
608 "*(deprecated)* Relaxed checking for :ref:`mutually-recursive "++
609 "polymorphic functions <typing-binds>`."
610 , flagType = DynamicFlag
611 , flagReverse = "-XNoRelaxedPolyRec"
612 , flagSince = "6.8.1"
613 }
614 , flag { flagName = "-XRoleAnnotations"
615 , flagDescription =
616 "Enable :ref:`role annotations <role-annotations>`."
617 , flagType = DynamicFlag
618 , flagReverse = "-XNoRoleAnnotations"
619 , flagSince = "7.10.1"
620 }
621 , flag { flagName = "-XSafe"
622 , flagDescription =
623 "Enable the :ref:`Safe Haskell <safe-haskell>` Safe mode."
624 , flagType = DynamicFlag
625 , flagSince = "7.2.1"
626 }
627 , flag { flagName = "-XScopedTypeVariables"
628 , flagDescription =
629 "Enable :ref:`lexically-scoped type variables "++
630 "<scoped-type-variables>`."
631 , flagType = DynamicFlag
632 , flagReverse = "-XNoScopedTypeVariables"
633 , flagSince = "6.8.1"
634 }
635 , flag { flagName = "-XStandaloneDeriving"
636 , flagDescription =
637 "Enable :ref:`standalone deriving <stand-alone-deriving>`."
638 , flagType = DynamicFlag
639 , flagReverse = "-XNoStandaloneDeriving"
640 , flagSince = "6.8.1"
641 }
642 , flag { flagName = "-XStaticPointers"
643 , flagDescription =
644 "Enable :ref:`static pointers <static-pointers>`."
645 , flagType = DynamicFlag
646 , flagReverse = "-XNoStaticPointers"
647 , flagSince = "7.10.1"
648 }
649 , flag { flagName = "-XStrictData"
650 , flagDescription =
651 "Enable :ref:`default strict datatype fields <strict-data>`."
652 , flagType = DynamicFlag
653 , flagReverse = "-XNoStrictData"
654 }
655 , flag { flagName = "-XTemplateHaskell"
656 , flagDescription =
657 "Enable :ref:`Template Haskell <template-haskell>`."
658 , flagType = DynamicFlag
659 , flagReverse = "-XNoTemplateHaskell"
660 , flagSince = "6.8.1"
661 }
662 , flag { flagName = "-XTemplateHaskellQuotes"
663 , flagDescription = "Enable quotation subset of "++
664 ":ref:`Template Haskell <template-haskell>`."
665 , flagType = DynamicFlag
666 , flagReverse = "-XNoTemplateHaskellQuotes"
667 , flagSince = "8.0.1"
668 }
669 , flag { flagName = "-XNoTraditionalRecordSyntax"
670 , flagDescription =
671 "Disable support for traditional record syntax "++
672 "(as supported by Haskell 98) ``C {f = x}``"
673 , flagType = DynamicFlag
674 , flagReverse = "-XTraditionalRecordSyntax"
675 , flagSince = "7.4.1"
676 }
677 , flag { flagName = "-XTransformListComp"
678 , flagDescription =
679 "Enable :ref:`generalised list comprehensions "++
680 "<generalised-list-comprehensions>`."
681 , flagType = DynamicFlag
682 , flagReverse = "-XNoTransformListComp"
683 , flagSince = "6.10.1"
684 }
685 , flag { flagName = "-XTrustworthy"
686 , flagDescription =
687 "Enable the :ref:`Safe Haskell <safe-haskell>` Trustworthy mode."
688 , flagType = DynamicFlag
689 , flagSince = "7.2.1"
690 }
691 , flag { flagName = "-XTupleSections"
692 , flagDescription = "Enable :ref:`tuple sections <tuple-sections>`."
693 , flagType = DynamicFlag
694 , flagReverse = "-XNoTupleSections"
695 , flagSince = "7.10.1"
696 }
697 , flag { flagName = "-XTypeFamilies"
698 , flagDescription =
699 "Enable :ref:`type families <type-families>`. "++
700 "Implies :ghc-flag:`-XExplicitNamespaces`, :ghc-flag:`-XKindSignatures`, "++
701 "and :ghc-flag:`-XMonoLocalBinds`."
702 , flagType = DynamicFlag
703 , flagReverse = "-XNoTypeFamilies"
704 , flagSince = "6.8.1"
705 }
706 , flag { flagName = "-XTypeOperators"
707 , flagDescription =
708 "Enable :ref:`type operators <type-operators>`. "++
709 "Implies :ghc-flag:`-XExplicitNamespaces`."
710 , flagType = DynamicFlag
711 , flagReverse = "-XNoTypeOperators"
712 , flagSince = "6.8.1"
713 }
714 , flag { flagName = "-XTypeSynonymInstances"
715 , flagDescription =
716 "Enable :ref:`type synonyms in instance heads "++
717 "<flexible-instance-head>`. Implied by :ghc-flag:`-XFlexibleInstances`."
718 , flagType = DynamicFlag
719 , flagReverse = "-XNoTypeSynonymInstances"
720 , flagSince = "6.8.1"
721 }
722 , flag { flagName = "-XUnboxedTuples"
723 , flagDescription = "Enable :ref:`unboxed tuples <unboxed-tuples>`."
724 , flagType = DynamicFlag
725 , flagReverse = "-XNoUnboxedTuples"
726 , flagSince = "6.8.1"
727 }
728 , flag { flagName ="-XUnboxedSums"
729 , flagDescription = "Enable :ref: `unboxed sums <unboxed-sums>`."
730 , flagType = DynamicFlag
731 , flagReverse = "-XNoUnboxedSums"
732 , flagSince = "8.2.1"
733 }
734 , flag { flagName = "-XUndecidableInstances"
735 , flagDescription =
736 "Enable :ref:`undecidable instances <undecidable-instances>`."
737 , flagType = DynamicFlag
738 , flagReverse = "-XNoUndecidableInstances"
739 , flagSince = "6.8.1"
740 }
741 , flag { flagName = "-XUnicodeSyntax"
742 , flagDescription = "Enable :ref:`unicode syntax <unicode-syntax>`."
743 , flagType = DynamicFlag
744 , flagReverse = "-XNoUnicodeSyntax"
745 , flagSince = "6.8.1"
746 }
747 , flag { flagName = "-XUnliftedFFITypes"
748 , flagDescription = "Enable unlifted FFI types."
749 , flagType = DynamicFlag
750 , flagReverse = "-XNoUnliftedFFITypes"
751 , flagSince = "6.8.1"
752 }
753 , flag { flagName = "-XUnsafe"
754 , flagDescription =
755 "Enable :ref:`Safe Haskell <safe-haskell>` Unsafe mode."
756 , flagType = DynamicFlag
757 , flagSince = "7.4.1"
758 }
759 , flag { flagName = "-XViewPatterns"
760 , flagDescription = "Enable :ref:`view patterns <view-patterns>`."
761 , flagType = DynamicFlag
762 , flagReverse = "-XNoViewPatterns"
763 , flagSince = "6.10.1"
764 }
765 ]