loại Hiện sinh và máy biến áp đơn nguyên

Question

Bối cảnh: Tôi đang cố gắng để tạo ra một đơn nguyên lỗi mà cũng theo dõi danh sách cảnh báo, một cái gì đó như thế này:

data Dangerous a = forall e w. (Error e, Show e, Show w) => 
    Dangerous (ErrorT e (State [w]) a) 

tức Dangerous a là một hoạt động dẫn đến (Either e a, [w]) nơi e là lỗi hiển thị và w có thể hiển thị.

Vấn đề là, tôi dường như không thể thực sự chạy điều này, chủ yếu là vì tôi không hiểu tất cả các loại tồn tại. Quan sát:

runDangerous :: forall a e w. (Error e, Show e, Show w) => 
    Dangerous a -> (Either e a, [w]) 
runDangerous (Dangerous f) = runState (runErrorT f) [] 

này không biên dịch, bởi vì:

Could not deduce (w1 ~ w) 
from the context (Error e, Show e, Show w) 
... 
`w1' is a rigidtype variable bound by 
    a pattern with constructor 
    Dangerous :: forall a e w. 
       (Error e, Show e, Show w) => 
       ErrorT e (State [w]) a -> Dangerous a 
... 
`w' is a rigid type variable bound by 
    the type signature for 
    runDangerous :: (Error e, Show e, Show w) => 
        Dangerous a -> (Either e a, [w]) 

Tôi bị mất. W1 là gì? Tại sao chúng ta không thể suy ra rằng đó là ~ w?

Answer 1

Hiện trạng có thể không phải là những gì bạn muốn ở đây; không có cách nào để "quan sát" các loại thực tế được ràng buộc với e hoặc w trong giá trị Dangerous a, vì vậy, bạn hoàn toàn bị giới hạn đối với các hoạt động được cung cấp cho bạn bởi Error và Show.

Nói cách khác, điều duy nhất bạn biết về w là bạn có thể biến nó thành một String, vì vậy nó có thể cũng chỉ là một String (bỏ qua ưu tiên để đơn giản hóa mọi thứ), và điều duy nhất bạn biết về e là bạn có thể biến nó thành một String, bạn có thể biến String giây vào đó và bạn có một giá trị phân biệt của nó (noMsg). Không có cách nào để khẳng định hoặc kiểm tra xem các kiểu này có giống nhau hay không, vì vậy khi bạn đặt chúng vào một Dangerous, không có cách nào để phục hồi bất kỳ cấu trúc đặc biệt nào mà các kiểu đó có thể có.

gì được thông báo lỗi được nói là, về cơ bản, loại hình cho runDangerous tuyên bố rằng bạn có thể biến một Dangerous thành một (Either e a, [w]) cho bất kỳe và w rằng có những trường hợp có liên quan. Điều này rõ ràng không đúng: bạn chỉ có thể biến một loại Dangerous thành loại đó cho một lựa chọn e và w: loại được tạo. Các w1 chỉ vì loại Dangerous của bạn được xác định với một biến loại w, và như vậy là runDangerous, do đó GHC đổi tên một trong số chúng để tránh xung đột tên.

Loại bạn cần phải cung cấp cho runDangerous trông như thế này:

runDangerous 
    :: (forall e w. (Error e, Show e, Show w) => (Either e a, [w]) -> r) 
    -> Dangerous a -> r 

đó, cho một chức năng mà sẽ chấp nhận một giá trị kiểu (Either e a, [w]) cho bất kỳ lựa chọn của e và w chừng nào họ có các trường hợp đã cho và Dangerous a, tạo ra kết quả của hàm đó. Điều này là khá khó khăn để có được đầu của bạn xung quanh!

Việc thực hiện cũng đơn giản như

runDangerous f (Dangerous m) = f $ runState (runErrorT m) [] 

đó là một sự thay đổi không đáng kể đến phiên bản của bạn. Nếu điều này làm việc cho bạn, tuyệt vời; nhưng tôi nghi ngờ rằng một tồn tại là đúng cách để đạt được bất cứ điều gì bạn đang cố gắng làm.

Lưu ý rằng bạn cần {-# LANGUAGE RankNTypes #-} để thể hiện loại runDangerous. Ngoài ra, bạn có thể định nghĩa khác hiện sinh cho loại kết quả của bạn:

data DangerousResult a = forall e w. (Error e, Show e, Show w) => 
    DangerousResult (Either e a, [w]) 

runDangerous :: Dangerous a -> DangerousResult a 
runDangerous (Dangerous m) = DangerousResult $ runState (runErrorT m) [] 

và trích xuất kết quả với case, nhưng bạn sẽ phải cẩn thận, hoặc GHC sẽ bắt đầu phàn nàn rằng bạn đã để cho e hoặc w thoát - tương đương với việc cố gắng truyền một hàm đa hình không đủ cho dạng khác của runDangerous; tức là một yêu cầu có nhiều ràng buộc hơn về những gì e và w vượt quá loại bảo đảm runDangerous.

Answer 2

Ok, tôi nghĩ rằng tôi đã tìm ra những gì tôi đã lúng túng sau: (. instance Monad Dangerous và data DangerousT giúp đỡ quá)

data Failure = forall e. (Error e, Show e) => Failure e 

data Warning = forall w. (Show w) => Warning w 

class (Monad m) => Errorable m where 
    warn :: (Show w) => w -> m() 
    throw :: (Error e, Show e) => e -> m() 

instance Errorable Dangerous where 
    warn w = Dangerous (Right(), [Warning w]) 
    throw e = Dangerous (Left $ Failure e, []) 

này cho phép bạn có đoạn mã sau:

foo :: Dangerous Int 
foo = do 
    when (badThings) (warn $ BadThings with some context) 
    when (worseThings) (throw $ BarError with other context) 

data FooWarning = BadThings FilePath Int String 
instance Show FooWarning where 
... 

và sau đó trong mô-đun chính của bạn, bạn có thể xác định các phiên bản tùy chỉnh của Show Failure, Error Failure và Show Warning một nd có cách tập trung để định dạng thông báo lỗi của bạn, ví dụ:

instance Show Warning where show (Warning s) = "WARNING: " ++ show s 
instance Show Failure where ... 

let (result, warnings) = runDangerous function 
in ... 

Theo tôi, cách khá hay là xử lý lỗi và cảnh báo. Tôi đã có một mô-đun đang hoạt động giống như thế này, bây giờ tôi tắt để đánh bóng nó và có thể đặt nó vào hackage. Đề xuất được đánh giá cao.