ghc - En ligne dans le Cloud

PROGRAMME:

Nom

GHC - le compilateur Glasgow Haskell

SYNOPSIS

ghc [option|nom de fichier] ...
ghci [option|nom de fichier] ...

DESCRIPTION

Cette page de manuel documente brièvement les ghc ainsi que ghci commandes. Noter que ghci n'est pas encore
disponible sur toutes les architectures. Une documentation complète est disponible dans divers autres
formats dont DVI, PostScript et HTML ; voir ci-dessous.

Chacune des options de ligne de commande de GHC est classée comme statique or Dynamic. Un statique
flag ne peut être spécifié que sur la ligne de commande, alors qu'un flag dynamique peut également être donné
dans un pragma OPTIONS dans un fichier source ou défini à partir de la ligne de commande GHCi avec :set.

En règle générale, toutes les options de langue sont dynamiques, de même que les options d'avertissement et
les options de débogage.

Le reste est statique, à l'exception notable de -v, -cpp, -fasme, -fvia-C, -fllvmet
" -#include . Les sections OPTIONS répertorient l'état de chaque indicateur.

Les suffixes courants des noms de fichiers pour Haskell sont :

.hs code source Haskell ; prétraiter, compiler

.lhs alphabétisé source Haskell; éteint, prétraiter, compiler

.salut Fichier d'interface ; contient des informations sur les symboles exportés

.hc fichiers C intermédiaires

.x_o manière x fichiers objets ; les moyens courants sont : p, u, s

.x_salut manière x fichiers d'interface

OPTIONS

Verbosité Options
-v -vn -fprint-explicit-foralls -fprint-explicit-kinds -ferror-spans -Htaille
-Rghc-timing

Alternative modes of opération
--aider,-? --interactive --make -e expr --show-iface -M --supported-extensions,
--supported-languages ​​--show-options --info --version, -V --numeric-version
--print-libdir

Laquelle phases à courir
-E -C -S -c -x suffixe

Redirection sortie
-hcsuf suffixe -hidir dir -hisuf suffixe -o nom de fichier -odir dir -oh nom de fichier -osuf
suffixe -répertoire stub dir -dumprép dir -rép_sortie dir

En gardant intermédiaire fichiers
-keep-hc-file ou
-keep-hc-files -keep-llvm-file ou
-keep-llvm-files -keep-s-file ou
-keep-s-files -keep-tmp-files

Temporaire fichiers
-tmprép

Trouver importations
-iDir1:Dir2:... -je

Interfaces filet Options
-ddump-salut -ddump-salut-diffs -ddump-minimal-imports --show-iface filet

Recompilation vérification
-fforce-recomp -fno-force-recomp

Mode interactif Options
-ignore-dot-ghci -ghci-script -fbreak-on-error -fno-break-on-error -fbreak-on-exception
-fno-break-on-exception -fghci-hist-size=n (la valeur par défaut est 50) -fprint-evld-with-show
-fno-print-evld-avec-show -fprint-bind-result -fno-print-bind-result
-fno-print-bind-content -fno-implicit-import-qualified -interactive-print

Formules
-cette-clé-paquet P -paquet P -masquer-tous-les-paquets -masquer-le-paquet prénom -ignorer-paquet
prénom -paquet-db filet -clear-package-db -no-global-package-db -global-package-db
-no-user-package-db -user-package-db -no-auto-link-packages -trust P -méfiance P
-méfiance-tout

Langue Options
-fcontext-pile=n -fglasgow-exts -fno-glasgow-exts -firrefutable-tuples
-fno-irréfutable-tuples -fpackage-trust -ftype-function-depth=n -XAutoriser les types ambigus
-XNoAllowAmbiguousTypes -XArrows -XNoArrows -XAutoDeriveTypeable -XNoAutoDeriveTypeable
-XBangPatterns -XNoBangPatterns -XBinaryLiterals -XNoBinaryLiterals -XCApiFFI
-XNoCAPIFFI -XConstrainedClassMethods -XNoConstrainedClassMethods -XConstraintKinds
-XNoConstraintKinds -XCPP -XNoCPP -XDataKinds -XNoDataKinds -XDefaultSignatures
-XNoDefaultSignatures -XDeriveAnyClass -XNoDeriveAnyClass -XDeriveDataTypeable
-XNoDeriveDataTypeable -XDeriveFunctor -XNoDeriveFunctor -XDeriveFoldable
-XNoDeriveFoldable -XDeriveGeneric -XNoDeriveGeneric -XDeriveTraversable
-XNoDeriveTraversable -XDisambiguateRecordFields -XNoDisambiguateRecordFields
-XEmptyCase -XNoEmptyCase -XNoEmptyDataDecls -XNoEmptyDataDecls
-XExistentialQuantification -XNoExistentialQuantification -XExplicitForAll
-XNoExplicitForAll -XExplicitNamespaces -XNoExplicitNamespaces -XExtendedDefaultRules
-XNoExtendedDefaultRules -XFlexibleContexts -XNoFlexibleContexts -XFlexibleInstances
-XNoFlexibleInstances -XForeignFunctionInterface -XNoForeignFunctionInterface
-XFunctionalDependencies -XNoFunctionalDependencies -XGADTs -XNoGADTs -XGADTSyntaxe
-XNoGADTSyntax -XGeneralizedNewtypeDeriving -XNoGeneralizedNewtypeDeriving -XGenerics
-XNoGenerics -XImplicitParams -XNoImplicitParams -XNoImplicitPrelude -XImplicitPrelude
-XImpredicativeTypes -XNoImpredicativeTypes -XIncoherentInstances -XNoIncoherentInstances
-XInstanceSigs -XNoInstanceSigs -XInterruptibleFFI -XNoInterruptibleFFI -XKindSignatures
-XNoKindSignatures -XLambdaCase -XNoLambdaCase -XLiberalTypeSynonyms
-XNoLiberalTypeSynonyms -XMagicHash -XNoMagicHash -XMonadComprehensions
-XNoMonadComprehensions -XMonoLocalBinds -XNoMonoLocalBinds -XNoMonomorphismRestriction
-XMonomorphismRestriction -XMultiParamTypeClasses -XNoMultiParamTypeClasses -XMultiWayIf
-XNoMultiWayIf -XNamedFieldPuns -XNoNamedFieldPuns -XNamedWildCards -XNoNamedWildCards
-XNegativeLiterals -XNoNegativeLiterals -XNoNPlusKPatterns -XNPlusKPatterns
-XNullaryTypeClasses -XNoNullaryTypeClasses -XNumDecimals -XNoNumDecimals
-XOverlappingInstances -XNoOverlappingInstances -XOverlappingLists -XNoOverloadedLists
-XOverloadedStrings -XNoOverloadedStrings -XPackageImports -XNoPackageImports
-XParallelArrays -XNoParallelArrays -XParallelListComp -XNoParallelListComp
-XPartialTypeSignatures -XNoPartialTypeSignatures -XPatternGuards -XNoPatternGuards
-XPatternSynonyms -XNoPatternSynonyms -XPolyKinds -XNoPolyKinds -XPolymorphicComponents
-XNoPolymorphicComponents -XPostfixOperators -XNoPostfixOperators -XQuasiQuotes
-XNoQuasiQuotes -XRank2Types -XNoRank2Types -XRankNTypes -XNoRankNTypes
-XRebindableSyntax -XNoRebindableSyntax -XRecordWildCards -XNoRecordWildCards
-XRecursiveDo -XNoRecursiveDo -XRelaxedPolyRec -XNoRelaxedPolyRec -XRoleAnnotations
-XNoRoleAnnotations -XSafe -XScopedTypeVariables -XNoScopedTypeVariables
-XStandaloneDeriving -XNoStandaloneDeriving -XTemplateHaskell -XNoTemplateHaskell
-XNoTraditionalRecordSyntax -XTraditionalRecordSyntax -XTransformListComp
-XNoTransformListComp -XTTrustworthy -XTupleSections -XNoTupleSections -XTypeFamilies
-XNoTypeFamilies -XTypeOperators -XNoTypeOperators -XTypeSynonymInstances
-XNoTypeSynonymInstances -XUnboxedTuples -XNoUnboxedTuples -XUndecidableInstances
-XNoUndecidableInstances -XUnicodeSyntax -XNoUnicodeSyntax -XUnliftedFFITypes
-XNoUnliftedFFITypes -XUnsafe -XViewPatterns -XNoViewPatterns

