क्या डेटा को लागू करना संभव है। प्रतिबिंब की बजाय प्रकार परिवारों का उपयोग करके प्रतिबिंब की चाल?

Question

पैकेज से Data.Reflection का जीएचसी कार्यान्वयन unsafeCoerce से युक्त एक चाल का उपयोग करता है जो जीएचसी संकलित शब्दकोश का उपयोग कर टाइपक्लास को संकलित करता है। कार्यान्वयन कम है, इसलिए मैं यहाँ अपनी संपूर्णता में यह पुन: पेश कर सकते हैं:

ghci> reify (42 :: Integer) (\p -> reflect p) :: Integer 
42 

मैं दिलचस्पी थी:

class Reifies s a | s -> a where 
    reflect :: proxy s -> a 

newtype Magic a r = Magic (forall (s :: *). Reifies s a => Proxy s -> r) 

reify :: forall a r. a -> (forall (s :: *). Reifies s a => Proxy s -> r) -> r 
reify a k = unsafeCoerce (Magic k :: Magic a r) (const a) Proxy 

यह यह संभव प्रकार के स्तर पर एक मूल्य वस्तु के बारे में जैसे सोचना है, तो इसे वापस को प्रतिबिंबित करता है इस तकनीक का उपयोग करने में, लेकिन मैंने सोचा कि मेरे उद्देश्यों के लिए एक कार्यात्मक निर्भरता के बजाय Reifies के साथ एक प्रकार के परिवार का उपयोग करना सुविधाजनक होगा, इसलिए मैंने सामान्य परिवर्तन का उपयोग करके कार्यान्वयन को फिर से लिखने का प्रयास किया:

class Reifies s where 
    type Reflects s 
    reflect :: Proxy s -> Reflects s 

newtype Magic a r = Magic (forall (s :: *). (Reifies s, Reflects s ~ a) => Proxy s -> r) 

reify :: forall a r. a -> (forall (s :: *). (Reifies s, Reflects s ~ a) => Proxy s -> r) -> r 
reify a k = unsafeCoerce (Magic k :: Magic a r) (const a) Proxy 

अफसोस की बात है, हालांकि, यह अब काम नहीं करता है! यह unsafeCoerce चाल को तोड़ने के लिए काफी पर्याप्त संकलन परिवर्तन:

ghci> reify (42 :: Integer) (\p -> reflect p) :: Integer 
2199023255808 

हालांकि, मैं कैसे GHC क्यों समझने के लिए काम करता है के साथ पर्याप्त परिचित नहीं हूँ। क्या कार्यात्मक निर्भरता के बजाय संबंधित प्रकार का उपयोग कर Data.Reflection को कार्यान्वित करना संभव है? यदि हां, तो क्या बदलने की जरूरत है? यदि नहीं, तो क्यों नहीं?

Answer 1

unsafeCoerce चाल

a -> Proxy s -> r 

के रूप में तथ्य यह है कि

Reifies s a => Proxy s -> r 

रन-टाइम में बिल्कुल वैसा ही प्रतिनिधित्व, है का लाभ लेता है, (Reifies s a, a ~ Reflects s) को बाधा के विस्तार करके, आप इस महत्वपूर्ण का उल्लंघन कल्पना। इसे ठीक करने के कई तरीके हैं। यहाँ एक है:

{-# language MultiParamTypeClasses, TypeFamilies, PolyKinds, KindSignatures, 
     RankNTypes, ScopedTypeVariables, TypeOperators #-} 
module TFReifies where 
import Data.Proxy 
import Unsafe.Coerce 
import Data.Type.Equality 

class Reifies s a where 
    type Reflects s :: * 
    reflect' :: proxy s -> a 

reflect :: (Reifies s a, a ~ Reflects s) => proxy s -> a 
reflect = reflect' 


newtype Magic a r = Magic (forall (s :: *). (Reifies s a) => Proxy s -> r) 

reify' :: forall a r. a -> (forall (s :: *). (Reifies s a) => Proxy s -> r) -> r 
reify' a k = unsafeCoerce (Magic k :: Magic a r) (const a) Proxy 

reify :: forall a r. a -> (forall (s :: *). (Reifies s a, a ~ Reflects s) => Proxy s -> r) -> r 
reify a f = reify' a (\(p :: Proxy s) -> case unsafeCoerce Refl :: a :~: Reflects s of Refl -> f p) 

---

यहाँ एक संस्करण तुम्हारा के करीब है:

class Reifies s where 
    type Reflects s :: * 
    reflect :: proxy s -> Reflects s 

newtype Magic a r = Magic (forall (s :: *). (Reifies s) => Proxy s -> r) 

reify :: forall a r. a -> (forall (s :: *). (Reifies s, a ~ Reflects s) => Proxy s -> r) -> r 
reify a f = reify' a (\(p :: Proxy s) -> case unsafeCoerce Refl :: a :~: Reflects s of Refl -> f p) 
    where 
    -- This function is totally bogus in other contexts, so we hide it. 
    reify' :: forall a r. a -> (forall (s :: *). (Reifies s) => Proxy s -> r) -> r 
    reify' a k = unsafeCoerce (Magic k :: Magic a r) (const a) Proxy