ad-hoc 다형 함수와 파라 메트릭 다형 함수 사이를 변환하는 좋은 방법

Question

ad-hoc 다형 함수와 파라 메트릭 다형 함수 사이를 변환하는 일반적인 방법이 있는지 궁금합니다. 다른 말로 표현하면, ad-hoc 다형 함수가 주어지면 매개 변수를 구현하는 방법은 무엇입니까? 그 반대의 경우는 어떨까요?

예를 들어 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. ad-hoc 다형 함수와 파라 메트릭 함수를 변환하는 일반적인 기술은 무엇입니까?

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 

,

Answer 2

선인장의 대답은 reflection에 다소 그늘 Given 클래스에 의존 (Data.Coerce를 사용하여, 우리는 O 래퍼의 모든 잠재적 인 런타임 비용을 피할 수 있습니다). 그러나 그것없이 반사를 사용하는 것도 가능합니다. 코어가 제조 검사

{-# 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의 thin 래퍼로 컴파일 것을 나타낸다. Proxy 대신 Tagged을 기반으로 한 Reifies 클래스를 사용하면 더 얇아 보이지만 Ed Kmett는 생성하는 API를 좋아하지 않습니다.