Avertissements
-W -w -w -Mur -w -Werror -Wwarn -fdefer-type-errors -fno-defer-type-errors
-fdefer-trous-typés -fno-defer-trous-typés -fhelpful-errors -fno-helpful-errors
-fwarn-drapeaux-obsolètes -fno-warn-drapeaux-obsolètes -fwarn-contraintes-en double
-fno-warn-dupliquer-les-contraintes -fwarn-dupliquer-les exportations -fno-warn-dupliquer-les-exportations
-fwarn-hi-shadowing -fno-warn-hi-shadowing -fwarn-identités -fno-warn-identités
-fwarn-implicit-prelude -fno-warn-implicit-prelude -fwarn-incomplete-patterns
-fno-warn-modèles-incomplets -fwarn-modèles-uni-incomplets
-fno-warn-incomplete-uni-patterns -fwarn-incomplete-record-updates
-fno-warn-incomplete-record-updates -fwarn-lazy-unlifted-bindings
-fno-warn-liaisons-paresseuses-non levées -fwarn-champs-manquants -fno-warn-champs-manquants
-fwarn-missing-import-lists -fnowarn-missing-import-lists -fwarn-missing-methods
-fno-warn-manquant-méthodes -fwarn-signatures-manquantes -fno-warn-manquant-signatures
-fwarn-missing-exported-sigs -fno-warn-missing-exported-sigs -fwarn-missing-local-sigs
-fno-warn-missing-local-sigs -fwarn-monomorphisme-restriction
-fno-warn-monomorphisme-restriction -fwarn-name-shadowing -fno-warn-name-shadowing
-fwarn-orphelins, -fwarn-auto-orphelins -fno-warn-orphelins, -fno-warn-auto-orphelins
-fwarn-patterns-chevauchants -fno-warn-patterns-chevauchants -fwarn-tabs -fno-warn-tabs
-fwarn-type-defaults -fno-warn-type-defaults -fwarn-pragmas-non reconnus
-fno-warn-pragmas-non reconnus -fwarn-uncoked-promoted-constructors
-fno-warn-constructeurs-promotés non cochés -fwarn-unused-binds -fno-warn-unused-binds
-fwarn-importations-inutilisées -fno-avertissement-importations-inutilisées -fwarn-correspondances-inutilisées
-fno-warn-unused-matches -fwarn-unused-do-bind -fno-warn-unused-do-bind
-fwarn-wrong-do-bind -fno-warn-wrong-do-bind -fwarn-unsafe -fno-warn-unsafe -fwarn-safe
-fno-warn-safe -fwarn-trustworthy-safe -fno-warn-safe -fwarn-warnings-dépréciations
-fno-warn-avertissements-dépréciations -fwarn-amp -fno-warn-amp -fwarn-typed-holes
-fno-warn-trous-typés -fwarn-partial-type-signatures -fno-warn-partial-type-signatures
-fwarn-deriving-typable -fno-warn-deriving-typable

Optimisation niveaux
-O0 -O -O ou -O1 -O0 -O2 -O0 -Odph

Individuelle optimisations
-fcall-arity -fno-call-arity -fcase-merge -fno-case-merge -fcmm-elim-common-blocks
-fno-cmm-elim-common-blocks -fcmm-sink -fno-cmm-sink -fcpr-off -fcse -fno-cse
-fdicts-pas cher -fno-dicts-pas cher -fdicts-strict -fno-dicts-strict -fdmd-tx-dict-sel
-fno-dmd-tx-dict-sel -fdo-eta-réduction -fno-do-eta-réduction
-fdo-lambda-eta-expansion -fno-do-lambda-eta-expansion -feager-blackholing
-fenable-rewrite-rules -fno-enable-rewrite-rules -fexcess-precision -fno-excess-precision
-fexposer-tous-les-dépliages -fno-exposer-tous-les-dépliages -ffloat-in -fno-float-in
-ffull-paresse -fno-full-paresse -ffun-to-thunk -fno-fun-to-thunk -fignore-asserts
-fno-ignore-asserts -figore-interface-pragmas -fno-ignore-interface-pragmas
-flate-dmd-anal -fno-late-dmd-anal -fliberate-case -fliberate-case-threshold=n
-fno-libérer-cas-seuil -floopification -fno-loopification
-fmax-inline-alloc-size=n
-fmax-inline-memcpy-insns=n

-fmax-inline-memset-insns=n
-fmax-relevant-binds=n -fno-max-relevant-binds
-fmax-simplifier-iterations=n -fmax-worker-args=n -fno-opt-coercion -fno-pre-inlining
-fno-state-hack -fomit-interface-pragmas -fno-omit-interface-pragmas -fomit-yields
-fno-omit-rendements -fpedantic-bottoms -fno-pedantic-bottoms -fregs-graph -fno-regs-graph
-fregs-iterative -fno-regs-iterative -fsimplifier-phases=n -fsimpl-tick-factor=n
-fspec-constr -fno-spec-constr -fspec-constr-count=n -fno-spec-constr-count
-fspec-constr-seuil=n -fno-spec-constr-threshold -fspecialise -fno-specialise
-fstatic-argument-transformation -fno-static-argument-transformation -fstrictness
-fno-strictité -fstrictness-avant=n -funbox-petits-champs-stricts
-fno-unbox-small-strict-fields -funbox-strict-fields -fno-unbox-strict-fields
-funfolding-création-seuil=n -funfolding-dict-discount=n -funfolding-fun-discount=n
-funfolding-keeness-factor=n -funfolding-use-threshold=n -fvectorisation-évitement
-fno-vectorisation-évitement -fvectorise -fno-vectorise

Profilage Options
-prof -fprof-auto -fno-prof-auto -fprof-auto-top -fno-prof-auto -fprof-auto-exporté
-fno-prof-auto -fprof-cafs -fno-prof-cafs -fno-prof-count-entries -fprof-count-entries
-ticky

Programme couverture Options
-fhpc -hpcdir rép

Haskell pré-processeur Options
-F

C pré-processeur Options
-cpp -Dsymbole=Plus-value -U -Usymbole -Idir

Code génération Options
-fasm -fllvm -fno-code -fwrite-interface -fbyte-code -fobject-code

Enchaînement Options
-shared -staticlib -fPIC -dynamic -dynamic-too -dyno -dynosuf -dynload -framework
prénom -chemin-cadre prénom -llib -Ldir -main-is --mk-dll -no-hs-main -rtsopts,
-rtsopts={aucun,certains,tous} -with-rtsopts=opts -no-link -split-objs -static -threaded
-debug -ticky -eventlog -fno-gen-manifest -fno-embed-manifest -fno-shared-implib
-nom-d'installation-dylib chemin -rdynamique

Brancher Options
-fplugin=module -fplugin-opt=module:arguments

Remplacement phases
-pgmL cmd -pgmP cmd -pgmc cmd -pgmlo cmd -pgmlc cmd -pgms cmd -pgma cmd -pgml cmd
-pgmdll cmd -pgmF cmd -pgmwindres cmd -pgmlibtool cmd -pgmreadelf cmd

Forcer Options à particulier phases
-optL option -optP option -optF option -optc option -optlo option -optlc option
-opta option -optl option -optdll option -optwindres option

Spécifique à la plate-forme Options
-msse2

