1 {-# LANGUAGE TemplateHaskell #-}
3 {-| TemplateHaskell helper for HTools.
5 As TemplateHaskell require that splices be defined in a separate
6 module, we combine all the TemplateHaskell functionality that HTools
7 needs in this module (except the one for unittests).
13 Copyright (C) 2011, 2012 Google Inc.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
32 module Ganeti.THH ( declareSADT
51 , buildObjectSerialisation
57 import Control.Monad (liftM, liftM2)
60 import qualified Data.Map as M
61 import Language.Haskell.TH
63 import qualified Text.JSON as JSON
65 import Ganeti.HTools.JSON
69 type Container = M.Map String
71 -- | Serialised field data type.
72 data Field = Field { fieldName :: String
74 , fieldRead :: Maybe (Q Exp)
75 , fieldShow :: Maybe (Q Exp)
76 , fieldDefault :: Maybe (Q Exp)
77 , fieldConstr :: Maybe String
78 , fieldIsContainer :: Bool
79 , fieldIsOptional :: Bool
82 -- | Generates a simple field.
83 simpleField :: String -> Q Type -> Field
84 simpleField fname ftype =
85 Field { fieldName = fname
89 , fieldDefault = Nothing
90 , fieldConstr = Nothing
91 , fieldIsContainer = False
92 , fieldIsOptional = False
95 -- | Sets the renamed constructor field.
96 renameField :: String -> Field -> Field
97 renameField constrName field = field { fieldConstr = Just constrName }
99 -- | Sets the default value on a field (makes it optional with a
101 defaultField :: Q Exp -> Field -> Field
102 defaultField defval field = field { fieldDefault = Just defval }
104 -- | Marks a field optional (turning its base type into a Maybe).
105 optionalField :: Field -> Field
106 optionalField field = field { fieldIsOptional = True }
108 -- | Marks a field as a container.
109 containerField :: Field -> Field
110 containerField field = field { fieldIsContainer = True }
112 -- | Sets custom functions on a field.
113 customField :: Q Exp -> Q Exp -> Field -> Field
114 customField readfn showfn field =
115 field { fieldRead = Just readfn, fieldShow = Just showfn }
117 fieldRecordName :: Field -> String
118 fieldRecordName (Field { fieldName = name, fieldConstr = alias }) =
119 maybe (camelCase name) id alias
121 -- | Computes the preferred variable name to use for the value of this
122 -- field. If the field has a specific constructor name, then we use a
123 -- first-letter-lowercased version of that; otherwise, we simply use
124 -- the field name. See also 'fieldRecordName'.
125 fieldVariable :: Field -> String
127 case (fieldConstr f) of
128 Just name -> ensureLower name
131 actualFieldType :: Field -> Q Type
132 actualFieldType f | fieldIsContainer f = [t| Container $t |]
133 | fieldIsOptional f = [t| Maybe $t |]
135 where t = fieldType f
137 checkNonOptDef :: (Monad m) => Field -> m ()
138 checkNonOptDef (Field { fieldIsOptional = True, fieldName = name }) =
139 fail $ "Optional field " ++ name ++ " used in parameter declaration"
140 checkNonOptDef (Field { fieldDefault = (Just _), fieldName = name }) =
141 fail $ "Default field " ++ name ++ " used in parameter declaration"
142 checkNonOptDef _ = return ()
144 loadFn :: Field -> Q Exp -> Q Exp
145 loadFn (Field { fieldIsContainer = True }) expr = [| $expr >>= readContainer |]
146 loadFn (Field { fieldRead = Just readfn }) expr = [| $expr >>= $readfn |]
149 saveFn :: Field -> Q Exp -> Q Exp
150 saveFn (Field { fieldIsContainer = True }) expr = [| showContainer $expr |]
151 saveFn (Field { fieldRead = Just readfn }) expr = [| $readfn $expr |]
154 -- * Common field declarations
156 timeStampFields :: [Field]
158 [ defaultField [| 0::Double |] $ simpleField "ctime" [t| Double |]
159 , defaultField [| 0::Double |] $ simpleField "mtime" [t| Double |]
162 serialFields :: [Field]
164 [ renameField "Serial" $ simpleField "serial_no" [t| Int |] ]
166 uuidFields :: [Field]
167 uuidFields = [ simpleField "uuid" [t| String |] ]
169 -- * Helper functions
171 -- | Ensure first letter is lowercase.
173 -- Used to convert type name to function prefix, e.g. in @data Aa ->
175 ensureLower :: String -> String
177 ensureLower (x:xs) = toLower x:xs
179 -- | Ensure first letter is uppercase.
181 -- Used to convert constructor name to component
182 ensureUpper :: String -> String
184 ensureUpper (x:xs) = toUpper x:xs
186 -- | Helper for quoted expressions.
187 varNameE :: String -> Q Exp
188 varNameE = varE . mkName
190 -- | showJSON as an expression, for reuse.
192 showJSONE = varNameE "showJSON"
194 -- | ToRaw function name.
195 toRawName :: String -> Name
196 toRawName = mkName . (++ "ToRaw") . ensureLower
198 -- | FromRaw function name.
199 fromRawName :: String -> Name
200 fromRawName = mkName . (++ "FromRaw") . ensureLower
202 -- | Converts a name to it's varE/litE representations.
204 reprE :: Either String Name -> Q Exp
205 reprE = either stringE varE
207 -- | Smarter function application.
209 -- This does simply f x, except that if is 'id', it will skip it, in
210 -- order to generate more readable code when using -ddump-splices.
211 appFn :: Exp -> Exp -> Exp
212 appFn f x | f == VarE 'id = x
213 | otherwise = AppE f x
215 -- | Container loader
216 readContainer :: (Monad m, JSON.JSON a) =>
217 JSON.JSObject JSON.JSValue -> m (Container a)
218 readContainer obj = do
219 let kjvlist = JSON.fromJSObject obj
220 kalist <- mapM (\(k, v) -> fromKeyValue k v >>= \a -> return (k, a)) kjvlist
221 return $ M.fromList kalist
223 -- | Container dumper
224 showContainer :: (JSON.JSON a) => Container a -> JSON.JSValue
225 showContainer = JSON.makeObj . map (second JSON.showJSON) . M.toList
227 -- * Template code for simple raw type-equivalent ADTs
229 -- | Generates a data type declaration.
231 -- The type will have a fixed list of instances.
232 strADTDecl :: Name -> [String] -> Dec
233 strADTDecl name constructors =
235 (map (flip NormalC [] . mkName) constructors)
236 [''Show, ''Read, ''Eq, ''Enum, ''Bounded, ''Ord]
238 -- | Generates a toRaw function.
240 -- This generates a simple function of the form:
243 -- nameToRaw :: Name -> /traw/
244 -- nameToRaw Cons1 = var1
245 -- nameToRaw Cons2 = \"value2\"
247 genToRaw :: Name -> Name -> Name -> [(String, Either String Name)] -> Q [Dec]
248 genToRaw traw fname tname constructors = do
249 let sigt = AppT (AppT ArrowT (ConT tname)) (ConT traw)
250 -- the body clauses, matching on the constructor and returning the
252 clauses <- mapM (\(c, v) -> clause [recP (mkName c) []]
253 (normalB (reprE v)) []) constructors
254 return [SigD fname sigt, FunD fname clauses]
256 -- | Generates a fromRaw function.
258 -- The function generated is monadic and can fail parsing the
259 -- raw value. It is of the form:
262 -- nameFromRaw :: (Monad m) => /traw/ -> m Name
263 -- nameFromRaw s | s == var1 = Cons1
264 -- | s == \"value2\" = Cons2
265 -- | otherwise = fail /.../
267 genFromRaw :: Name -> Name -> Name -> [(String, Name)] -> Q [Dec]
268 genFromRaw traw fname tname constructors = do
269 -- signature of form (Monad m) => String -> m $name
270 sigt <- [t| (Monad m) => $(conT traw) -> m $(conT tname) |]
271 -- clauses for a guarded pattern
272 let varp = mkName "s"
274 clauses <- mapM (\(c, v) -> do
275 -- the clause match condition
276 g <- normalG [| $varpe == $(varE v) |]
278 r <- [| return $(conE (mkName c)) |]
279 return (g, r)) constructors
280 -- the otherwise clause (fallback)
282 g <- normalG [| otherwise |]
283 r <- [|fail ("Invalid string value for type " ++
284 $(litE (stringL (nameBase tname))) ++ ": " ++ show $varpe) |]
286 let fun = FunD fname [Clause [VarP varp]
287 (GuardedB (clauses++[oth_clause])) []]
288 return [SigD fname sigt, fun]
290 -- | Generates a data type from a given raw format.
292 -- The format is expected to multiline. The first line contains the
293 -- type name, and the rest of the lines must contain two words: the
294 -- constructor name and then the string representation of the
295 -- respective constructor.
297 -- The function will generate the data type declaration, and then two
300 -- * /name/ToRaw, which converts the type to a raw type
302 -- * /name/FromRaw, which (monadically) converts from a raw type to the type
304 -- Note that this is basically just a custom show/read instance,
306 declareADT :: Name -> String -> [(String, Name)] -> Q [Dec]
307 declareADT traw sname cons = do
308 let name = mkName sname
309 ddecl = strADTDecl name (map fst cons)
310 -- process cons in the format expected by genToRaw
311 cons' = map (\(a, b) -> (a, Right b)) cons
312 toraw <- genToRaw traw (toRawName sname) name cons'
313 fromraw <- genFromRaw traw (fromRawName sname) name cons
314 return $ ddecl:toraw ++ fromraw
316 declareIADT :: String -> [(String, Name)] -> Q [Dec]
317 declareIADT = declareADT ''Int
319 declareSADT :: String -> [(String, Name)] -> Q [Dec]
320 declareSADT = declareADT ''String
322 -- | Creates the showJSON member of a JSON instance declaration.
324 -- This will create what is the equivalent of:
327 -- showJSON = showJSON . /name/ToRaw
330 -- in an instance JSON /name/ declaration
331 genShowJSON :: String -> Q Dec
332 genShowJSON name = do
333 body <- [| JSON.showJSON . $(varE (toRawName name)) |]
334 return $ FunD (mkName "showJSON") [Clause [] (NormalB body) []]
336 -- | Creates the readJSON member of a JSON instance declaration.
338 -- This will create what is the equivalent of:
341 -- readJSON s = case readJSON s of
342 -- Ok s' -> /name/FromRaw s'
343 -- Error e -> Error /description/
346 -- in an instance JSON /name/ declaration
347 genReadJSON :: String -> Q Dec
348 genReadJSON name = do
350 body <- [| case JSON.readJSON $(varE s) of
351 JSON.Ok s' -> $(varE (fromRawName name)) s'
353 JSON.Error $ "Can't parse raw value for type " ++
354 $(stringE name) ++ ": " ++ e ++ " from " ++
357 return $ FunD (mkName "readJSON") [Clause [VarP s] (NormalB body) []]
359 -- | Generates a JSON instance for a given type.
361 -- This assumes that the /name/ToRaw and /name/FromRaw functions
362 -- have been defined as by the 'declareSADT' function.
363 makeJSONInstance :: Name -> Q [Dec]
364 makeJSONInstance name = do
365 let base = nameBase name
366 showJ <- genShowJSON base
367 readJ <- genReadJSON base
368 return [InstanceD [] (AppT (ConT ''JSON.JSON) (ConT name)) [readJ,showJ]]
370 -- * Template code for opcodes
372 -- | Transforms a CamelCase string into an_underscore_based_one.
373 deCamelCase :: String -> String
375 intercalate "_" . map (map toUpper) . groupBy (\_ b -> not $ isUpper b)
377 -- | Transform an underscore_name into a CamelCase one.
378 camelCase :: String -> String
379 camelCase = concatMap (ensureUpper . drop 1) .
380 groupBy (\_ b -> b /= '_') . ('_':)
382 -- | Computes the name of a given constructor.
383 constructorName :: Con -> Q Name
384 constructorName (NormalC name _) = return name
385 constructorName (RecC name _) = return name
386 constructorName x = fail $ "Unhandled constructor " ++ show x
388 -- | Builds the generic constructor-to-string function.
390 -- This generates a simple function of the following form:
393 -- fname (ConStructorOne {}) = trans_fun("ConStructorOne")
394 -- fname (ConStructorTwo {}) = trans_fun("ConStructorTwo")
397 -- This builds a custom list of name/string pairs and then uses
398 -- 'genToRaw' to actually generate the function
399 genConstrToStr :: (String -> String) -> Name -> String -> Q [Dec]
400 genConstrToStr trans_fun name fname = do
401 TyConI (DataD _ _ _ cons _) <- reify name
402 cnames <- mapM (liftM nameBase . constructorName) cons
403 let svalues = map (Left . trans_fun) cnames
404 genToRaw ''String (mkName fname) name $ zip cnames svalues
406 -- | Constructor-to-string for OpCode.
407 genOpID :: Name -> String -> Q [Dec]
408 genOpID = genConstrToStr deCamelCase
410 -- | OpCode parameter (field) type.
411 type OpParam = (String, Q Type, Q Exp)
413 -- | Generates the OpCode data type.
415 -- This takes an opcode logical definition, and builds both the
416 -- datatype and the JSON serialisation out of it. We can't use a
417 -- generic serialisation since we need to be compatible with Ganeti's
418 -- own, so we have a few quirks to work around.
419 genOpCode :: String -- ^ Type name to use
420 -> [(String, [Field])] -- ^ Constructor name and parameters
422 genOpCode name cons = do
423 decl_d <- mapM (\(cname, fields) -> do
424 -- we only need the type of the field, without Q
425 fields' <- mapM actualFieldType fields
426 let fields'' = zip (repeat NotStrict) fields'
427 return $ NormalC (mkName cname) fields'')
429 let declD = DataD [] (mkName name) [] decl_d [''Show, ''Read, ''Eq]
431 (savesig, savefn) <- genSaveOpCode cons
432 (loadsig, loadfn) <- genLoadOpCode cons
433 return [declD, loadsig, loadfn, savesig, savefn]
435 -- | Checks whether a given parameter is options.
437 -- This requires that it's a 'Maybe'.
438 isOptional :: Type -> Bool
439 isOptional (AppT (ConT dt) _) | dt == ''Maybe = True
442 -- | Generates the \"save\" clause for an entire opcode constructor.
444 -- This matches the opcode with variables named the same as the
445 -- constructor fields (just so that the spliced in code looks nicer),
446 -- and passes those name plus the parameter definition to 'saveObjectField'.
447 saveConstructor :: String -- ^ The constructor name
448 -> [Field] -- ^ The parameter definitions for this
450 -> Q Clause -- ^ Resulting clause
451 saveConstructor sname fields = do
452 let cname = mkName sname
453 let fnames = map (mkName . fieldVariable) fields
454 let pat = conP cname (map varP fnames)
455 let felems = map (uncurry saveObjectField) (zip fnames fields)
456 -- now build the OP_ID serialisation
457 opid = [| [( $(stringE "OP_ID"),
458 JSON.showJSON $(stringE . deCamelCase $ sname) )] |]
459 flist = listE (opid:felems)
460 -- and finally convert all this to a json object
461 flist' = [| $(varNameE "makeObj") (concat $flist) |]
462 clause [pat] (normalB flist') []
464 -- | Generates the main save opcode function.
466 -- This builds a per-constructor match clause that contains the
467 -- respective constructor-serialisation code.
468 genSaveOpCode :: [(String, [Field])] -> Q (Dec, Dec)
469 genSaveOpCode opdefs = do
470 cclauses <- mapM (uncurry saveConstructor) opdefs
471 let fname = mkName "saveOpCode"
472 sigt <- [t| $(conT (mkName "OpCode")) -> JSON.JSValue |]
473 return $ (SigD fname sigt, FunD fname cclauses)
475 loadConstructor :: String -> [Field] -> Q Exp
476 loadConstructor sname fields = do
477 let name = mkName sname
478 fbinds <- mapM loadObjectField fields
479 let (fnames, fstmts) = unzip fbinds
480 let cval = foldl (\accu fn -> AppE accu (VarE fn)) (ConE name) fnames
481 fstmts' = fstmts ++ [NoBindS (AppE (VarE 'return) cval)]
484 genLoadOpCode :: [(String, [Field])] -> Q (Dec, Dec)
485 genLoadOpCode opdefs = do
486 let fname = mkName "loadOpCode"
489 opid = mkName "op_id"
490 st1 <- bindS (varP objname) [| liftM JSON.fromJSObject
491 (JSON.readJSON $(varE arg1)) |]
492 st2 <- bindS (varP opid) [| $(varNameE "fromObj")
493 $(varE objname) $(stringE "OP_ID") |]
494 -- the match results (per-constructor blocks)
495 mexps <- mapM (uncurry loadConstructor) opdefs
496 fails <- [| fail $ "Unknown opcode " ++ $(varE opid) |]
497 let mpats = map (\(me, c) ->
498 let mp = LitP . StringL . deCamelCase . fst $ c
499 in Match mp (NormalB me) []
501 defmatch = Match WildP (NormalB fails) []
502 cst = NoBindS $ CaseE (VarE opid) $ mpats++[defmatch]
503 body = DoE [st1, st2, cst]
504 sigt <- [t| JSON.JSValue -> JSON.Result $(conT (mkName "OpCode")) |]
505 return $ (SigD fname sigt, FunD fname [Clause [VarP arg1] (NormalB body) []])
507 -- * Template code for luxi
509 -- | Constructor-to-string for LuxiOp.
510 genStrOfOp :: Name -> String -> Q [Dec]
511 genStrOfOp = genConstrToStr id
513 -- | Constructor-to-string for MsgKeys.
514 genStrOfKey :: Name -> String -> Q [Dec]
515 genStrOfKey = genConstrToStr ensureLower
517 -- | LuxiOp parameter type.
518 type LuxiParam = (String, Q Type, Q Exp)
520 -- | Generates the LuxiOp data type.
522 -- This takes a Luxi operation definition and builds both the
523 -- datatype and the function trnasforming the arguments to JSON.
524 -- We can't use anything less generic, because the way different
525 -- operations are serialized differs on both parameter- and top-level.
527 -- There are three things to be defined for each parameter:
533 -- * operation; this is the operation performed on the parameter before
536 genLuxiOp :: String -> [(String, [LuxiParam])] -> Q [Dec]
537 genLuxiOp name cons = do
538 decl_d <- mapM (\(cname, fields) -> do
539 fields' <- mapM (\(_, qt, _) ->
540 qt >>= \t -> return (NotStrict, t))
542 return $ NormalC (mkName cname) fields')
544 let declD = DataD [] (mkName name) [] decl_d [''Show, ''Read, ''Eq]
545 (savesig, savefn) <- genSaveLuxiOp cons
546 req_defs <- declareSADT "LuxiReq" .
547 map (\(str, _) -> ("Req" ++ str, mkName ("luxiReq" ++ str))) $
549 return $ [declD, savesig, savefn] ++ req_defs
551 -- | Generates the \"save\" expression for a single luxi parameter.
552 saveLuxiField :: Name -> LuxiParam -> Q Exp
553 saveLuxiField fvar (_, qt, fn) =
554 [| JSON.showJSON ( $(liftM2 appFn fn $ varE fvar) ) |]
556 -- | Generates the \"save\" clause for entire LuxiOp constructor.
557 saveLuxiConstructor :: (String, [LuxiParam]) -> Q Clause
558 saveLuxiConstructor (sname, fields) = do
559 let cname = mkName sname
560 fnames = map (\(nm, _, _) -> mkName nm) fields
561 pat = conP cname (map varP fnames)
562 flist = map (uncurry saveLuxiField) (zip fnames fields)
563 finval = if null flist
564 then [| JSON.showJSON () |]
565 else [| JSON.showJSON $(listE flist) |]
566 clause [pat] (normalB finval) []
568 -- | Generates the main save LuxiOp function.
569 genSaveLuxiOp :: [(String, [LuxiParam])]-> Q (Dec, Dec)
570 genSaveLuxiOp opdefs = do
571 sigt <- [t| $(conT (mkName "LuxiOp")) -> JSON.JSValue |]
572 let fname = mkName "opToArgs"
573 cclauses <- mapM saveLuxiConstructor opdefs
574 return $ (SigD fname sigt, FunD fname cclauses)
576 -- * "Objects" functionality
578 -- | Extract the field's declaration from a Field structure.
579 fieldTypeInfo :: String -> Field -> Q (Name, Strict, Type)
580 fieldTypeInfo field_pfx fd = do
581 t <- actualFieldType fd
582 let n = mkName . (field_pfx ++) . fieldRecordName $ fd
583 return (n, NotStrict, t)
585 -- | Build an object declaration.
586 buildObject :: String -> String -> [Field] -> Q [Dec]
587 buildObject sname field_pfx fields = do
588 let name = mkName sname
589 fields_d <- mapM (fieldTypeInfo field_pfx) fields
590 let decl_d = RecC name fields_d
591 let declD = DataD [] name [] [decl_d] [''Show, ''Read, ''Eq]
592 ser_decls <- buildObjectSerialisation sname fields
593 return $ declD:ser_decls
595 buildObjectSerialisation :: String -> [Field] -> Q [Dec]
596 buildObjectSerialisation sname fields = do
597 let name = mkName sname
598 savedecls <- genSaveObject saveObjectField sname fields
599 (loadsig, loadfn) <- genLoadObject loadObjectField sname fields
600 shjson <- objectShowJSON sname
601 rdjson <- objectReadJSON sname
602 let instdecl = InstanceD [] (AppT (ConT ''JSON.JSON) (ConT name))
604 return $ savedecls ++ [loadsig, loadfn, instdecl]
606 genSaveObject :: (Name -> Field -> Q Exp)
607 -> String -> [Field] -> Q [Dec]
608 genSaveObject save_fn sname fields = do
609 let name = mkName sname
610 let fnames = map (mkName . fieldVariable) fields
611 let pat = conP name (map varP fnames)
612 let tdname = mkName ("toDict" ++ sname)
613 tdsigt <- [t| $(conT name) -> [(String, JSON.JSValue)] |]
615 let felems = map (uncurry save_fn) (zip fnames fields)
617 -- and finally convert all this to a json object
618 tdlist = [| concat $flist |]
620 tclause <- clause [pat] (normalB tdlist) []
621 cclause <- [| $(varNameE "makeObj") . $(varE tdname) |]
622 let fname = mkName ("save" ++ sname)
623 sigt <- [t| $(conT name) -> JSON.JSValue |]
624 return [SigD tdname tdsigt, FunD tdname [tclause],
625 SigD fname sigt, ValD (VarP fname) (NormalB cclause) []]
627 saveObjectField :: Name -> Field -> Q Exp
628 saveObjectField fvar field
629 | isContainer = [| [( $nameE , JSON.showJSON . showContainer $ $fvarE)] |]
630 | fisOptional = [| case $(varE fvar) of
632 Just v -> [( $nameE, JSON.showJSON v)]
634 | otherwise = case fieldShow field of
635 Nothing -> [| [( $nameE, JSON.showJSON $fvarE)] |]
636 Just fn -> [| [( $nameE, JSON.showJSON . $fn $ $fvarE)] |]
637 where isContainer = fieldIsContainer field
638 fisOptional = fieldIsOptional field
639 nameE = stringE (fieldName field)
642 objectShowJSON :: String -> Q Dec
643 objectShowJSON name = do
644 body <- [| JSON.showJSON . $(varE . mkName $ "save" ++ name) |]
645 return $ FunD (mkName "showJSON") [Clause [] (NormalB body) []]
647 genLoadObject :: (Field -> Q (Name, Stmt))
648 -> String -> [Field] -> Q (Dec, Dec)
649 genLoadObject load_fn sname fields = do
650 let name = mkName sname
651 funname = mkName $ "load" ++ sname
654 opid = mkName "op_id"
655 st1 <- bindS (varP objname) [| liftM JSON.fromJSObject
656 (JSON.readJSON $(varE arg1)) |]
657 fbinds <- mapM load_fn fields
658 let (fnames, fstmts) = unzip fbinds
659 let cval = foldl (\accu fn -> AppE accu (VarE fn)) (ConE name) fnames
660 fstmts' = st1:fstmts ++ [NoBindS (AppE (VarE 'return) cval)]
661 sigt <- [t| JSON.JSValue -> JSON.Result $(conT name) |]
662 return $ (SigD funname sigt,
663 FunD funname [Clause [VarP arg1] (NormalB (DoE fstmts')) []])
665 loadObjectField :: Field -> Q (Name, Stmt)
666 loadObjectField field = do
667 let name = fieldVariable field
669 -- these are used in all patterns below
670 let objvar = varNameE "o"
671 objfield = stringE (fieldName field)
673 if fieldIsOptional field
674 then [| $(varNameE "maybeFromObj") $objvar $objfield |]
675 else case fieldDefault field of
677 [| $(varNameE "fromObjWithDefault") $objvar
679 Nothing -> [| $(varNameE "fromObj") $objvar $objfield |]
680 bexp <- loadFn field loadexp
682 return (fvar, BindS (VarP fvar) bexp)
684 objectReadJSON :: String -> Q Dec
685 objectReadJSON name = do
687 body <- [| case JSON.readJSON $(varE s) of
688 JSON.Ok s' -> $(varE .mkName $ "load" ++ name) s'
690 JSON.Error $ "Can't parse value for type " ++
691 $(stringE name) ++ ": " ++ e
693 return $ FunD (mkName "readJSON") [Clause [VarP s] (NormalB body) []]
695 -- * Inheritable parameter tables implementation
697 -- | Compute parameter type names.
698 paramTypeNames :: String -> (String, String)
699 paramTypeNames root = ("Filled" ++ root ++ "Params",
700 "Partial" ++ root ++ "Params")
702 -- | Compute information about the type of a parameter field.
703 paramFieldTypeInfo :: String -> Field -> Q (Name, Strict, Type)
704 paramFieldTypeInfo field_pfx fd = do
705 t <- actualFieldType fd
706 let n = mkName . (++ "P") . (field_pfx ++) .
708 return (n, NotStrict, AppT (ConT ''Maybe) t)
710 -- | Build a parameter declaration.
712 -- This function builds two different data structures: a /filled/ one,
713 -- in which all fields are required, and a /partial/ one, in which all
714 -- fields are optional. Due to the current record syntax issues, the
715 -- fields need to be named differrently for the two structures, so the
716 -- partial ones get a /P/ suffix.
717 buildParam :: String -> String -> [Field] -> Q [Dec]
718 buildParam sname field_pfx fields = do
719 let (sname_f, sname_p) = paramTypeNames sname
720 name_f = mkName sname_f
721 name_p = mkName sname_p
722 fields_f <- mapM (fieldTypeInfo field_pfx) fields
723 fields_p <- mapM (paramFieldTypeInfo field_pfx) fields
724 let decl_f = RecC name_f fields_f
725 decl_p = RecC name_p fields_p
726 let declF = DataD [] name_f [] [decl_f] [''Show, ''Read, ''Eq]
727 declP = DataD [] name_p [] [decl_p] [''Show, ''Read, ''Eq]
728 ser_decls_f <- buildObjectSerialisation sname_f fields
729 ser_decls_p <- buildPParamSerialisation sname_p fields
730 fill_decls <- fillParam sname field_pfx fields
731 return $ [declF, declP] ++ ser_decls_f ++ ser_decls_p ++ fill_decls
733 buildPParamSerialisation :: String -> [Field] -> Q [Dec]
734 buildPParamSerialisation sname fields = do
735 let name = mkName sname
736 savedecls <- genSaveObject savePParamField sname fields
737 (loadsig, loadfn) <- genLoadObject loadPParamField sname fields
738 shjson <- objectShowJSON sname
739 rdjson <- objectReadJSON sname
740 let instdecl = InstanceD [] (AppT (ConT ''JSON.JSON) (ConT name))
742 return $ savedecls ++ [loadsig, loadfn, instdecl]
744 savePParamField :: Name -> Field -> Q Exp
745 savePParamField fvar field = do
747 let actualVal = mkName "v"
748 normalexpr <- saveObjectField actualVal field
749 -- we have to construct the block here manually, because we can't
751 return $ CaseE (VarE fvar) [ Match (ConP 'Nothing [])
752 (NormalB (ConE '[])) []
753 , Match (ConP 'Just [VarP actualVal])
754 (NormalB normalexpr) []
756 loadPParamField :: Field -> Q (Name, Stmt)
757 loadPParamField field = do
759 let name = fieldName field
761 -- these are used in all patterns below
762 let objvar = varNameE "o"
763 objfield = stringE name
764 loadexp = [| $(varNameE "maybeFromObj") $objvar $objfield |]
765 bexp <- loadFn field loadexp
766 return (fvar, BindS (VarP fvar) bexp)
768 -- | Builds a simple declaration of type @n_x = fromMaybe f_x p_x@.
769 buildFromMaybe :: String -> Q Dec
770 buildFromMaybe fname =
771 valD (varP (mkName $ "n_" ++ fname))
772 (normalB [| $(varNameE "fromMaybe")
773 $(varNameE $ "f_" ++ fname)
774 $(varNameE $ "p_" ++ fname) |]) []
776 fillParam :: String -> String -> [Field] -> Q [Dec]
777 fillParam sname field_pfx fields = do
778 let fnames = map (\fd -> field_pfx ++ fieldRecordName fd) fields
779 (sname_f, sname_p) = paramTypeNames sname
782 name_f = mkName sname_f
783 name_p = mkName sname_p
784 fun_name = mkName $ "fill" ++ sname ++ "Params"
785 le_full = ValD (ConP name_f (map (VarP . mkName . ("f_" ++)) fnames))
786 (NormalB . VarE . mkName $ oname_f) []
787 le_part = ValD (ConP name_p (map (VarP . mkName . ("p_" ++)) fnames))
788 (NormalB . VarE . mkName $ oname_p) []
789 obj_new = foldl (\accu vname -> AppE accu (VarE vname)) (ConE name_f)
790 $ map (mkName . ("n_" ++)) fnames
791 le_new <- mapM buildFromMaybe fnames
792 funt <- [t| $(conT name_f) -> $(conT name_p) -> $(conT name_f) |]
793 let sig = SigD fun_name funt
794 fclause = Clause [VarP (mkName oname_f), VarP (mkName oname_p)]
795 (NormalB $ LetE (le_full:le_part:le_new) obj_new) []
796 fun = FunD fun_name [fclause]