การได้มาทำงานอย่างไรใน Haskell?

พีชคณิตประเภทข้อมูล (ADTs) ใน Haskell จะกลายเป็นกรณีของบางอย่างโดยอัตโนมัติ typeclasse s (เช่นShow,Eq) โดยสืบมาจากพวกเขา

data  Maybe a  =  Nothing | Just a
  deriving (Eq, Ord)

คำถามของฉันคือวิธีการderivingทำงานเช่น Haskell รู้วิธีใช้ฟังก์ชันของคลาสประเภทที่ได้รับสำหรับ ADT ที่ได้รับมาได้อย่างไร

นอกจากนี้เหตุใดจึงderivingจำกัด เฉพาะแว่นตาบางประเภทเท่านั้น เหตุใดฉันจึงไม่สามารถเขียนคลาสประเภทของตัวเองที่สามารถรับมาได้

คำตอบสั้น ๆ คือ :-) มายากล นี่คือการบอกว่าการรับอัตโนมัติถูกรวมเข้ากับข้อมูลจำเพาะของ Haskell และคอมไพเลอร์ทุกตัวสามารถเลือกที่จะใช้งานได้ในแบบของตัวเอง มีงานมากมายเกี่ยวกับวิธีการทำให้ขยายได้

Deriveเป็นเครื่องมือสำหรับ Haskell เพื่อให้คุณเขียนกลไกการได้มาของคุณเอง

GHC เคยจัดเตรียมส่วนขยายคลาสประเภทที่ได้มาซึ่งเรียกว่าGeneric Classesแต่ไม่ค่อยมีการใช้งานเนื่องจากค่อนข้างอ่อนแอ ตอนนี้ได้ถูกนำออกไปแล้วและกำลังดำเนินการอย่างต่อเนื่องในการรวมกลไกการสืบหาข้อมูลทั่วไปใหม่ตามที่อธิบายไว้ในเอกสารนี้: http://www.dreixel.net/research/pdf/gdmh.pdf

สำหรับข้อมูลเพิ่มเติมโปรดดู:

• GHC wiki: http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/GenericDeriving
• Haskell wiki: http://www.haskell.org/haskellwiki/Generics
• การแฮ็ก: http://hackage.haskell.org/package/generic-deriving

จากรายงาน Haskell 98:

คลาสเดียวใน Prelude ที่อนุญาตให้ใช้อินสแตนซ์ที่ได้รับคือ Eq, Ord, Enum, Bounded, Show และ Read ...

นี่คือคำอธิบายวิธีการรับคลาสประเภทเหล่านี้: http://www.haskell.org/onlinereport/derived.html#derived-appendix

เป็นไปได้ที่จะใช้ Template Haskellเพื่อสร้างการประกาศอินสแตนซ์ในลักษณะเดียวกับที่ได้รับอนุประโยค

ตัวอย่างต่อไปนี้ถูกขโมยจากHaskell Wiki อย่างไร้ยางอาย :

ในตัวอย่างนี้เราใช้โค้ด Haskell ต่อไปนี้

$(gen_render ''Body)

เพื่อสร้างอินสแตนซ์ต่อไปนี้:

instance TH_Render Body where
  render (NormalB exp) = build 'normalB exp
  render (GuardedB guards) = build 'guardedB  guards

ฟังก์ชันgen_renderข้างต้นกำหนดไว้ดังนี้ (โปรดทราบว่ารหัสนี้ต้องอยู่ในโมดูลแยกต่างหากจากการใช้งานข้างต้น)

-- Generate an intance of the class TH_Render for the type typName
gen_render :: Name -> Q [Dec]
gen_render typName =
  do (TyConI d) <- reify typName -- Get all the information on the type
     (type_name,_,_,constructors) <- typeInfo (return d) -- extract name and constructors                  
     i_dec <- gen_instance (mkName "TH_Render") (conT type_name) constructors
                      -- generation function for method "render"
                      [(mkName "render", gen_render)]
     return [i_dec]  -- return the instance declaration
             -- function to generation the function body for a particular function
             -- and constructor
       where gen_render (conName, components) vars 
                 -- function name is based on constructor name  
               = let funcName = makeName $ unCapalize $ nameBase conName 
                 -- choose the correct builder function
                     headFunc = case vars of
                                     [] -> "func_out"
                                     otherwise -> "build" 
                      -- build 'funcName parm1 parm2 parm3 ...
                   in appsE $ (varE $ mkName headFunc):funcName:vars -- put it all together
             -- equivalent to 'funcStr where funcStr CONTAINS the name to be returned
             makeName funcStr = (appE (varE (mkName "mkName")) (litE $ StringL funcStr))