Compilateur débogage Options
-dcore-lint -ddump-vers-fichier -ddump-asm -ddump-bcos -ddump-cmm -ddump-core-stats
-ddump-cse -ddump-deriv -ddump-ds -ddump-foreign -ddump-hpc -ddump-inlinings
-ddump-llvm -ddump-occur-anal -ddump-opt-cmm -ddump-parsed -ddump-prep -ddump-rn
-ddump-rule-firings -ddump-rule-rewrites -ddump-rules -ddump-vect -ddump-simpl
-ddump-simpl-itérations -ddump-spec -ddump-splices -ddump-stg -ddump-stranal
-ddump-strsigs -ddump-tc -dth-dec-file -ddump-types -ddump-worker-wrapper
-ddump-si-trace -ddump-tc-trace -ddump-vt-trace -ddump-rn-trace -ddump-rn-stats
-ddump-simpl-stats -dno-debug-output -dppr-debug -dppr-user-length -dppr-colsNNN
-dppr-case-as-let -dsuppress-all -dsuppress-uniques -dsuppress-idinfo
-dsuppress-module-prefixes -dsuppress-type-signatures -dsuppress-type-applications
-dsuppress-coercions -dsource-stats -dcmm-lint -dstg-lint -dstg-stats
-dverbose-core2core -dverbose-stg2stg -dshow-passes -dfaststring-stats -frule-check

Divers compilateur Options
-jN -fno-hi-version-check -fhistory-size -fno-ghci-history -fno-ghci-sandbox

VERBOSITÉ OPTIONS

-v mode verbeux (équivalent à -v3)
[dynamique]

-vn définir le niveau de verbosité
[dynamique]

-fprint-explicit-foralls
imprimer la quantification explicite pour tous les types
[dynamique]

-fprint-types-explicites
imprimer des foralls de genre explicites et des arguments de genre dans les types
[dynamique]

-ferror-travées
sortie pleine étendue dans les messages d'erreur
[dynamique]

-Htaille Définissez la taille minimale du tas sur taille
[dynamique]

-Rghc-timing
Résumer les statistiques de synchronisation pour GHC (identique à +RTS -tstderr)
[dynamique]

ALTERNATIVE MODES OF FONCTIONNEMENT

--Aidez-moi,-?
Afficher l'aide
[mode]

--interactif
Mode interactif - normalement utilisé en exécutant simplement ghci ; voir pour plus de détails.
[mode]

--Fabriquer Construisez un programme Haskell multi-modules, identifiant automatiquement les dépendances.
Probablement plus facile et plus rapide que d'utiliser make ; voir pour les détails..
[mode]

-e expr
Évaluer expr; voir pour plus de détails.
[mode]

--montrer-iface
Affiche le contenu d'un fichier d'interface.
[mode]

-M Générer des informations de dépendance adaptées à une utilisation dans un Makefile ; voir pour plus de détails.
[mode]

--extensions-supportées, --langues-prises en charge
afficher les extensions de langue prises en charge
[mode]

--show-options
afficher les options de ligne de commande prises en charge
[mode]

--Info afficher des informations sur le compilateur
[mode]

--version, -V
afficher la version GHC
[mode]

--version-numérique
afficher la version GHC (numérique uniquement)
[mode]

--print-libdir
afficher le répertoire de la bibliothèque GHC
[mode]

LEQUEL ÉTAPES À COURT

-E Arrêt après prétraitement (fichier .hspp)
[mode]

-C Arrêter après avoir généré C (fichier .hc)
[mode]

-S Arrêter après avoir généré l'assembly (fichier .s)
[mode]

-c Arrêter après avoir généré le fichier objet (.o)
[mode]

-x suffixe
Remplacer le comportement par défaut des fichiers source
[dynamique]

REDIRECTION SORTIE

-hcsuf suffixe
définir le suffixe à utiliser pour les fichiers C intermédiaires
[dynamique]

-hidir dir
définir le répertoire pour les fichiers d'interface
[dynamique]

-hisuf suffixe
définir le suffixe à utiliser pour les fichiers d'interface
[dynamique]

-o nom de fichier
définir le nom du fichier de sortie
[dynamique]

-odir dir
définir le répertoire pour les fichiers objets
[dynamique]

-oh nom de fichier
définir le nom de fichier dans lequel mettre l'interface
[dynamique]

-osuf suffixe
définir le suffixe du fichier de sortie
[dynamique]

-répertoire stub dir
rediriger les fichiers de raccord FFI
[dynamique]

-dumprép dir
rediriger les fichiers de vidage
[dynamique]

-rép_sortie dir
définir le répertoire de sortie
[dynamique]

EN GARDANT INTERMÉDIAIRE DES DOSSIERS

-garder-fichier-hc or
-conserver-les-fichiers-hc conserver les fichiers .hc intermédiaires
[dynamique]

-garder-fichier-llvm or
-conserver-les-fichiers-llvm conserver les fichiers LLVM .ll intermédiaires
[dynamique]

-conserver-s-fichier or
-conserver-les-fichiers conserver les fichiers .s intermédiaires
[dynamique]

-garder-les-fichiers-tmp
conserver tous les fichiers temporaires intermédiaires
[dynamique]

TEMPORAIRE DES DOSSIERS

-tmprép
définir le répertoire des fichiers temporaires
[dynamique]

DÉCOUVERTE IMPORTATIONS

-iDir1:Dir2: ...
ajouter dir, Dir2, etc. pour importer le chemin
[dynamique/:définir]

-i Vider la liste des répertoires d'importation
[dynamique/:définir]

INTERFACE DOSSIER OPTIONS

-ddump-salut
Vider la nouvelle interface sur stdout
[dynamique]

-ddump-salut-diffs
Montrer les différences par rapport à l'ancienne interface
[dynamique]

-ddump-importations-minimales
Vider un ensemble minimal d'importations
[dynamique]

--montrer-iface filet
Voir .
[]

RECOMPILATION VÉRIFICATION

