TL; DR ：使用“ 代码汇总 ”底部列出的模块为您生成代码， 
 
 你不忍心写所有的样板代码。 我非常同情。 还有其他方法，但我们可以使用Template Haskell来生成我们需要的代码。 
 
 如果你是模板Haskell的新手，你应该看看haskellwiki页面 。 
 
 首先，让我们打开模板Haskell扩展，并导入Control.Applicative将代码整理一下： 
 
{-# LANGUAGE TemplateHaskell #-}
import Language.Haskell.TH
import Control.Applicative
 
 我们应该生成什么模板haskell代码？ 
 
 让我们让ghci为我们转换一个恰当的表达。 （为了方便，我伪装了一个getn函数，所以我可以在独立代码中使用它。） 
 
*Main> :set -XTemplateHaskell
*Main> runQ [| Test <$> getn "field1" <*> getn "field2" <*> getn "field3" |]
InfixE (Just (InfixE (Just (InfixE (Just (ConE Main.Test)) (VarE Data.Functor.<$>) (Just (AppE (VarE Main.getn) (LitE (StringL "field1")))))) (VarE Control.Applicative.<*>) (Just (AppE (VarE Main.getn) (LitE (StringL "field2")))))) (VarE Control.Applicative.<*>) (Just (AppE (VarE Main.getn) (LitE (StringL "field3"))))
 
 哇！ 让我们整理一下，并使其有效的haskell代码。 首先请注意，诸如Data.Functor.<$>之类的表达式实际上是Name类型的。 为了得到它，我们可以做mkName "<$>" ，但是字符串修改是最糟糕的源代码操作，所以让我们来执行'(<$>) ，它会从函数生成（完全限定）名称： 
 
whatWeWant = InfixE 
    (Just (InfixE 
             (Just (InfixE 
                      (Just (ConE 'Test)) 
                      (VarE '(<$>)) 
                      (Just (AppE (VarE 'getn) (LitE (StringL "field1")))))) 
             (VarE '(<*>)) 
             (Just (AppE (VarE 'getn) (LitE (StringL "field2")))))) 
    (VarE '(<*>)) 
    (Just (AppE (VarE 'getn) (LitE (StringL "field3"))))
 
 这个（隐藏的）美妙之处在于，它只是一个非常类似的表达，我们可以一起折叠。 
 
 生成我们需要的表达式 
 
fieldExpressions :: Name -> [String] -> [Exp]
fieldExpressions getter = map $ \field -> AppE (VarE getter) (LitE (StringL field))
 
 让我们使用<<*>>作为<*>的一种提升来将表达式与<*>绑定在一起： 
 
(<<*>>) :: Exp -> Exp -> Exp
a <<*>> b = InfixE  (Just a)  (VarE '(<*>))  (Just b)
 
 现在，当我们获取字段时，我们将首先通过<$>将构造函数应用于第一个字段，然后我们可以将其用作折叠其他字段的基础。 
 
getFields :: Name -> [Exp] -> Exp
getFields _ [] = error "getFields: empty field list"
getFields constructor (f:fs) = foldl (<<*>>) 
                               ( InfixE  (Just $ ConE constructor)  (VarE '(<$>))  (Just f) )
                               fs
 
 快速检查： 
 
*Main> whatWeWant == (getFields 'Test $ fieldExpressions 'getn ["field1","field2","field3"])
True
 
 舞台限制叮咬 
 
 我们可以用同一个源文件测试/使用它 
 
domything = do
   optionsRecord <- $(return $ getFields 'Test $ fieldExpressions 'getn ["field1","field2","field3"])
   print optionsRecord
 
 除非你会遇到相当不方便的阶段限制： 
 
GHC stage restriction: `getFields'
  is used in a top-level splice or annotation,
  and must be imported, not defined locally
 
 这意味着您必须在另一个模块中定义getFields等，然后将其导入到您的主文件中，并在其中拼接。 
 
 代码摘要 
 
 GetFields.hs： 
 
{-# LANGUAGE TemplateHaskell #-}
import Language.Haskell.TH
import Control.Applicative

module GetFields where

fieldExpressions :: Name -> [String] -> [Exp]
fieldExpressions getter = map $ \field -> AppE (VarE getter) (LitE (StringL field))

(<<*>>) :: Exp -> Exp -> Exp
a <<*>> b = InfixE  (Just a)  (VarE '(<*>))  (Just b)

getFields :: Name -> [Exp] -> Exp
getFields _ [] = error "getFields: empty field list"
getFields constructor (f:fs) = foldl (<<*>>) 
                               ( InfixE  (Just $ ConE constructor)  (VarE '(<$>))  (Just f) )
                               fs
 
 Main.hs： 
 
import GetFields
import Data.ConfigFile

...defs...

readConfigFile = do
  rv <- runErrorT $ do 
    cp <- join . liftIO $ readfile emptyCP "theconfig.cfg"
    let printn = liftIO . putStrLn
        getn = get x "DEFAULT"
        x = cp
    printn "Loading configuration file..."
    someoptions <- $(getFields 'Test $ fieldExpressions 'getn ["field" ++ show n| n<-[1..30]])

TL;DR: Generate your code for you using the module listed at the bottom under "Code Summary"
 
You can't bear to write all that boilerplate code. I can very much sympathise. There are other approaches, but we could use Template Haskell to generate the code we need.
 
If you're new to Template Haskell, you should have a look at the haskellwiki page.
 
First, let's turn on the Template Haskell extension, and import Control.Applicative to tidy the code up a bit:
 
{-# LANGUAGE TemplateHaskell #-}
import Language.Haskell.TH
import Control.Applicative
 
What template haskell code should we generate?
 
And let's ask ghci to convert an appropriate expression for us. (I faked a getn function for convenience so I can use it in standalone code.)
 
*Main> :set -XTemplateHaskell
*Main> runQ [| Test <$> getn "field1" <*> getn "field2" <*> getn "field3" |]
InfixE (Just (InfixE (Just (InfixE (Just (ConE Main.Test)) (VarE Data.Functor.<$>) (Just (AppE (VarE Main.getn) (LitE (StringL "field1")))))) (VarE Control.Applicative.<*>) (Just (AppE (VarE Main.getn) (LitE (StringL "field2")))))) (VarE Control.Applicative.<*>) (Just (AppE (VarE Main.getn) (LitE (StringL "field3"))))
 
Woah! let's tidy that up a bit, and make it valid haskell code. Firstly note that an expression such as Data.Functor.<$> is actually of type Name. To get it we could do mkName "<$>", but string mangling is the ugliest sort of source code manipulation, so let's do '(<$>) instead, which generates the (fully qualified) name from the function:
 
whatWeWant = InfixE 
    (Just (InfixE 
             (Just (InfixE 
                      (Just (ConE 'Test)) 
                      (VarE '(<$>)) 
                      (Just (AppE (VarE 'getn) (LitE (StringL "field1")))))) 
             (VarE '(<*>)) 
             (Just (AppE (VarE 'getn) (LitE (StringL "field2")))))) 
    (VarE '(<*>)) 
    (Just (AppE (VarE 'getn) (LitE (StringL "field3"))))
 
The (hidden) beauty of this is that it's just a load of very similar expressions that we can fold together.
 
Generating the expressions we need
 
fieldExpressions :: Name -> [String] -> [Exp]
fieldExpressions getter = map $ \field -> AppE (VarE getter) (LitE (StringL field))
 
Let's use <<*>> as a sort of lift of <*> to glue expressions together with <*>:
 
(<<*>>) :: Exp -> Exp -> Exp
a <<*>> b = InfixE  (Just a)  (VarE '(<*>))  (Just b)
 
Now when we get the fields, we'll first apply the constructor via <$> to the first field, then we can use that as the base for a fold over the other fields.
 
getFields :: Name -> [Exp] -> Exp
getFields _ [] = error "getFields: empty field list"
getFields constructor (f:fs) = foldl (<<*>>) 
                               ( InfixE  (Just $ ConE constructor)  (VarE '(<$>))  (Just f) )
                               fs
 
A quick check:
 
*Main> whatWeWant == (getFields 'Test $ fieldExpressions 'getn ["field1","field2","field3"])
True
 
The stage restriction bites
 
We could test/use that in the same source file with 
 
domything = do
   optionsRecord <- $(return $ getFields 'Test $ fieldExpressions 'getn ["field1","field2","field3"])
   print optionsRecord
 
except that you'll run into the rather inconvenient stage restriction:
 
GHC stage restriction: `getFields'
  is used in a top-level splice or annotation,
  and must be imported, not defined locally
 
That means that you'll have to define getFields etc in another module, and then import that into your main file where you can splice it in.
 
Code Summary
 
GetFields.hs:
 
{-# LANGUAGE TemplateHaskell #-}
import Language.Haskell.TH
import Control.Applicative

module GetFields where

fieldExpressions :: Name -> [String] -> [Exp]
fieldExpressions getter = map $ \field -> AppE (VarE getter) (LitE (StringL field))

(<<*>>) :: Exp -> Exp -> Exp
a <<*>> b = InfixE  (Just a)  (VarE '(<*>))  (Just b)

getFields :: Name -> [Exp] -> Exp
getFields _ [] = error "getFields: empty field list"
getFields constructor (f:fs) = foldl (<<*>>) 
                               ( InfixE  (Just $ ConE constructor)  (VarE '(<$>))  (Just f) )
                               fs
 
Main.hs:
 
import GetFields
import Data.ConfigFile

...defs...

readConfigFile = do
  rv <- runErrorT $ do 
    cp <- join . liftIO $ readfile emptyCP "theconfig.cfg"
    let printn = liftIO . putStrLn
        getn = get x "DEFAULT"
        x = cp
    printn "Loading configuration file..."
    someoptions <- $(getFields 'Test $ fieldExpressions 'getn ["field" ++ show n| n<-[1..30]])