Haskell记录更新

Question

I would like to update a record with external (streams of) name/value pairs. The record's fields have different types.

That's how I did it, is there a more elegant Haskell way to do this?

data MyRec = MyRec {field1 :: String, field2 :: Int, field3 :: Bool} deriving Show
defRec = MyRec {field1 = "", field2 = 0, field3 = False}

singleUpdate :: String -> MyRec -> MyRec  -> MyRec
singleUpdate "field1" urec rec = rec {field1 = field1 urec}
singleUpdate "field2" urec rec = rec {field2 = field2 urec}
singleUpdate "field3" urec rec = rec {field3 = field3 urec}
singleUpdate _ _ rec = rec

update :: [(String, MyRec)] -> MyRec -> MyRec
update flds rec = foldl (flip (uncurry singleUpdate)) rec flds

nameVals = [("field1",defRec {field1 = "foo"}), ("field3",defRec {field3 = True})]
updtdRec   = update nameVals defRec

updtdRec returns MyRec {field1 = "foo", field2 = 0, field3 = True}

Is there a more compact way, closer to something like this : update field val = MyRec {field = val} (this is just pseudo-code), which works for all fields, without having to specify the function implementation for each field?

Answer 1

As Sibi comments, what you want is lens. It provides a powerful way of manipulating data types.

Example:

{-# LANGUAGE TemplateHaskell #-}
import Control.Lens

data MyRec = MyRec { _field1 :: String, _field2 :: Int, _field3 :: Bool } 
             deriving(Show)
makeLenses ''MyRec

main :: IO ()
main = do
  let myrec    = MyRec { _field1 = "", _field2 = 0, _field3 = False }
      myrec'   = myrec & field1 .~ "updated"
      myrec''  = myrec' & field2 .~ 1
      myrec''' = myrec'' & field3 .~ True
  print myrec    -- MyRec {_field1 = "", _field2 = 0, _field3 = False}
  print myrec'   -- MyRec {_field1 = "updated", _field2 = 0, _field3 = False}
  print myrec''  -- MyRec {_field1 = "updated", _field2 = 1, _field3 = False}
  print myrec''' -- MyRec {_field1 = "updated", _field2 = 1, _field3 = True}

You can write a function like update field val = MyRec {field = val} .

update :: MyRec -> ASetter MyRec MyRec t t -> t -> MyRec
update record field val = record & field .~ val

> update defRec field1 "updated"
MyRec {_field1 = "updated", _field2 = 0, _field3 = False}

These are very compact, but tuples of a lense and a corresponding value have different types. For example, (field1, "updated") and (field2, 1) have different types, so it is difficult to write a list for updating.

The link below will help you get started with lens.

https://hackage.haskell.org/package/lens-tutorial-1.0.0/docs/Control-Lens-Tutorial.html

Answer 2

Every update is just a function of type MyRec -> MyRec .

Your code becomes:

data MyRec = MyRec {field1 :: String, field2 :: Int, field3 :: Bool} deriving Show
defRec = MyRec {field1 = "", field2 = 0, field3 = False}

update :: [MyRec -> MyRec] -> MyRec -> MyRec
update flds rec = foldl' (flip ($)) rec flds

nameVals = [(\ r -> r { field1 = "foo" }), (\ r -> r { field3 = True })]
updtdRec = update nameVals defRec

Answer 3

You can do it with TemplateHaskell. Here's one way to do it:

File MyTH2.hs:

module MyTH2 where

import Language.Haskell.TH
import Data.List

mkUpdaterForRecordType :: String -> Name -> Q [Dec]
mkUpdaterForRecordType fname tyname = do
  i <- reify tyname
  let cs = case i of
            TyConI (DataD _ _ _ cs _) -> cs
            _                         -> []
      ls = [ l | (RecC _ ls) <- cs, l <- ls ]
      ns = [ nameBase n  | (n, _, _) <- ls ]
  mkUpdater fname ns

mkUpdater :: String -> [String] -> Q [Dec]
mkUpdater fname names = do
  let clauses = map mkClause names
      varb = mkName "b"
      clause0 = Clause [ WildP, WildP, (VarP varb) ] (NormalB $ VarE varb) []
      decl1 = FunD (mkName fname) (clauses ++ [clause0])
  return [decl1]

mkClause :: String -> Clause
mkClause fldname = 
  let vara = mkName "a"
      varb = mkName "b"
      varf = mkName fldname
      pats = [ LitP (StringL fldname) , VarP vara, VarP varb ]
      body = NormalB $ RecUpdE (VarE varb) [ (varf, AppE (VarE varf) (VarE vara)) ]
      clause = Clause pats body []
  in clause

File Main.hs:

{-# LANGUAGE TemplateHaskell #-}

import MyTH2

data MyRec = MyRec {field1 :: String, field2 :: Int, field3 :: Bool} deriving Show

old1 = MyRec "old1" 1 False
new2 = MyRec "new2" 2 True

$(mkUpdaterForRecordType "update" ''MyRec)

test1 = update "field1" new2 old1
test2 = update "field2" new2 old1
test3 = update "field3" new2 old1
test4 = update "other" new2 old1   -- no update performed

Note that the Template Haskell has to be in its own module.