-fforce-recomp
Désactivez la vérification de la recompilation. Ceci est impliqué par tout -ddump-X option quand
compiler un seul fichier (c'est-à-dire en utilisant -c).
[dynamique]

MODE INTERACTIF OPTIONS

-ignore-point-ghci
Désactiver la lecture des fichiers .ghci
[dynamique]

-ghci-script
Lire des fichiers .ghci supplémentaires
[dynamique]

-fbreak-on-error
Pause sur les exceptions et erreurs non détectées
[dynamique]

-fbreak-sur-exception
Pause sur toute exception levée
[dynamique]

-fghci-taille-hist=n
Définir le nombre d'entrées que GHCi conserve pour :history
[dynamique]

-fprint-evld-avec-show
Activer l'utilisation de Afficher les instances dans :print
[dynamique]

-fprint-bind-résultat
Activer l'impression des résultats de reliure dans GHCi
[dynamique]

-fno-print-bind-content
Désactiver l'impression du contenu de la reliure dans GHCi
[dynamique]

-fno-implicite-import-qualifié
Désactiver l'importation qualifiée implicite de tout dans GHCi
[dynamique]

-impression-interactive
Sélectionnez la fonction à utiliser pour imprimer les expressions évaluées dans GHCi
[dynamique]

FORFAITS

-cette-clé-paquet P
Compiler pour faire partie du package P
[dynamique]

-paquet P
Exposer le paquet P
[dynamique/:définir]

-masquer-tous-les-paquets
Masquer tous les packages par défaut
[dynamique]

-masquer-paquet prénom
Masquer le paquet P
[dynamique/:définir]

-ignorer-paquet prénom
Ignorer le paquet P
[dynamique/:définir]

-paquet-db filet
Ajouter filet à la pile de base de données du package.
[dynamique]

-clear-paquet-db
Effacez la pile de base de données du package.
[dynamique]

-pas de paquet global-base de données
Supprimez la base de données globale du package de la pile.
[dynamique]

-global-paquet-db
Ajoutez la base de données globale du package à la pile.
[dynamique]

-no-user-package-db
Supprimez la base de données du package de l'utilisateur de la pile.
[dynamique]

-user-package-db
Ajoutez la base de données du package de l'utilisateur à la pile.
[dynamique]

-paquets sans lien automatique
Ne pas lier automatiquement dans les packages base et rts.
[dynamique]

-confiance P
Exposer le paquet P et le configurer pour qu'il soit digne de confiance
[dynamique/:définir]

-méfiance P
Exposer le paquet P et le mettre pour qu'on s'en méfie
[dynamique/:définir]

-méfiance-tout
Méfiez-vous de tous les packages par défaut
[dynamique/:définir]

LANGUAGE OPTIONS

-fcontext-pile=n
définir la limite pour la réduction de contexte de classe de type. La valeur par défaut est 100.
[dynamique]

-fglasgow-exts
Obsolète. Activer la plupart des extensions de langue ; voir pour lesquels exactement.
[dynamique]

-tuples-réfutables
Rendre la correspondance des motifs de tuple irréfutable
[dynamique]

-fpackage-confiance
Activez l'exigence de package de confiance Safe Haskell pour les modules dignes de confiance.
[dynamique]

-ftype-fonction-profondeur=n
définir la limite pour les réductions de fonction de type. La valeur par défaut est 200.
[dynamique]

-XAutoriser les types ambigus
Permettre à l'utilisateur d'écrire des types ambigus et au moteur d'inférence de type d'inférer
Eux.
[dynamique]

-Xflèches
Activer l'extension de notation de flèche
[dynamique]

-XAutoDeriveTypeable
Depuis GHC 7.10, cette option n'est pas nécessaire et ne doit pas être utilisée. Automatiquement
dériver des instances typables pour chaque type de données et déclaration de classe de type. Implique
-XDeriveDataTypeable.
[dynamique]

-XBangPatterns
Activez les motifs de détonation.
[dynamique]

-XBinaryLittéraux
Activer la prise en charge des littéraux binaires.
[dynamique]

-XCApiFFI
Activez la convention d'appel CAPI.
[dynamique]

-XConstrainedClassMethods
Activez les méthodes de classe contrainte.
[dynamique]

-XConstraintKinds
Activer une sorte de contraintes.
[dynamique]

-XCPP Activez le préprocesseur C.
[dynamique]

-XDataKinds
Activer la promotion du type de données.
[dynamique]

-XDefaultSignatures
Activez les signatures par défaut.
[dynamique]

-XDeriveAnyClass
Activer la dérivation pour n'importe quelle classe.
[dynamique]

-XDeriveDataTypeable
Activez la dérivation pour la classe Data. Impliqué par -XAutoDeriveTypeable.
[dynamique]

-XDeriveFunctor
Activer la dérivation pour la classe Functor. Impliqué par -XDeriveTraversable.
[dynamique]

-XDerivePliable
Activez la dérivation pour la classe Foldable. Impliqué par -XDeriveTraversable.
[dynamique]

-XDeriveGénérique
Activez la dérivation pour la classe générique.
[dynamique]

-XDeriveTraversable
Activer la dérivation pour la classe Traversable. Implique -XDeriveFunctor ainsi que
-XDerivePliable.
[dynamique]

-XDisambiguateRecordFields
Activer la désambiguïsation du champ d'enregistrement. Impliqué par -XRecordWildCards.
[dynamique]

-XVideCase
Autoriser les alternatives de cas vides.
[dynamique]

-XEmptyDataDecls
Activez les déclarations de données vides.
[dynamique]

-XQuantificationExistentielle
Activer la quantification existentielle.
[dynamique]

-XExplicitPourTous
Activez la quantification universelle explicite. Impliqué par -XScopedTypeVariables,
-XLiberalTypeSynonymes, -XRankNCTypes ainsi que -XQuantificationExistentielle.
[dynamique]

-XEspaces de noms explicites
Activez l'utilisation du type de mot-clé pour spécifier l'espace de noms des entrées dans les importations et
exportations (). Impliqué par -XTypeOpérateurs ainsi que -XTypeFamilles.
[dynamique]

-XExtendedDefaultRules
Utilisez les règles par défaut étendues de GHCi dans un module normal.
[dynamique]

-XContextesFlexibles
Activez les contextes flexibles. Impliqué par -XImplicitParams.
[dynamique]

-XInstances flexibles
Activez les instances flexibles. Implique -XTypeSynonymInstances. Impliqué par
-XImplicitParams.
[dynamique]

-XForeignFunctionInterface
Activer l'interface de fonction étrangère.
[dynamique]

-XDépendances Fonctionnelles
Activer les dépendances fonctionnelles. Implique -XClassesTypeMultiParam.
[dynamique]

-XGADT
Activez les types de données algébriques généralisés. Implique -XGADTSyntaxe ainsi que -XMonoLocalBinds.
[dynamique]

-XGADTSyntaxe
Activez la syntaxe de type de données algébrique généralisée.
[dynamique]

-XGeneralizedNewtypeDérivant
Activer la dérivation de nouveau type.
[dynamique]

-XGénériques
Obsolète, ne fait rien. N'active plus les classes génériques. Voir aussi le soutien de GHC
pour la programmation générique.
[dynamique]

-XImplicitParams
Activer les paramètres implicites. Implique -XContextesFlexibles ainsi que -XInstances flexibles.
[dynamique]

-XNoImplicitPrélude
N'importez pas implicitement Prelude. Impliqué par -XRebindableSyntaxe.
[dynamique]

-XTypesImprédicatifs
Activer les types imprédicatifs. Implique -XRankNCTypes.
[dynamique]

-XInstancesIncohérentes
Activer les instances incohérentes. Implique -XOverlappingInstances.
[dynamique]

-XInstanceSigs
Activez les signatures d'instance.
[dynamique]

-XInterruptibleFFI
Activer le FFI interruptible.
[dynamique]

-XKindSignatures
Activer les signatures aimables. Impliqué par -XTypeFamilles ainsi que -XPolyKinds.
[dynamique]

-XLambdaCase
Activez les expressions en cas lambda.
[dynamique]

-XLiberalTypeSynonymes
Activer les synonymes de type libéralisé.
[dynamique]

-XMagiqueHash
Autorisez "#" comme modificateur de suffixe sur les identifiants.
[dynamique]

-XMonadCompréhensions
Activer les compréhensions de monades.
[dynamique]

-XMonoLocalBinds
Activer ne pas généraliser les liaisons locales. Impliqué par -XTypeFamilles ainsi que -XGADT.
[dynamique]

-XNoMonomorphismRestriction
Désactivez la restriction de monomorphisme.
[dynamique]

-XClassesTypeMultiParam
Activer les classes de type multi-paramètres. Impliqué par -XDépendances Fonctionnelles.
[dynamique]

-XMultiWaySi
Activez les expressions if multidirectionnelles.
[dynamique]

-XNamedFieldPuns
Activer les jeux de mots d'enregistrement.
[dynamique]

-XNamedWildCards
Activez les caractères génériques nommés.
[dynamique]

-XNegativeLiterals
Activer la prise en charge des littéraux négatifs.
[dynamique]

-XNoNPlusKPatterns
Désactivez la prise en charge des modèles n+k.
[dynamique]

-XNularyTypeClasses
Obsolète, ne fait rien. les classes de type nullaire (sans paramètre) sont maintenant activées à l'aide
-XClassesTypeMultiParam.
[dynamique]

-XNumDécimales
Activer la prise en charge des littéraux entiers « fractionnaires ».
[dynamique]

-XOverlappingInstances
Activez les instances qui se chevauchent.
[dynamique]

-XListes surchargées
Activez les listes surchargées.
[dynamique]

-XChaînes surchargées
Activez les littéraux de chaîne surchargés.
[dynamique]

-XPackageImports
Activez les importations qualifiées de package.
[dynamique]

-XParallelArrays
Activez les baies parallèles. Implique -XParallelListComp.
[dynamique]

-XParallelListComp
Activer les compréhensions de liste parallèle. Impliqué par -XParallelArrays.
[dynamique]

-XPartialTypeSignatures
Activez les signatures de type partiel.
[dynamique]

-XPatternGuards
Activez les protections de motif.
[dynamique]

-XPatternSynonymes
Activer les synonymes de modèle.
[dynamique]

-XPolyKinds
Activer le polymorphisme de type. Implique -XKindSignatures.
[dynamique]

-XComposants polymorphes
Activez les composants polymorphes pour les constructeurs de données.
[dynamique, synonyme de -XRankNCTypes]

-OpérateursXPostfix
Activer les opérateurs suffixes.
[dynamique]

-XQuasiCitations
Activer la quasi-cotation.
[dynamique]

-XRank2Types
Activez les types de rang 2.
[dynamique, synonyme de -XRankNCTypes]

-XRankNCTypes
Activez les types de rang N. Impliqué par -XTypesImprédicatifs.
[dynamique]

-XRebindableSyntaxe
Utilisez une syntaxe rebindable. Implique -XNoImplicitPrélude.
[dynamique]

-XRecordWildCards
Activez les caractères génériques d'enregistrement. Implique -XDisambiguateRecordFields.
[dynamique]

-XRécursifDo
Activez la notation do (mdo) récursive.
[dynamique]

-XRelaxedPolyRec
(obsolète) Vérification assouplie des fonctions polymorphes mutuellement récursives.
[dynamique]

-XRoleAnnotations
Activer les annotations de rôle.
[dynamique]

-XSûr Activez le mode Safe Haskell Safe.
[dynamique]

-XScopedTypeVariables
Activez les variables de type à portée lexicale.
[dynamique]

-XStandaloneDérivant
Activer la dérivation autonome.
[dynamique]

-XTemplateHaskell
Activez le modèle Haskell.
[dynamique]

-XNoTraditionalRecordSyntaxe
Désactiver la prise en charge de la syntaxe d'enregistrement traditionnelle (telle que prise en charge par Haskell 98) C {f =
x}
[dynamique]

