cách tốt để chuyển đổi giữa các hàm đa hình ad-hoc và các đa hình tham số

Question

Tôi tự hỏi liệu có cách tổng quát để chuyển đổi giữa các hàm đa hình ad-hoc và các hàm đa hình tham số hay không. Nói cách khác, được đưa ra một chức năng đa hình ad-hoc, làm thế nào để thực hiện đối số tham số của nó? và còn cách nào khác?

chụp sort làm ví dụ. thật dễ dàng để viết sort :: Ord a => [a] -> [a] về sortBy:

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

nhưng cách khác xung quanh dường như khó khăn, cho đến nay là tốt nhất tôi có thể làm là để đi một chút "hướng đối tượng":

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 

Nhưng điều này nghe có vẻ giống như một hack hơn là giải pháp thích hợp.

vì vậy tôi muốn biết:

1. đang có những cách tốt hơn ví dụ cụ thể này?
2. các kỹ thuật chung để chuyển đổi giữa các hàm đa hình ad-hoc và các hàm tham số là gì?

Answer 1

Tôi không nhất thiết phải nói rằng bạn nên làm điều này, nhưng bạn có thể sử dụng reflection để vượt qua xung quanh chức năng so sánh mà không cần phải gói nó lên với mỗi phần tử của danh sách:

{-# 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 

Given (heh) cơ sở hạ tầng trên, sau đó bạn có thể viết sortBy về sort như sau:

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 

(lưu ý rằng bằng cách sử dụng Data.Coerce, chúng tôi tránh tất cả các chi phí thời gian chạy tiềm năng của O wrapper)

Answer 2

Cactus của câu trả lời dựa trên lớp hơi râm Given trong reflection. Tuy nhiên, có thể sử dụng sự phản chiếu mà không có điều đó.

{-# 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]) 

Kiểm tra lõi được sản xuất cho biết rằng trình biên dịch này bao bọc mỏng khoảng sortBy. Nó trông mỏng hơn khi sử dụng lớp Reifies dựa trên Tagged thay vì Proxy, nhưng Ed Kmett không thích API sản xuất.