Wie werden Informationen zur Kompilierung korrekt an die Template-Haskell-Funktionen übermittelt?

Question

Ich muss einige Informationen aus Kompilierungsskripten in Template Haskell kommunizieren. Momentan behalten die Kompilierungsskripte die Informationen in der Systemumgebung, also lese ich sie nur unter Verwendung von System.Environment.getEnvironment, eingepackt in runIO. Gibt es einen besseren Weg, zum Beispiel einige Argumente an ghc (ähnlich -D... für den C-Pre-Prozessor) zu übergeben, oder vielleicht etwas speziell für diesen Zweck in TH?

Answer 1

Es sieht so aus, als ob Sie versuchen, here, Die -D-Option in Ghc scheint eine Kompilierzeit Variable zu definieren.

Hier zum gleichen Thema ist eine question, die auch den anderen Teil Ihrer Frage zu beantworten scheint. Von dem, was ich sagen kann, bedingte Kompilierung zu tun, tun Sie so etwas wie:

#ifdef MACRO_NAME 
    //Do stuff here 
    #endif 

Answer 2

Da so viele Menschen in der Frage interessiert sind, werde ich meinen aktuellen Ansatz hinzufügen, vielleicht wird jemand es nützlich finden. Wahrscheinlich wäre der beste Weg, wenn TH -D Parameter auf der GHC-Befehlszeile lesen könnte, aber es scheint, als sei nichts dergleichen implementiert.

Ein einfaches Modul ermöglicht TH, Kompilierzeitumgebung zu lesen. Eine Hilfsfunktion ermöglicht auch das Lesen von Dateien; Lies beispielsweise den Pfad einer Konfigurationsdatei von der Umgebung und lies dann die Datei.

{-# LANGUAGE TemplateHaskell #-} 
module THEnv 
    (
    -- * Compile-time configuration 
     lookupCompileEnv 
    , lookupCompileEnvExp 
    , getCompileEnv 
    , getCompileEnvExp 
    , fileAsString 
    ) where 

import Control.Monad 
import qualified Data.Text as T 
import qualified Data.Text.IO as T 
import Language.Haskell.TH 
import Language.Haskell.TH.Syntax (Lift(..)) 
import System.Environment (getEnvironment) 

-- Functions that work with compile-time configuration 

-- | Looks up a compile-time environment variable. 
lookupCompileEnv :: String -> Q (Maybe String) 
lookupCompileEnv key = lookup key `liftM` runIO getEnvironment 

-- | Looks up a compile-time environment variable. The result is a TH 
-- expression of type @Maybe String@. 
lookupCompileEnvExp :: String -> Q Exp 
lookupCompileEnvExp = (`sigE` [t| Maybe String |]) . lift <=< lookupCompileEnv 
    -- We need to explicly type the result so that things like `print Nothing` 
    -- work. 

-- | Looks up an compile-time environment variable and fail, if it's not 
-- present. 
getCompileEnv :: String -> Q String 
getCompileEnv key = 
    lookupCompileEnv key >>= 
    maybe (fail $ "Environment variable " ++ key ++ " not defined") return 

-- | Looks up an compile-time environment variable and fail, if it's not 
-- present. The result is a TH expression of type @String@. 
getCompileEnvExp :: String -> Q Exp 
getCompileEnvExp = lift <=< getCompileEnv 

-- | Loads the content of a file as a string constant expression. 
-- The given path is relative to the source directory. 
fileAsString :: FilePath -> Q Exp 
fileAsString = do 
    -- addDependentFile path -- works only with template-haskell >= 2.7 
    stringE . T.unpack . T.strip <=< runIO . T.readFile 

Es kann wie folgt verwendet werden:

{-# LANGUAGE TemplateHaskell #-} 
import THEnv 
main = print $(lookupCompileEnvExp "DEBUG") 

Dann:

Nothing

• runhaskell Main.hs druckt;
• DEBUG="yes" runhaskell Main.hs druckt Just "yes".