-XTransformListeComp
Activez les compréhensions de liste généralisées.
[dynamique]

-XFiable
Activez le mode Safe Haskell Trustworthy.
[dynamique]

-XTupleSections
Activez les sections de tuple.
[dynamique]

-XTypeFamilles
Activer les familles de types. Implique -XEspaces de noms explicites, -XKindSignatures ainsi que
-XMonoLocalBinds.
[dynamique]

-XTypeOpérateurs
Activer les opérateurs de type. Implique -XEspaces de noms explicites.
[dynamique]

-XTypeSynonymInstances
Activez les synonymes de type dans les têtes d'instance. Impliqué par -XInstances flexibles.
[dynamique]

-XUnboxedTuples
Activez les tuples non encadrés.
[dynamique]

-XInstances indécidables
Activer les instances indécidables.
[dynamique]

-XUnicodeSyntaxe
Activez la syntaxe Unicode.
[dynamique]

-XTypesFFIC non levés
Activer les types FFI non levés.
[dynamique]

-XNon sûr
Activez le mode non sécurisé Safe Haskell.
[dynamique]

-XViewPatterns
Activer les modèles de vue.
[dynamique]

MISES EN GARDE

-W activer les avertissements normaux
[dynamique]

-w désactiver tous les avertissements
[dynamique]

-Mur activer presque tous les avertissements (détails dans )
[dynamique]

-Werreur
rendre les avertissements fatals
[dynamique]

-Waver rendre les avertissements non mortels
[dynamique]

-fdefer-type-erreurs
Transformez les erreurs de type en avertissements, en différant l'erreur jusqu'à l'exécution. Implique
-fdefer-trous-typés.
[dynamique]

-fdefer-trous-typés
Convertissez les erreurs de trous saisies en avertissements, en différant l'erreur jusqu'à l'exécution. Implicite
by -fdefer-type-erreurs. Voir également -fwarn-typé-trous.
[dynamique]

-fhelpful-erreurs
Faites des suggestions pour les noms mal orthographiés.
[dynamique]

-fwarn-drapeaux-obsolètes
avertir des utilisations des indicateurs de ligne de commande qui sont obsolètes
[dynamique]

-fwarn-duplication-contraintes
avertir lorsqu'une contrainte apparaît dupliquée dans une signature de type
[dynamique]

-fwarn-exports-en double
avertir lorsqu'une entité est exportée plusieurs fois
[dynamique]

-fwarn-salut-ombrage
avertir lorsqu'un fichier .hi dans le répertoire courant masque une bibliothèque
[dynamique]

-fwarn-identités
avertir des utilisations des conversions numériques Prelude qui sont probablement l'identité (et
pourrait donc être omis)
[dynamique]

-fwarn-implicite-prelude
avertir lorsque le Prélude est implicitement importé
[dynamique]

-fwarn-incomplet-patterns
avertir lorsqu'une correspondance de modèle pourrait échouer
[dynamique]

-fwarn-incomplet-uni-patterns
avertir lorsqu'une correspondance de modèle dans une expression lambda ou une liaison de modèle pourrait échouer
[dynamique]

-fwarn-incomplet-record-updates
avertir lorsqu'une mise à jour d'enregistrement pourrait échouer
[dynamique]

-fwarn-lazy-unlifted-reliures
(obsolète) avertir lorsqu'une liaison de modèle semble paresseuse mais doit être stricte
[dynamique]

-fwarn-champs-manquants
avertir lorsque les champs d'un enregistrement sont désinitialisés
[dynamique]

-fwarn-listes-d'importation-manquantes
avertir lorsqu'une déclaration d'importation ne répertorie pas explicitement tous les noms introduits dans
portée
[dynamique]

-fwarn-manquant-méthodes
avertir lorsque les méthodes de classe ne sont pas définies
[dynamique]

-fwarn-manquant-signatures
avertir des fonctions de niveau supérieur sans signatures
[dynamique]

-fwarn-missing-exported-sigs
avertir des fonctions de niveau supérieur sans signature, uniquement si elles sont exportées. prend
priorité sur -fwarn-missing-signatures
[dynamique]

-fwarn-manquant-signatures locales
avertir des liaisons locales polymorphes sans signature
[dynamique]

-fwarn-monomorphisme-restriction
avertir lorsque la restriction de monomorphisme est appliquée
[dynamique]

-fwarn-name-shadowing
avertir lorsque les noms sont masqués
[dynamique]

-fwarn-orphelins, -fwarn-auto-orphelins
avertir lorsque le module contient des déclarations d'instances orphelines ou des règles de réécriture
[dynamique]

-fwarn-motifs-qui se chevauchent
avertir du chevauchement des motifs
[dynamique]

-fwarn-onglets
avertir s'il y a des onglets dans le fichier source
[dynamique]

-fwarn-type-valeurs par défaut
avertir en cas de défaut
[dynamique]

-fwarn-pragmas-non reconnus
avertir des utilisations de pragmas que GHC ne reconnaît pas
[dynamique]

-fwarn-un-ticked-promed-constructors
avertir si les constructeurs promus ne sont pas cochés
[dynamique]

-fwarn-liaisons-inutilisées
avertir des fixations qui ne sont pas utilisées
[dynamique]

-fwarn-importations-inutilisées
avertir des importations inutiles
[dynamique]

-fwarn-matches-inutilisés
avertir des variables dans les modèles qui ne sont pas utilisées
[dynamique]

-fwarn-inutilisé-do-bind
avertir des liaisons do qui semblent jeter des valeurs de types autres que ()
[dynamique]

-fwarn-mauvais-faire-lier
avertir des liaisons do qui semblent jeter les valeurs monadiques que vous devriez
ont lié à la place
[dynamique]

-fwarn-dangereux
avertir si le module en cours de compilation est considéré comme dangereux. Doit être utilisé pour vérifier
l'état de sécurité des modules lors de l'utilisation de l'inférence sûre. Fonctionne sur tous les types de modules,
même ceux qui utilisent des modes Safe Haskell explicites (comme -XFiable) et peut donc être
utilisé pour que le compilateur vérifie toutes les hypothèses faites.
[dynamique]

-fwarn-safe
avertir si le module en cours de compilation est considéré comme sûr. Doit être utilisé pour vérifier
l'état de sécurité des modules lors de l'utilisation de l'inférence sûre. Fonctionne sur tous les types de modules,
même ceux qui utilisent des modes Safe Haskell explicites (comme -XFiable) et peut donc être
utilisé pour que le compilateur vérifie toutes les hypothèses faites.
[dynamique]

