有在短短的哈斯克尔平台众多重叠的单独模块（几个泛型库syb ， Data.Typeable ， Data.Data ， GHC.Generics ），但我有一个非常基本的通用编程任务的麻烦。
我希望能够类型相同的形状之间的转换，也就是我想同构型之间的多态，类型转换功能，基本上就是在年底提供的文章 ，其中索引类型系列被提及（PDF）。
我不关心我再杀样板，而是以能够围绕打造和与积抽象新库。
下面的问题是，在以下方面GHC.Generic我认为是最接近我所需要的，但其他的解决方案是受欢迎的。
以下两种类型具有相同的形状
data Pair = Pair Char Int deriving (Generic, Show)
data Pair2 = Pair2 Char Int deriving (Generic, Show)
我想用GHC.Generics它们之间转换数值。 下面失败，因为所有的幻影参数和其他的废话来进行类型检查：
f :: Pair -> Pair2
f = to . from
最后，我想类似的功能fromInteger这对任何一个多态的返回值Generic （或任何其他类可以支持此）实例。 我想我正在寻找类似GHC.Generics ：
--class:
type family NormalForm a
class ToGeneric a where
to :: a -> NormalForm a
class FromGeneric b where
from :: NormalForm b -> b
--examples:
data A = A Char Int deriving Show
data B = B Char Int deriving Show
type instance NormalForm A = (Char,Int)
instance ToGeneric A where
to (A a b) = (a,b)
instance FromGeneric A where
from (a,b) = A a b
type instance NormalForm B = (Char,Int)
instance ToGeneric B where
to (B a b) = (a,b)
instance FromGeneric B where
from (a,b) = B a b
-- the function I'm looking for
coerce :: (ToGeneric a, FromGeneric b, NormalForm a ~ NormalForm b)=> a -> b
coerce = from . to
通过以上我们可以做我想要的一切：
*Main> (coerce $A 'a' 1) :: B
B 'a' 1
*Main> (coerce $A 'a' 1) :: A
A 'a' 1
编辑：这是内森豪威尔的如何f功能似乎以下工作，其实。
问题
这是可以做到与图书馆目前在Haskell的平台？
如果不是这样，可能一个库被定义为利用现有的deriving的机制Generic ， Data等，而不诉诸TH？
如果“的相同的形状”指的是数据类型是等于高达构造名称，记录选择和类型的同义词然后数据类型转换是作为遍历表示一样简单。
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts, FlexibleInstances #-}
import GHC.Generics
conv
:: (Generic a, Generic b, Conv (Rep a) (Rep b))
=> a -> b
conv = to . cv . from
class Conv a b where
cv :: a x -> b x
-- skip irrelevant parts: datatype name, constructor name, selector
instance Conv f1 f2 => Conv (M1 i1 c1 f1) (M1 i2 c2 f2) where
cv = M1 . cv . unM1
instance (Conv a1 a2, Conv b1 b2) => Conv (a1 :*: b1) (a2 :*: b2) where
cv ~(a :*: b) = cv a :*: cv b
instance (Conv a1 a2, Conv b1 b2) => Conv (a1 :+: b1) (a2 :+: b2) where
cv (L1 a) = L1 $ cv a
cv (R1 b) = R1 $ cv b
-- copy values
instance Conv U1 U1 where cv = id
instance Conv (K1 R c) (K1 R c) where cv = id
测试用例：
data A = A1 String Int | A2 (Int,Int) deriving (Generic, Show)
data B = B1 [Char] Int | B2 { xy :: (Int,Int) } deriving (Generic, Show)
data X = X Int Int deriving (Generic, Show)
*Main> conv $ X 3 14 :: (Int,Int)
(3,14)
*Main> conv $ A1 "hello" 42 :: B
B1 "hello" 42
*Main> conv $ A2 (13,42) :: B
B2 {xy = (13,42)}
更新
一些更多的情况下，让更多的有趣的转换：
instance Conv U1 (M1 S s (K1 R ())) where
cv _ = M1 $ K1 ()
-- *> conv (Nothing :: Maybe Int) :: Either () Int
-- Left ()
instance Conv (M1 S s (K1 R ())) U1 where
cv _ = U1
-- *> conv (Left () :: Either () Int) :: Maybe Int
-- Nothing
-- this one requires OverlappingInstances
instance (Generic c1, Generic c2, Conv (Rep c1) (Rep c2))
=> Conv (K1 R c1) (K1 R c2)
where
cv (K1 x) = K1 $ conv x
-- *> conv (Right Nothing :: Either () (Maybe Int)) :: Maybe (Either () Int)
-- Just (Left ())
-- data List a = Empty | Cons a (List a) deriving (Generic, Show)
-- *> conv [1,2,3::Int] :: List Int
-- Cons 1 (Cons 2 (Cons 3 Empty))
这是可能的，而且比较痛苦。 与使用unsafeCoerce直接，即使你的类型不排队拿到的版本是否中断。 你也许可以依靠对等式约束f提供足够的编译时类型安全使用unsafeCoerce ，并避免与工作Rep家庭。
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeFamilies #-}
import GHC.Generics
data Pair1 = Pair1 Char Int deriving (Generic, Show)
data Pair2 = Pair2 Char Int deriving (Generic, Show)
data Triple1 = Triple1 Char Int Double deriving (Generic, Show)
data Triple2 = Triple2 Char Int Double deriving (Generic, Show)
f :: (Generic a, Generic c, Rep a ~ D1 da (C1 ca f), Rep c ~ D1 db (C1 cb f))
=> a -> c
f = to . M1 . M1 . unM1 . unM1 . from
-- this might also be acceptable:
-- f = unsafeCoerce
p1 :: Pair1 -> Pair2
p1 = f
p2 :: Pair2 -> Pair1
p2 = f
t1 :: Triple1 -> Triple2
t1 = f
t2 :: Triple2 -> Triple1
t2 = f
运行它产生预期的结果：
*Main> p1 $ Pair1 'x' 1
Pair2 'x' 1
*Main> p2 $ Pair2 'x' 1
Pair1 'x' 1
*Main> t1 $ Triple1 'y' 2 3.0
Triple2 'y' 2 3.0
*Main> t2 $ Triple2 'y' 2 3.0
Triple1 'y' 2 3.0
