5

看这个问题的答案：

https://stackoverflow.com/a/34164251/1052117

我看到它定义了一种用于解析 JSON 对象的数据类型。

data Address = Address
    { house  :: Integer
    , street :: String
    , city   :: String
    , state  :: Maybe String
    , zip    :: String -- here I change the original, zip codes are strings, they have leading zeros.
    } deriving (Show, Eq)

$(deriveJSON defaultOptions ''Address)

这很有帮助，但我想知道：如何更改地址数据类型以使所有 json 字段都可以为空？具体来说，我在 state 字段之前看到了一个 Maybe，但我在想象一个更大的数据结构，在其中将所有字段修改为 Maybe 字段会很乏味。例如，虽然我 / 可以 / 将上面重写为：

data Address = Address
    { house  :: Maybe Integer
    , street :: Maybe String
    , city   :: Maybe String
    , state  :: Maybe String
    , zip    :: Maybe String
    } deriving (Show, Eq)

我可以对地址数据类型 /in code/ 应用什么函数来实现相同的结果，而无需重写所有代码并手动插入 Maybes？

4

2 回答 2

5

正如评论中所讨论的，使用 functor-functor 只需对原始数据类型进行非常小的更改即可。

如果你开始

data Address = Address
    { house  :: Integer
    , street :: String
    , city   :: String
    , state  :: Maybe String
    , zip    :: String
    } deriving (Show, Eq)

那么它相当于

import Data.Functor.Identity

data AddressF f = Address
  { house  :: f Integer 
  , street :: f String
  , city   :: f String
  , state  :: Maybe String
  , zip    :: f String 
  } deriving (Show, Eq)

type Address = AddressF Identity

然后你可以通过写得到第二个

type Address' = AddressF Maybe

要回到原来的定义，你可以写

toOriginal (AddressF (Identity house) (Identity street) (Identity city) mbState (Identity zip)) = Address house street city mbState zip
于 2018-12-27T09:38:39.983 回答
2

无需重写所有代码并手动插入 Maybes 即可获得相同的结果

为了避免对记录类型的侵入性更改，我们可以通过分析其结构来处理从记录派生的另一种类型，这需要相对高级的泛型和类型级编程。这个答案使用generics-sop包。

一些必需的编译指示和导入：

{-# LANGUAGE DataKinds, TypeFamilies, FlexibleInstances, UndecidableInstances, 
             ScopedTypeVariables, TypeApplications, TypeOperators, 
             DeriveGeneric, StandaloneDeriving, MultiParamTypeClasses,
             FunctionalDependencies, AllowAmbiguousTypes, FlexibleContexts #-}
import           Data.Kind (Type)
import           Data.Type.Equality (type (==))
import           GHC.TypeLits
import qualified GHC.Generics as GHC
import           Generics.SOP -- from package "generics-sop"
import qualified Generics.SOP.Type.Metadata as M

这种新类型表示从记录派生的字段值的n 元乘积f，每个值都包装在一个仿函数中。ns字段名称的类型级别列表保存为幻像类型变量：

newtype Wrapped f (ns :: [Symbol]) (xs :: [Type]) = Wrapped { unwrap :: NP f xs }

deriving instance All (Generics.SOP.Compose Show f) xs => Show (Wrapped f ns xs)

type family FieldNamesOf (a :: M.DatatypeInfo) :: [Symbol] where
    FieldNamesOf ('M.ADT moduleName datatypeName '[ 'M.Record constructorName fields ]) = 
        ExtractFieldNames fields

type family ExtractFieldNames (a :: [M.FieldInfo]) :: [Symbol] where
    ExtractFieldNames '[] = '[]
    ExtractFieldNames (('M.FieldInfo n) ': xs) = n ': ExtractFieldNames xs

fromRecord :: forall r ns xs.  (IsProductType r xs, 
                                HasDatatypeInfo r, 
                                FieldNamesOf (DatatypeInfoOf r) ~ ns)
           => r 
           -> Wrapped I ns xs 
fromRecord r = let (SOP (Z np)) = from r in Wrapped np

toRecord :: forall r ns xs.  (IsProductType r xs, 
                              HasDatatypeInfo r, 
                              FieldNamesOf (DatatypeInfoOf r) ~ ns)
         => Wrapped I ns xs 
         -> r
toRecord (Wrapped np) = to (SOP (Z np))

如果我们不需要保留字段名称，那么 newtype 就变得多余了，最好直接使用 n 元乘积NP ，使用generics-sop 提供的丰富函数集来操作它。

但是如果我们确实想保持按名称选择字段的能力，那么我们需要在 newtype 上定义一个函数，由一对 typeclasses 支持：

getWrappedField :: forall n f ns xs x. HasField ns n xs x => Wrapped f ns xs -> f x
getWrappedField (Wrapped np) = getHasField @ns @n np  

class HasField (ns :: [Symbol]) (n :: Symbol) 
               (xs :: [Type])   (x :: Type)   | ns n xs -> x where 
    getHasField :: NP f xs -> f x 

instance ((e == n) ~ flag, HasField' flag (e : ns) n xs x) => HasField (e : ns) n xs x where
    getHasField = getHasField' @flag @(e : ns) @n

class HasField' (flag :: Bool) 
                (ns :: [Symbol]) (n :: Symbol) 
                (xs :: [Type]) (x :: Type)     | ns n xs -> x where 
    getHasField' :: NP f xs -> f x 

instance HasField' True (n : ns) n (x : xs) x where
    getHasField' (v :* _) = v

instance HasField ns n xs x => HasField' False (nz : ns) n (xz : xs) x where
    getHasField' (_ :* rest) = getHasField @ns @n rest

鉴于此示例记录派生了必要的 支持 类型类：

data Person = Person { name :: String, age :: Int } deriving (Show, GHC.Generic)
instance Generic Person
instance HasDatatypeInfo Person

我们可以构造它的广义表示（所有字段最初都包含在恒等函子I中），然后获取其中一个字段，如下所示：

ghci> getWrappedField @"age" (fromRecord (Person "Jimmy" 25))
I 25

字段的名称作为类型级别传递Symbol，使用类型 application。

于 2018-12-28T21:44:39.037 回答