-fwarn-digne de confiance-sûr
avertir si le module en cours de compilation est marqué comme -XFiable mais il pourrait à la place
être marqué comme -XSûr, une borne plus informative. Peut être utilisé pour détecter une fois un coffre-fort
Haskell bound peut être amélioré au fur et à mesure que les dépendances sont mises à jour.
[dynamique]

-fwarn-avertissements-dépréciations
avertir des utilisations des fonctions et des types qui ont des avertissements ou des pragmas obsolètes
[dynamique]

-fwarn-ampli
(obsolète) avertir sur les définitions en conflit avec la proposition Applicative-Monad
(AMP)
[dynamique]

-fwarn-typé-trous
Signaler des avertissements lorsque les erreurs de trous saisies sont différées jusqu'à l'exécution. Voir
-fdefer-trous-typés.
[dynamique]

-fwarn-signatures-de-type-partielles
avertir des trous dans les signatures de type partielles lorsque -XPartialTypesignatures is
activée. Non applicable lorsque -XPartialTypesignatures n'est pas activé, auquel cas
des erreurs sont générées pour de tels trous. Voir .
[dynamique]

-fwarn-deriving-typable
avertir lorsqu'il rencontre une demande pour dériver une instance de la classe Typeable. Depuis GHC
7.10, de telles déclarations sont inutiles et sont ignorées par le compilateur car GHC
dispose d'un solveur personnalisé pour décharger ce type de contrainte.
[dynamique]

OPTIMISATION NIVEAUX

-O0 Désactiver les optimisations (par défaut)
[dynamique]

-O or -O1
Activer les optimisations de niveau 1
[dynamique]

-O2 Activer les optimisations de niveau 2
[dynamique]

-Odph Activer les optimisations de niveau 2, définir -fmax-simplifier-itérations=20 ainsi que
-fsimplifier-phases=3.
[dynamique]

INDIVIDUEL OPTIMISATIONS

-fcall-arité
Activez l'optimisation de la callarité. Impliqué par -O.
[dynamique]

-fcase-fusion
Activer la fusion de casse. Impliqué par -O.
[dynamique]

-fcmm-elim-common-blocks
Activez l'élimination des blocs communs Cmm. Impliqué par -O.
[dynamique]

-fcmm-évier
Activer le naufrage Cmm. Impliqué par -O.
[dynamique]

-fcpr-off
Désactivez l'analyse CPR dans l'analyseur de demande.
[statique]

-fcse Activer l'élimination des sous-expressions communes. Impliqué par -O.
[dynamique]

-fdicts-pas cher
Faites en sorte que les expressions à valeur de dictionnaire semblent bon marché à l'optimiseur.
[dynamique]

-fdicts-strict
Rendre les dictionnaires stricts
[dynamique]

-fdmd-tx-dict-sel

Utilisez un transformateur de demande spécial pour les sélecteurs de dictionnaire. Toujours activé par
défaut.
[dynamique]

-fdo-eta-réduction
Activer la réduction êta. Impliqué par -O.
[dynamique]

-extension fdo-lambda-eta
Activez l'extension lambda eta. Toujours activé par défaut.
[dynamique]

-feager-blackholing
Activer le blackholing avide
[dynamique]

-fenable-réécriture-règles
Activez toutes les règles de réécriture (y compris les règles générées par la spécialisation automatique
de fonctions surchargées). Impliqué par -O.
[dynamique]

-fexcès-précision
Activer l'excès de précision intermédiaire
[dynamique]

-fexposer-tous-les-déploiements
Exposez tous les dépliements, même pour les fonctions très grandes ou récursives.
[dynamique]

-flotter
Activez la transformation flottante. Impliqué par -O.
[dynamique]

