5

我想Type Class用几个默认方法实现 a ，但我得到一个错误，我不能record selectors在内部type classes定义中使用。

下面的代码基本上创建了type classwhich 定义函数，它应该向some 的记录中add添加一个元素。这是代码：reprdata type

import qualified Data.Graph.Inductive     as DG

class Graph gr a b where
    empty :: DG.Gr a b
    empty = DG.empty

    repr :: gr -> DG.Gr a b

    -- following function declaration does NOT work:
    add :: a -> gr -> gr
    add el g = g{repr = DG.insNode el $ repr g}

编译器抛出错误：

repr is not a record selector
In the expression: g {repr = DG.insNode el $ repr g}
In an equation for add:
    add el g = g {repr = DG.insNode el $ repr g}

是否可以在 Haskell 中声明此类方法？

澄清

我需要这样的设计，因为我有一些data types，它们的行为方式相似。可以说，我们得到A和。他们每个人都应该有一个记录，每个人在哪里和是不同的，和。BC data typesrepr :: DG.Gr a babABC

A,B并C共享相同的功能，例如addor delete（基本上添加或删除元素到记录repr）。type class如果这些数据类型共享很多函数，那么在其中实现这些函数并创建实例是有意义的type class——这些函数将为我们的每个函数data type自动实现。

另外，我希望其中一些data types（假设我想要B）在调用add函数时表现得略有不同。instance在制作type classfor时很容易实现这种行为B。

4

2 回答 2

3

  1. 记录更新语法

     <record-instance> { <record-field-name> = ..., ... }

    当<record-instance>是已知代数数据类型的实例/术语时起作用（因此它<record-field-name>是已知字段），在您的代码中它只是一些（临时）多态参数gr，因此您需要首先转换gr为Gr，然后更新它，并且然后...

  2. 我认为，gr并且Gr在某种意义上应该是等价的，也就是说，我们需要一个反函数repr来iface实现add。

这是一个例子：

{-# LANGUAGE MultiParamTypeClasses, TypeSynonymInstances, FlexibleInstances #-}

data Gr a b = Gr { _internal :: [(a, b)] } deriving ( Show, Read )

class Graph gr a b where

  repr :: gr -> Gr a b
  iface :: Gr a b -> gr

  -- iface . repr == id {gr}
  -- repr . iface == id {Gr a b}

  -- add element via "interface" (get a representation via @repr@, update it, and then 
  -- return an interface back with @iface@)
  add :: (a, b) -> gr -> gr
  add el g = let r = repr g in iface r { _internal = el : _internal r }
  -- or
  add el = iface . insNode el . repr where
    insNode x (Gr xs) = Gr (x : xs) -- or whatever

instance Graph String Int Int where
  repr = read
  iface = show

test :: String
test = add (1 :: Int, 2 :: Int) "Gr { _internal = [] }"
-- test => "Gr {_internal = [(1,2)]}"

如果某些数据类型A和B 聚合 Gr a b（这样我们就不能为 写逆repr），那么我们可以这样做：

{-# LANGUAGE MultiParamTypeClasses #-}

data Gr a b = Gr [(a, b)] deriving ( Show )

class Graph gr a b where

  repr :: gr -> Gr a b

  update :: gr -> (Gr a b -> Gr a b) -> gr
  -- 2: update :: gr -> Gr a b -> gr

  add :: (a, b) -> gr -> gr
  add el g = update g $ insNode el
    -- 2: update g (insNode el $ repr g)
    where insNode x (Gr xs) = Gr (x : xs)

data A = A { _aRepr :: Gr Char Char, _aRest :: Char } deriving ( Show )
data B = B { _bRepr :: Gr Int Int, _bRest :: Int } deriving ( Show )

instance Graph A Char Char where
  repr = _aRepr
  update r f = r { _aRepr = f $ _aRepr r }
  -- 2: update r g = r { _aRepr = g }

instance Graph B Int Int where
  repr = _bRepr
  update r f = r { _bRepr = f $ _bRepr r }
  -- 2: update r g = r { _bRepr = g }

testA :: A
testA = add ('1', '2') $ A (Gr []) '0'
-- => A {_aRepr = Gr [('1','2')], _aRest = '0'}

testB :: B
testB = add (1 :: Int, 2 :: Int) $ B (Gr []) 0
-- => B {_bRepr = Gr [(1,2)], _bRest = 0}

也可以在这里使用镜头：

{-# LANGUAGE MultiParamTypeClasses, TemplateHaskell #-}

import Control.Lens

data Gr a b = Gr [(a, b)] deriving ( Show )

insNode :: (a, b) -> Gr a b -> Gr a b
insNode x (Gr xs) = Gr (x : xs)

class Graph gr a b where
  reprLens :: Simple Lens gr (Gr a b)

add :: Graph gr a b => (a, b) -> gr -> gr
add el = reprLens %~ insNode el

data A = A { _aRepr :: Gr Char Char, _aRest :: Char } deriving ( Show )
data B = B { _bRepr :: Gr Int Int, _bRest :: Int } deriving ( Show )

makeLenses ''A
makeLenses ''B

instance Graph A Char Char where
  reprLens = aRepr

instance Graph B Int Int where
  reprLens = bRepr

main :: IO ()
main = do
  let a = A (Gr []) '0'
      b = B (Gr []) 0
  print $ add ('0', '1') a
  print $ add (0 :: Int, 1 :: Int) b
-- A {_aRepr = Gr [('0','1')], _aRest = '0'}
-- B {_bRepr = Gr [(0,1)], _bRest = 0}
于 2013-07-20T15:36:03.033 回答
0

您可以尝试这样的事情（它使用元组列表作为示例而不是DG）

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, TypeSynonymInstances #-}

class MyClass g a b | g -> a b where
      extract :: g -> [(a,b)]
      construct :: [(a,b)] -> g 

      empty :: g
      empty = construct []

      add :: (a,b) -> g  -> g
      add i d = construct $  [i] ++ (extract d) 

data A  = A {reprA :: [(Int,Int)]}

instance MyClass A Int Int  where
         extract = reprA
         construct = A

data B  = B {reprB :: [(String,String)]}

instance MyClass B String String  where
         extract = reprB
         construct = B
于 2013-07-20T16:47:31.177 回答