Fix test output after 'Some tidying up of type pretty-printing'
[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 = "-XDeriveLift"
173 , flagDescription =
174 "Enable :ref:`deriving for the Lift class <deriving-lift>`"
175 , flagType = DynamicFlag
176 , flagReverse = "-XNoDeriveLift"
177 , flagSince = "7.2.1"
178 }
179 , flag { flagName = "-XDeriveTraversable"
180 , flagDescription =
181 "Enable :ref:`deriving for the Traversable class <deriving-extra>`. "++
182 "Implies :ghc-flag:`-XDeriveFunctor` and :ghc-flag:`-XDeriveFoldable`."
183 , flagType = DynamicFlag
184 , flagReverse = "-XNoDeriveTraversable"
185 , flagSince = "7.10.1"
186 }
187 , flag { flagName = "-XDerivingStrategies"
188 , flagDescription =
189 "Enables :ref:`deriving strategies <deriving-strategies>`."
190 , flagType = DynamicFlag
191 , flagReverse = "-XNoDerivingStrategies"
192 , flagSince = "8.2.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 = "-XOverloadedLabels"
481 , flagDescription =
482 "Enable :ref:`overloaded labels <overloaded-labels>`."
483 , flagType = DynamicFlag
484 , flagReverse = "-XNoOverloadedLabels"
485 , flagSince = "8.0.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 ]