एड-होक पॉलीमोर्फिक फ़ंक्शंस और पैरामीट्रिक पॉलिमॉर्फिक वाले

Question

के बीच कनवर्ट करने का अच्छा तरीका मैं सोच रहा हूं कि विज्ञापन-हाक पॉलीमोर्फिक फ़ंक्शंस और पैरामीट्रिक पॉलिमॉर्फिक वाले लोगों के बीच कनवर्ट करने के सामान्य तरीके हैं या नहीं। दूसरे शब्दों में, एक विज्ञापन-पॉलीमोर्फिक फ़ंक्शन दिया गया है, इसके पैरामीट्रिक समकक्ष को कैसे कार्यान्वित किया जाए? और दूसरी तरफ के बारे में क्या?

उदाहरण के रूप में sort लें। यह sortBy के मामले में sort :: Ord a => [a] -> [a] लिखने के लिए आसान है:

sort :: Ord a => [a] -> [a] 
sort = sortBy compare 

लेकिन दूसरी तरह के आसपास मुश्किल लगता है, अब तक सबसे अच्छा मैं कर सकता है एक सा "वस्तु उन्मुख" जाने के लिए है:

import qualified Data.List as L 

data OrdVal a = OV (a -> a -> Ordering) a 

instance Eq (OrdVal a) where 
    (OV cmp a) == (OV _ b) = a `cmp` b == EQ 

instance Ord (OrdVal a) where 
    (OV cmp a) `compare` (OV _ b) = a `cmp` b 

sortBy :: (a -> a -> Ordering) -> [a] -> [a] 
sortBy cmp = map unOV . L.sort . map (OV cmp) 
    where 
    unOV (OV _ v) = v 

लेकिन यह उचित समाधान की तुलना में एक हैक की तरह लगता है।

तो मैं जानना चाहते हैं:

1. इस विशिष्ट उदाहरण के लिए बेहतर तरीके देखते हैं?
2. विज्ञापन-पॉलीमोरिमिक फ़ंक्शंस और पैरामीट्रिक वाले लोगों के बीच कनवर्ट करने के लिए सामान्य तकनीक क्या हैं?

Answer 1

मैं जरूरी नहीं कह रहा हूँ आप इस करना चाहिए, लेकिन आप कर सकते हैं उपयोग reflection यह पैकेज के लिए सूची के प्रत्येक तत्व के साथ बिना तुलना समारोह के आसपास पारित करने के लिए:

{-# LANGUAGE UndecidableInstances #-} 
import Data.Reflection 

newtype O a = O a 

instance Given (a -> a -> Ordering) => Eq (O a) where 
    x == y = compare x y == EQ 

instance Given (a -> a -> Ordering) => Ord (O a) where 
    compare (O x) (O y) = given x y 

यह देखते हुए (हे) के ऊपर बुनियादी सुविधाओं, आप तो sort के मामले में sortBy लिख सकते हैं इस प्रकार है:

import Data.Coerce 
import Data.List (sort) 

sortBy :: (a -> a -> Ordering) -> [a] -> [a] 
sortBy cmp = give cmp $ from . sort . to 
    where 
    to :: [a] -> [O a] 
    to = coerce 

    from :: [O a] -> [a] 
    from = coerce 

(ध्यान दें कि Data.Coerce का उपयोग करके, हम O आवरण के सभी संभावित क्रम लागत से बचने)

Answer 2

कैक्टस के जवाब reflection में कुछ हद तक छायादार Given वर्ग पर निर्भर करता है। हालांकि, इसके बिना प्रतिबिंब का उपयोग करना संभव है।

{-# LANGUAGE ScopedTypeVariables, MultiParamTypeClasses, UndecidableInstances #-} 

module SortReflection where 

import Data.Reflection 
import Data.List (sort) 
import Data.Proxy 
import Data.Coerce 

newtype O s a = O {getO :: a} 

instance Reifies s (a -> a -> Ordering) => Eq (O s a) where 
    a == b = compare a b == EQ 

instance Reifies s (a -> a -> Ordering) => Ord (O s a) where 
    compare = coerce (reflect (Proxy :: Proxy s)) 

sortBy :: forall a . (a -> a -> Ordering) -> [a] -> [a] 
sortBy cmp = reify cmp $ 
    \(_ :: Proxy s) -> coerce (sort :: [O s a] -> [O s a]) 

जांच कोर का उत्पादन इंगित करता है कि इस sortBy चारों ओर एक पतली आवरण को संकलित करता है। Proxy के बजाय Tagged पर आधारित Reifies कक्षा का उपयोग करके यह पतला दिखता है, लेकिन एड Kmett उत्पादित एपीआई पसंद नहीं करता है।