रैंकेंटिप्स का उपयोग करने वाले इस मज़ेदार का नाम क्या है?

Question

objective पैकेज के आसपास खेलने के दौरान, मैंने देखा कि निम्नलिखित प्रकार की रोचक संपत्ति है।

> {-# LANGUAGE RankNTypes #-} 
> data N f r = N { unN :: forall x. f x -> (x, r) } 

यह एक फ़ैक्टर है।

> instance Functor (N f) where 
> fmap f (N nat) = N $ fmap (fmap f) nat 
>   -- or, = N $ \fx -> let { (x,a) = nat fx } in (x, f a) 

गूगल/hoogle के कुछ ही घंटों के बाद, मैं किसी भी मौजूदा मॉड्यूल है कि इस प्रकार के शामिल पाने के छोड़ दिया। इस प्रकार क्या है? यदि यह अच्छी तरह से जाना जाता है, तो नाम क्या है? क्या यह उपयोगी या अनदेखा है क्योंकि बेकार?

यह मेरी 100% मूल रचना नहीं है, क्योंकि एन उद्देश्य पैकेज में पाए गए ऑब्जेक्ट से लिया गया था।

> data Object f g = Object { 
>  runObject :: forall x. f x -> g (x, Object f g) 
> } 

N f एक functor जो Object f Identity पैदावार जब फिक्स करने के लिए लागू किया जाता है।

---

इस प्रकार के बारे में एक तथ्य है और मैंने क्यों सोचा कि यह दिलचस्प है।

एन रीडर को राइटर में परिवर्तित करता है, इसके विपरीत।

N ((->) e) r 
= forall x. (e -> x) -> (x, r) 
= (e, r) 

N ((,) d) r 
= forall x. (d, x) -> (x, r) 
= d -> r 

एन स्टोर राज्य इकाई को comonad बदलता है, लेकिन उलटा सच नहीं है (यहाँ मैं (=) प्रकार के बीच समाकृतिकता के लिए प्रतीक का इस्तेमाल किया)।

> data Store s a = Store s (s -> a) 
> type State s a = s -> (s, a) 

N (Store s) r 
= forall x. (s, (s -> x)) -> (x, r) 
= forall x. s -> (s -> x) -> (x, r) 
= s -> (s, r) 
= State s r 

N (State s) r 
= forall x. (s -> (s, x)) -> (x, r) 
= forall x. (s -> s, s -> x) -> (x, r) 
= forall x. (s -> s) -> (s -> x) -> (x, r) 
= (s -> s) -> (s, r) -- ??? 

एन शायद नहीं ले सकता है।

N Maybe r 
= forall x. Maybe x -> (x, r) 
= forall x. (() -> (x, r), x -> (x, r)) 
= Void  -- because (() -> (x, r)) can't be implemented 

निम्नलिखित कार्य मजेदार हो सकता है। मैं इसे उलटा नहीं कर सका।

> data Cofree f a = Cofree a (f (Cofree f a)) 
> data Free f a = Pure a | Wrap (f (Free f a)) 

> unfree :: Free (N f) r -> N (Cofree f) r 
> unfree (Pure r) = N $ \(Cofree a _) -> (a, r) 
> unfree (Wrap n_f) = N $ 
> \(Cofree _ f) -> let (cofree', free') = unN n_f f 
>     in unN (unfree free') cofree' 

संपूर्ण पोस्ट साक्षर हैस्केल (.lhs) है।

Answer 1

मैं इसे "हैंडलर" मजेदार कहता हूं। उद्देश्य जारी किए जाने से पहले Object को हैंडलर फ़ैक्टर का उपयोग करके परिभाषित किया जाता था।

हाँ, यह मजेदार दिलचस्प है - Cofree (Handler f) में सार्वजनिक गेटर है और Free (Handler f) एक mortal object है। शायद मुझे हैंडलर मज़ेदार भेजना चाहिए था ...

Answer 2

हालांकि यह पहले से ही उत्तर दिया गया है, मुझे अपने आप से सवाल का एक और जवाब मिला।

टाइप N निम्न लेखों में वर्णित प्रकार श्रेणी Pairing का मान-स्तर प्रतिनिधित्व था।

Free for DSLs, cofree for interpreters

Cofree Comonads and the Expression Problem (कतरन दोहरी यहाँ कहा जाता है)

युग्मित कर रहा है और N ही बातें

युग्मित कर रहा है की परिभाषा यह है कर रहे हैं।

> class Pairing f g where 
> pair :: (a -> b -> c) -> f a -> g b -> c 

f और N f युग्मित कर रहा है।

> instance Pairing f (N f) where 
> pair k fa nb = uncurry k $ unN nb fa 

N को जोड़े के संदर्भ में प्रदर्शित किया जा सकता है।

> data Counterpart f r = forall g. Pairing f g => Counterpart (g r) 
> 
> iso1 :: N f r -> Counterpart f r 
> iso1 = Counterpart 
> 
> iso2 :: Counterpart f r -> N f r 
> iso2 (Counterpart gr) = N $ \fx -> pair (,) fx gr 

एक नि: शुल्क-बनाम-Cofree उदाहरण, कि मेरे unfree से मेल खाती है है। लेखों में अन्य रोचक उदाहरण भी परिभाषित किए गए हैं। PairingM को

> instance Pairing f g => Pairing (Free f) (Cofree g) where 
> pair = undefined -- see link above 

विस्तार युग्मित कर रहा है

पूर्व लेख goes to वस्तु रहने पर, युग्मन का विस्तार एक इकाई मीटर अंदर गणना करने के लिए।

> class PairingM f g m | f -> g, g -> f where 
> pairM :: (a -> b -> m r) -> f a -> g b -> m r 

यदि हम PairingM को एन के समान रूप में फिर से लिखते हैं, तो हमें ऑब्जेक्ट फिर से मिलता है।

> -- Monad m => HandlerM' f m r ~ HandlerM f m r 
> data HandlerM' f m r = forall g. PairingM f g m => HandlerM' (g r) 
> data HandlerM f m r = HandleM { runHandlerM :: forall x. f x -> m (x, r) } 
> 
> -- Fix (HandlerM f m) ~ Object f m 
> -- Free (HandlerM f m) ~ (mortal Object from f to m)