-pleine-paresse
Activez la paresse totale (fixations flottantes vers l'extérieur). Impliqué par -O.
[dynamique]

-ffamusant à penser
Autoriser worker-wrapper à convertir une fermeture de fonction en un thunk si la fonction
n'utilise aucun de ses arguments. Désactivé par défaut.
[dynamique]

-figore-affirme
Ignorer les affirmations dans la source. Impliqué par -O.
[dynamique]

-figore-interface-pragmas
Ignorer les pragmas dans les fichiers d'interface. Impliqué par -O0 seulement.
[dynamique]

-flate-dmd-anal
Exécutez à nouveau l'analyse de la demande, à la fin du pipeline de simplification
[dynamique]

-fliberate-cas
Activez la transformation Libérer la casse. Impliqué par -O2.
[dynamique]

-fliberate-cas-seuil=n
Définissez le seuil de taille pour la transformation de cas de libération sur n (par défaut : 2000)
[dynamisme]

-floopification
Transformez les appels de queue auto-récursifs saturés en sauts locaux dans le
Assemblée. Impliqué par -O.
[dynamique]

-fmax-inline-alloc-taille=n
Définissez la taille maximale des allocations de tableaux en ligne sur n octets (par défaut : 128). GHC
allouera des tableaux non épinglés de taille statiquement connue dans la pépinière actuelle
bloquer s'ils ne sont pas plus grands que n octets, en ignorant la surcharge GC. Cette valeur doit être
un peu plus petit que la taille du bloc (typiquement : 4096).
[dynamique]

-fmax-inline-memcpy-insns=n

Appels memcpy en ligne s'ils ne généraient pas plus de n pseudo-instructions
(par défaut : 32).
[dynamique]

-fmax-inline-memset-insns=n

Appels memset en ligne s'ils ne généraient pas plus de n pseudo-instructions
(par défaut : 32).
[dynamique]

-fmax-relevant-binds=n
Définissez le nombre maximal de liaisons à afficher dans les messages d'erreur de type (6 par défaut).
[dynamique]

-fmax-simplificateur-itérations=n
Définit le nombre maximal d'itérations pour le simplificateur (par défaut 4).
[dynamique]

-fmax-worker-args=n
Si un worker a autant d'arguments, aucun ne sera plus décompressé (par défaut : 10)
[dynamique]

-fno-opt-coercition
Désactiver l'optimiseur de coercition
[statique]

-fno-pré-entoilage
Désactiver la pré-inline
[dynamique]

-fno-state-hack
Désactivez le "piratage d'état" par lequel tout lambda avec un jeton d'état réel comme
l'argument est considéré comme à entrée unique. Par conséquent, OK pour insérer des choses à l'intérieur.
[statique]

-fomit-interface-pragmas
Ne générez pas de pragmas d'interface. Impliqué par -O0 seulement.
[dynamique]

-fomit-rend
Omettre les vérifications de tas lorsqu'aucune allocation n'est effectuée.
[dynamique]

-fpedantic-bas
Faire en sorte que GHC soit plus précis sur son traitement de fond (mais voir aussi
-fno-state-hack). En particulier, GHC ne s'étendra pas en eta via une expression case.
[dynamique]

-fregs-graphique
Utilisez l'allocateur de registre de coloration de graphique pour l'allocation de registre dans le natif
générateur de code. Impliqué par -O2.
[dynamique]

-fregs-itérative
Utiliser l'allocateur de registre de coloration de graphe de fusion itérative dans le code natif
générateur.
[dynamique]

-fsimplifier-phases=n
Définit le nombre de phases pour le simplificateur (par défaut 2). Ignoré avec -O0.
[dynamique]

-fsimpl-tick-factor=n
Définir le facteur de pourcentage pour les graduations du simplificateur (par défaut 100)
[dynamique]

-fspec-constr
Activez la transformation SpecConstr. Impliqué par -O2.
[dynamique]

-fspec-constr-compte=n
Régler n (par défaut : 3) le nombre maximum de spécialisations qui seront créées
pour n'importe quelle fonction par la transformation SpecConstr
[dynamique]

-fspec-constr-seuil=n
Définissez le seuil de taille pour la transformation SpecConstr sur n (par défaut : 2000)
[dynamique]

-fspécialiser
Activez la spécialisation des fonctions surchargées. Impliqué par -O.
[dynamique]

-fstatic-argument-transformation
Activez la transformation d'argument statique.
[dynamique]

-sévérité
Activez l'analyse de rigueur. Impliqué par -O.
[dynamique]

-fstrictness-avant=n
Exécuter une analyse de rigueur supplémentaire avant la phase de simplification n
[dynamique]

-funbox-petits-champs-stricts
Aplatissez les champs de constructeur stricts avec une représentation de la taille d'un pointeur. Impliqué par
-O.
[dynamique]

-funbox-strict-champs
Aplatir les champs de constructeur stricts
[dynamique]

-funfolding-creation-threshold=n
Ajustez les paramètres de dépliage. Par défaut : 750
[dynamique]

-funfolding-dict-discount=n
Ajustez les paramètres de dépliage. Par défaut : 30
[dynamique]

-funfolding-fun-discount=n
Ajustez les paramètres de dépliage. Par défaut : 60
[dynamique]

-funfolding-keeness-factor=n
Ajustez les paramètres de dépliage. Par défaut : 1.5
[dynamique]

-funfolding-use-threshold=n
Ajustez les paramètres de dépliage. Par défaut : 60
[dynamique]

-fvectorisation-évitement
Activer l'évitement de la vectorisation. Toujours activé par défaut.
[dynamique]

-fvectoriser
Activer la vectorisation du parallélisme des données imbriquées
[dynamique]

PROFILAGE OPTIONS

-prof Activer le profilage
[dynamique]

-fprof-auto
Ajouter automatiquement des SCC à toutes les liaisons non marquées INLINE
[dynamique]

-fprof-auto-top
Ajouter automatiquement des SCC à toutes les liaisons de niveau supérieur non marquées INLINE
[dynamique]

-fprof-auto-exporté
Ajouter automatiquement des SCC à toutes les liaisons exportées non marquées INLINE
[dynamique]

-fprof-cafés
Ajouter automatiquement des SCC à tous les CAF
[dynamique]

-fno-prof-count-entries
Ne pas collecter le nombre d'entrées
[dynamique]

-ticky Activer le profilage ticky-ticky
[dynamique]

PROGRAMME COUVERTURE OPTIONS

-fhpc Activer l'instrumentation de couverture du programme Haskell
[dynamique]

-réppch dir
Répertoire pour déposer les fichiers .mix lors de la compilation (la valeur par défaut est .hpc)
[dynamique]

HASKELL PRÉ-PROCESSEUR OPTIONS

-F Activer l'utilisation d'un préprocesseur (défini avec -pgmF)
[dynamique]

C PRÉ-PROCESSEUR OPTIONS

-cpp Exécutez le préprocesseur C sur les fichiers source Haskell
[dynamique]

-Dsymbole=Plus-value
Définir un symbole dans le préprocesseur C
[dynamique]

-Usymbole
Dédéfinir un symbole dans le préprocesseur C
[dynamique]

-Idir Ajouter dir à la liste de recherche de répertoires pour les fichiers #include
[dynamique]

CODE GÉNÉRATION OPTIONS

-fasme Utiliser le générateur de code natif
[dynamique]

-fllvm Compiler à l'aide du générateur de code LLVM
[dynamique]

-fno-code
Omettre la génération de code
[dynamique]

-fwrite-interface
Toujours écrire les fichiers d'interface
[dynamique]

-fbyte-code
Générer un byte-code
[dynamique]

-fcode-objet
Générer le code objet
[dynamique]

MISE EN RELATION OPTIONS

-partagé
Générer une bibliothèque partagée (par opposition à un exécutable)
[dynamique]

-liblib
Sur Darwin/OS X/iOS uniquement, générez une bibliothèque statique autonome (par opposition à un
exécutable). C'est la manière habituelle de compiler pour iOS.
[dynamique]

-fPIC Générer un code indépendant de la position (le cas échéant)
[dynamique]

-dynamique
Utiliser les bibliothèques dynamiques Haskell (si disponibles)
[dynamique]

-dynamique-aussi
Construire des fichiers objets dynamiques ainsi que des fichiers objets statiques lors de la compilation
[dynamique]

-dyno Définir le chemin de sortie pour les objets liés dynamiquement
[dynamique]

-dynosuf
Définir le suffixe de sortie pour les fichiers d'objets dynamiques
[dynamique]

-dynload
Sélectionne l'un des nombreux modes de recherche des bibliothèques partagées lors de l'exécution.
[dynamique]

-cadre prénom
Sur Darwin/OS X/iOS uniquement, lien dans le framework prénom. Cette option correspond à la
-cadre option pour Linker d'Apple.
[dynamique]

-chemin-cadre prénom
Sur Darwin/OS X/iOS uniquement, ajoutez dir à la liste des répertoires recherchés
cadres. Cette option correspond à la -F option pour Linker d'Apple.
[dynamique]

-llib Lien dans la bibliothèque lib
[dynamique]

-Ldir Ajouter dir à la liste des répertoires recherchés pour les bibliothèques
[dynamique]

-principal-est
Définir le module principal et la fonction
[dynamique]

--mk-dll
Mode de création de DLL (Windows uniquement)
[dynamique]

-no-hs-main
Ne présumez pas que ce programme contient main
[dynamique]

-rtsopts, -rtsopts={aucun,certains,tous}
Contrôlez si le comportement RTS peut être modifié via des indicateurs de ligne de commande et le
Variable d'environnement GHCRTS. L'utilisation de none signifie qu'aucun indicateur RTS ne peut être donné ; certains moyens
seul un minimum d'options sûres peut être donné (valeur par défaut), et tout (ou aucun argument
du tout) signifie que tous les fanions RTS sont autorisés.
[dynamique]

-with-rtsopts=opte
Définissez les options RTS par défaut sur opte.
[dynamique]

-pas de lien
Omettre la liaison
[dynamique]

-split-objs
Objets fractionnés (pour les bibliothèques)
[dynamique]

-statique
Utiliser les bibliothèques statiques Haskell
[dynamique]

-fileté
Utiliser le runtime threadé
[dynamique]

-déboguer Utiliser le runtime de débogage
[dynamique]

-ticky Pour lier, cela implique simplement -déboguer; voir .
[dynamique]

-journal des événements
Activer le suivi des événements d'exécution
[dynamique]

-fno-gen-manifeste
Ne pas générer de fichier manifeste (Windows uniquement)
[dynamique]

-fno-embed-manifeste
Ne pas intégrer le manifeste dans l'exécutable (Windows uniquement)
[dynamique]

-fno-partagé-implib
Ne pas générer de bibliothèque d'importation pour une DLL (Windows uniquement)
[dynamique]

-nom-d'installation-dylib chemin
Définissez le nom d'installation (via -install_name transmis à l'éditeur de liens d'Apple), en spécifiant le
chemin d'installation complet du fichier de bibliothèque. Toutes les bibliothèques ou exécutables liés à
il choisira plus tard ce chemin comme emplacement de recherche d'exécution pour celui-ci. (Darwin/OS
X uniquement)
[dynamique]

-rdynamique
Cela indique à l'éditeur de liens d'ajouter tous les symboles, pas seulement ceux utilisés, à la dynamique
table des symboles. Actuellement Linux et Windows/MinGW32 uniquement. Cela équivaut à utiliser
-optl -rdynamic sous Linux et -optl -export-all-symbols sous Windows.
[dynamique]

BRANCHER OPTIONS

-fplugin=module
Charger un plugin exporté par un module donné
[dynamique]

-fplugin-opt=module:arguments
Donnez des arguments à un module de plugin ; module doit être spécifié avec -fplugin
[dynamique]

REMPLACEMENT ÉTAPES

-pgmL cmd
Utilisez cmd en tant que préprocesseur lettré
[dynamique]

-pgmP cmd
Utilisez cmd comme préprocesseur C (avec -cpp seulement)
[dynamique]

-pgmc cmd
Utilisez cmd en tant que compilateur C
[dynamique]