ซึ่งใช้ฟังก์ชันและประเภทต่อไปนี้

คำพ้องความหมายบางประเภทก่อนอื่นเพื่อให้โค้ดอ่านง่ายขึ้น

type Constructor = (Name, [(Maybe Name, Type)]) -- the list of constructors
type Cons_vars = [ExpQ] -- A list of variables that bind in the constructor
type Function_body = ExpQ 
type Gen_func = Constructor -> Cons_vars -> Function_body
type Func_name = Name   -- The name of the instance function we will be creating
-- For each function in the instance we provide a generator function
-- to generate the function body (the body is generated for each constructor)
type Funcs = [(Func_name, Gen_func)]

ฟังก์ชันหลักที่ใช้ซ้ำได้ เราส่งผ่านรายการฟังก์ชันเพื่อสร้างฟังก์ชันของอินสแตนซ์

-- construct an instance of class class_name for type for_type
-- funcs is a list of instance method names with a corresponding
-- function to build the method body
gen_instance :: Name -> TypeQ -> [Constructor] -> Funcs -> DecQ
gen_instance class_name for_type constructors funcs = 
  instanceD (cxt [])
    (appT (conT class_name) for_type)
    (map func_def funcs) 
      where func_def (func_name, gen_func) 
                = funD func_name -- method name
                  -- generate function body for each constructor
                  (map (gen_clause gen_func) constructors)

ฟังก์ชันตัวช่วยดังกล่าวข้างต้น

-- Generate the pattern match and function body for a given method and
-- a given constructor. func_body is a function that generations the
-- function body
gen_clause :: (Constructor -> [ExpQ] -> ExpQ) -> Constructor -> ClauseQ
gen_clause func_body data_con@(con_name, components) = 
      -- create a parameter for each component of the constructor
   do vars <- mapM var components
      -- function (unnamed) that pattern matches the constructor 
      -- mapping each component to a value.
      (clause [(conP con_name (map varP vars))]
            (normalB (func_body data_con (map varE vars))) [])
       -- create a unique name for each component. 
       where var (_, typ) 
                 = newName 
                   $ case typ of 
                     (ConT name) -> toL $ nameBase name
                     otherwise   -> "parm"
               where toL (x:y) = (toLower x):y

unCapalize :: [Char] -> [Char]
unCapalize (x:y) = (toLower x):y

และรหัสผู้ช่วยที่ยืมมาจาก Syb III / replib 0.2

typeInfo :: DecQ -> Q (Name, [Name], [(Name, Int)], [(Name, [(Maybe Name, Type)])])
typeInfo m =
     do d <- m
        case d of
           d@(DataD _ _ _ _ _) ->
            return $ (simpleName $ name d, paramsA d, consA d, termsA d)
           d@(NewtypeD _ _ _ _ _) ->
            return $ (simpleName $ name d, paramsA d, consA d, termsA d)
           _ -> error ("derive: not a data type declaration: " ++ show d)

     where
        consA (DataD _ _ _ cs _)    = map conA cs
        consA (NewtypeD _ _ _ c _)  = [ conA c ]

        {- This part no longer works on 7.6.3
        paramsA (DataD _ _ ps _ _) = ps
        paramsA (NewtypeD _ _ ps _ _) = ps
        -}

        -- Use this on more recent GHC rather than the above
        paramsA (DataD _ _ ps _ _) = map nameFromTyVar ps
        paramsA (NewtypeD _ _ ps _ _) = map nameFromTyVar ps

        nameFromTyVar (PlainTV a) = a
        nameFromTyVar (KindedTV a _) = a


        termsA (DataD _ _ _ cs _) = map termA cs
        termsA (NewtypeD _ _ _ c _) = [ termA c ]

        termA (NormalC c xs)        = (c, map (\x -> (Nothing, snd x)) xs)
        termA (RecC c xs)           = (c, map (\(n, _, t) -> (Just $ simpleName n, t)) xs)
        termA (InfixC t1 c t2)      = (c, [(Nothing, snd t1), (Nothing, snd t2)])

        conA (NormalC c xs)         = (simpleName c, length xs)
        conA (RecC c xs)            = (simpleName c, length xs)
        conA (InfixC _ c _)         = (simpleName c, 2)

        name (DataD _ n _ _ _)      = n
        name (NewtypeD _ n _ _ _)   = n
        name d                      = error $ show d

simpleName :: Name -> Name
simpleName nm =
   let s = nameBase nm
   in case dropWhile (/=':') s of
        []          -> mkName s
        _:[]        -> mkName s
        _:t         -> mkName t