-pgmlo cmd
Utilisez cmd en tant qu'optimiseur LLVM
[dynamique]

-pgmlc cmd
Utilisez cmd en tant que compilateur LLVM
[dynamique]

-pgms cmd
Utilisez cmd comme diviseur
[dynamique]

-pgma cmd
Utilisez cmd en tant qu'assembleur
[dynamique]

-pgml cmd
Utilisez cmd en tant qu'éditeur de liens
[dynamique]

-pgmdll cmd
Utilisez cmd comme générateur de DLL
[dynamique]

-pgmF cmd
Utilisez cmd en tant que préprocesseur (avec -F seulement)
[dynamique]

-pgmwindres cmd
Utilisez cmd comme programme d'intégration des manifestes sous Windows.
[dynamique]

-pgmlibtool cmd
Utilisez cmd comme commande pour libtool (avec -liblib seulement).
[dynamique]

-pgmreadelf cmd
Utilisez cmd en tant que commande pour readelf (partie d'Unix binutils)
[dynamique]

FORCER OPTIONS À PARTICULIER ÉTAPES

-optL option
pass option au préprocesseur lettré
[dynamique]

-optP option
pass option au cpp (avec -cpp seulement)
[dynamique]

-optF option
pass option au préprocesseur personnalisé
[dynamique]

-optc option
pass option au compilateur C
[dynamique]

-optlo option
pass option à l'optimiseur LLVM
[dynamique]

-optlc option
pass option au compilateur LLVM
[dynamique]

-opta option
pass option à l'assembleur
[dynamique]

-optl option
pass option à l'éditeur de liens
[dynamique]

-optdll option
pass option au générateur de DLL
[dynamique]

-optwindres option
pass option à windres.
[dynamique]

SPÉCIFIQUE À LA PLATEFORME OPTIONS

-msse2 (x86 uniquement) Utiliser SSE2 pour la virgule flottante
[dynamique]

COMPILATEUR DÉBOGAGE OPTIONS

-dcore-peluche
Activer la vérification interne de l'intégrité
[dynamique]

-ddump-vers-fichier
Vider dans des fichiers au lieu de stdout
[dynamique]

-ddump-asm
Ensemble de vidage
[dynamique]

-ddump-bcos
Vider le code d'octet de l'interpréteur
[dynamique]

-ddump-cmm
Vidage C-- sortie
[dynamique]

-ddump-core-stats
Imprimez un résumé d'une ligne de la taille du programme de base à la fin du
pipeline d'optimisation
[dynamique]

-ddump-cse
Vider la sortie CSE
[dynamique]

-ddump-deriv
Dump dérivant la sortie
[dynamique]

-ddump-ds
Vider la sortie de désucrage
[dynamique]

-ddump-étranger
Vider les talons d'exportation étrangers
[dynamique]

-ddump-hpc
Vidage après instrumentation pour la couverture du programme
[dynamique]

-dump-inlinings
Vider les informations de mise en ligne
[dynamique]

-ddump-llvm
Vider le code intermédiaire LLVM
[dynamique]

-ddump-occur-anal
Sortie d'analyse d'occurrence de vidage
[dynamique]

-ddump-opt-cmm
Transférer les résultats des passes C-- à C-- optimisant
[dynamique]

-ddump-parsé
Vider l'arbre d'analyse
[dynamique]

-ddump-prep
Vider le noyau préparé
[dynamique]

-ddump-rn
Vider la sortie de renommage
[dynamique]

-ddump-règle-tirs
Vider les informations de déclenchement de la règle
[dynamique]

-ddump-rule-réécritures
Vider les informations de déclenchement des règles détaillées
[dynamique]

-dump-règles
Règles de vidage
[dynamique]

-ddump-vect
Vider l'entrée et la sortie du vectoriseur
[dynamique]

-ddump-simpl
Vider la sortie du simplificateur final
[dynamique]

-ddump-simpl-itérations
Vider la sortie de chaque itération du simplificateur
[dynamique]

-ddump-spec
Sortie du spécialiste du vidage
[dynamique]

-ddump-épissures
Dump des expressions épissées TH, et ce qu'elles évaluent à
[dynamique]

-ddump-stg
Vider le STG final
[dynamique]

-ddump-stranale
Vider la sortie de l'analyseur de rigueur
[dynamique]

-ddump-strsigs
Vider les signatures de rigueur
[dynamique]

-ddump-tc
Vider la sortie du vérificateur de type
[dynamique]

-dth-dec-fichier
Afficher les déclarations TH évaluées dans un fichier .th.hs
[dynamique]

-types-ddump
Type de vidage des signatures
[dynamique]

-ddump-worker-wrapper
Vider la sortie de l'emballage du travailleur
[dynamique]

-ddump-si-trace
Tracer les fichiers d'interface
[dynamique]

-ddump-tc-trace
Vérificateur de type de trace
[dynamique]

-ddump-vt-trace
Vectoriseur de traces
[dynamique]

-ddump-rn-trace
Renommer la trace
[dynamique]

-ddump-rn-statistiques
Statistiques de renommage
[dynamique]

-ddump-simpl-stats
Vider les statistiques du simplificateur
[dynamique]

-dno-debug-sortie
Supprimer les sorties de débogage non sollicitées
[statique]

-dppr-debug
Activer l'impression de débogage (plus détaillé)
[statique]

-dppr-longueur-utilisateur
Définir la profondeur d'impression des expressions dans les messages d'erreur
[dynamique]

-dppr-colsNNN
Définissez la largeur de la sortie de débogage. Par exemple -dppr-cols200
[dynamique]

-dppr-case-as-let
Imprimez des expressions de cas alternatives uniques en tant que let strict.
[dynamique]

-dsupprimer-tout
Dans les vidages de mémoire, supprimez tout (à l'exception des uniques) qui est supprimable.
[dynamique]

-dsuppress-uniques
Supprimer l'impression des uniques dans la sortie de débogage (diff plus facile à utiliser)
[dynamique]

-dsuppress-idinfo
Supprimer les informations étendues sur les identifiants où ils sont liés
[dynamique]

-dsuppress-module-préfixes
Supprimer l'impression des préfixes de qualification de module
[dynamique]

-dsuppress-type-signatures
Supprimer les signatures de type
[dynamique]

-dsuppress-type-applications
Supprimer les applications de type
[dynamique]

-dsupprimer-les-coercitions
Supprimer l'impression des coercitions dans les vidages Core pour les raccourcir
[dynamique]

-dsource-statistiques
Vider les statistiques de la source haskell
[dynamique]

-dcmm-lint
C--passer la vérification de la santé mentale
[dynamique]

-dstg-lint
Vérification du bon sens du test STG
[dynamique]

-dstg-stats
Vider les statistiques STG
[dynamique]

-dverbose-core2core
Afficher la sortie de chaque passe de cœur à cœur
[dynamique]

-dverbose-stg2stg
Afficher la sortie de chaque passe STG à STG
[dynamique]

-dshow-pass
Imprimez chaque nom de passe au fur et à mesure
[dynamique]

-dfaststring-statistiques
Afficher les statistiques d'utilisation rapide des chaînes une fois terminé
[dynamique]

-frule-vérifier
Signalez les sites avec des règles qui auraient pu se déclencher, mais ne l'ont pas fait. Prend un argument de chaîne.
[dynamique]

MISC COMPILATEUR OPTIONS

-Jn Lors de la compilation avec --make, compilez N modules en parallèle.
[dynamique]

-fno-salut-version-check
Ne vous plaignez pas des incompatibilités de fichiers .hi
[dynamique]

-fhistory-taille
Définir la taille de l'historique de simplification
[dynamique]

-fno-ghci-histoire
N'utilisez pas le chargement/stockage de l'historique des commandes GHCi depuis/vers ghci_history.
[dynamique]

-fno-ghci-bac à sable
Désactivez le bac à sable GHCi. Signifie que les calculs sont exécutés dans le thread principal, plutôt
qu'un fil fourchu.
[dynamique]

Utiliser ghc en ligne en utilisant les services onworks.net