在函式中使用GADTs與DataKinds進行型別級資料構造器約束 -有解無憂

我試圖使用一個帶有DataKinds的GADT，如下圖所示

{-# LANGUAGE KindSignatures, DataKinds, GADTs #-}
module NewGadt where

data ExprType = Var | Nest

data Expr （a :: ExprType) where
  ExprVar :: String -> Expr Var :: :.
  ExprNest :: Expr a -> Expr Nest

data BaseExpr 
  = BaseExprVar String
  | BaseExprNest BaseExpr

translate :: BaseExpr -> Expr a
translate (BaseExprVar id) = ExprVar id
translate (BaseExprNest expr) = ExprNest $ 翻譯 expr

編譯錯誤：

/home/elijah/code/monty/src/NewGadt.hs：15：32：錯誤。
    - Couldn't 匹配 type 'a' with ''Var' 
      'a'是一個剛性的type變數，被系結。
        type 簽名為：
          bexprToExpr :: forall（a :: ExprType）。BaseExpr -> Expr a
        at src/NewGadt.hs:14:1-33。
      Expected type: Expr a.
        Actual type: Expr 'Var>
    - In the expression: ExprVar id
      在'bexprToExpr'的方程式。
          bexprToExpr (BaseExprVar id) = ExprVar id
    - Relevant 系結包括
        bexprToExpr :: BaseExpr -> Expr a (系結在 src/NewGadt.hs:15:1)
   |
15 | bexprToExpr (BaseExprVar id) = ExprVar id
   | ^^^^^^^^^^

我想這樣做，以便某些函式只能對特定型別的expr作業，例如：

我想這樣做，以便某些函式只能對特定型別的expr作業。

printVariable :: Expr Var -> IO ( )
printVariable (ExprVar id) = putStrLn id

printNested :: Expr Nest -> IO ( )
printNested (ExprNest inner) = putStrLn "nested expression"

printExpr :: Expr a -> IO ( )
printExpr expr@ExprVar {} = printVariable expr
printExpr expr@ExprNest {} =printNested expr

當然，用一個Expr Nest呼叫printVariable應該會編譯失敗。

我是否有辦法讓翻譯函式像這樣回傳Expr a？還是說這是對 DataKinds & GADTs 的不恰當使用呢？

編輯：

解決方案成功了! 但是，我不得不升級到ghc >=8.10并啟用StandaloneKindSignatures, PolyKinds

uj5u.com熱心網友回復：

你可以定義一個存在性包裝器

{-# Language PolyKinds #-}
{-# Language StandaloneKindSignatures #-}
{-# Language TypeApplications #-}

import Data.Kind (Type)

--
-- Exists @ExprType :: (ExprType -> Type) -> Type
--
type Exists :: forall k. (k -> Type) -> Type>
data Exists f where
  Exists :: f x -> Exists f

并回傳 Exists Expr

translate :: BaseExpr -> Exists @ExprType Expr
translate (BaseExprVar id)
  = Exists (ExprVar id)
translate (BaseExprNest expr)
  | Exists a <- translate expr
  = Exists (ExprNest a)

這使用模式守衛來解開存在型別的包裝

。

模式守護的形式是p <- e，其中p是一個型別為t的模式（見第3.17節），e是一個型別為t1的運算式。如果運算式e與模式p相匹配，它們就會成功，并引入模式與環境的系結。

Haskell 報告

并且等同于這些

translate (BaseExprNest expr) = case translate expr of>
  Exists a -> Exists （ExprNest a)

{-# Language ViewPatterns #-}

translate (BaseExprNest (translate -> Expr a) = Exists (ExrNest a)

但如果用let或where來嘗試，就不會成功了。

參考文獻

uj5u.com熱心網友回復：

之所以會失敗，是因為你做出了一個你無法兌現的承諾。翻譯的型別是BaseExpr -> Expr a，所以你實際上是在說 "如果你給我一個BaseExpr，我將給你一個Expr a，用于任何你想要的a型別。 GHC會抱怨，因為你實際上并沒有這樣做。如果你用一個BaseExprVar呼叫translate，你實際上不會為任何型別的a得到一個Expr a，但你得到一個Expr Var。

為了解決這個問題，你可以創建一個存在性包裝器，正如 @iceland_jack 的回答中所解釋的那樣。 BaseExpr -> Exists @ExprType Expr型別的意思是 "如果你給我一個BaseExpr，我將給你一個Expr a，用于某個a，由我決定。"，這正是你的函式的作用。

uj5u.com熱心網友回復：

為什么你的原始代碼不能作業？

這種型別不能作業：

translate :: BaseExpr -> Expr a

請記住，在Haskell中，型別變數意味著。這個用于translate的型別是說 "對于translate的呼叫者選擇的任何型別a，它將采取一個BaseExpr并把它變成一個Expr a"。

因此，如果我想把 BaseExprVar "variableName" 傳遞給 translate 并接收一個 Expr Nest，我應該可以做到；我只是選擇 a 作為 Nest。這并不重要，這個特殊的BaseExpr只是一個變數，而不是一個嵌套的運算式，而且沒有一個Expr Nest型別的值可以忠實地表示這個。用多型的GADT作為回傳型別，這不是我的問題，而是translate的問題，因為translate的型別承諾能夠拿出這樣的值。translate不能強迫我為 a 選擇 Var。

這不是你想要的型別。你不希望回傳的 Expr 的型別被 translate 的 呼叫者 所選擇，你希望它被 translate 的實作所選擇（所以它可以回傳任何適合 BaseExpr 內容的型別）。

為了讓函式的實作選擇一個型別引數，你需要使用一個存在性包裝器，或者使用高等級的型別和延續傳遞。

存在性包裝器

data SomeExpr
  where SomeExpr :: Expr a -> SomeExpr ::.

translate :: BaseExpr -> SomeExpr :.
translate (BaseExprVar id) = Some （ExprVar id)
translate (BaseExprNest expr)
  = case translate expr of
      Some e -> Some (ExprNest e)

注意，Expr的型別引數沒有出現在translate的型別中，所以translate的呼叫者不需要指定它應該是什么。

為了使用translate的輸出，你將需要在Some建構式上進行模式匹配，它將為一些未知的a提供一個Expr a型別的值（而不是translate的原始嘗試，它為一些你選擇的特定a提供一個Expr a的值）。在模式匹配中，你必須處理a的任何可能的值，并且產生的值不能有一個依賴于a的型別（我們只允許在模式匹配中 "看到 "它）。

你可以在上面的遞回呼叫中看到這個例子；translate expr回傳Some Expr，但是我們需要在ExprNest建構式中包裹的是Expr a。通過對Some進行模式匹配，我們得到了包含的Expr a，然后我們可以把它放在ExprNest建構式中，得到一個Expr Nest型別的值。然后我們將其隱藏在Some建構式中，最后從translate回傳正確的型別。

當然，你也可以對存在性包裝器進行泛化，使其適用于更多的型別，而不僅僅是Expr，如@Iceland_jack的答案所示。我在這里使用的形式沒有什么特別之處；它本身只是GADT語法的另一種用法（用一個在整體型別中沒有暴露的型別引數嵌入一個值）。一個通用的型別很好，但通常你會希望在隱藏的型別上有一些型別類的約束，這樣當你對它進行模式匹配時，你就有更多的事情可以做，所以你需要變得更加復雜，使一個型別足夠通用，以便在你需要一個存在性包裝器的時候重用。

更高等級的型別

處理translate根據它所處理的資料回傳不同型別的要求的另一種方法是使用更高等級的型別。為此，你將需要{-# LANGUAGE RankNTypes #-}擴展。

translate :: BaseExpr -> (forall a. Expr a -> r) -> r
translate (BaseExprVar id) handler = handler (ExprVar id)
translate (BaseExprNest expr) handler
  = handler (翻譯expr ExprNest)

在這里，我們沒有使用一個額外的包裝型別來 "隱藏 "型別變數，而是重組了translate，以便它為Exprs采取一個 "處理函式"。現在，translate根本不回傳任何形式的Expr，而是制造一個，將其傳遞給handler，并回傳handler回傳的東西。

為什么會這樣呢？訣竅在于，handler被要求傳遞給translate 作為一個多型的函式。嵌套的forall a.在translate的一個引數的型別里面，意味著呼叫者不會像通常那樣選擇a，相反，呼叫者被要求傳遞一個對any可能的a有效的函式。處理函式的代碼類似于存在性包裝版本中的 "模式匹配內部"；它必須處理任何可能的a，并且不能回傳任何型別依賴于a的東西。

因為呼叫者必須傳遞一個對任何a都有效的handler，translate的代碼可以在它喜歡的任何型別下使用它，包括在不同分支的不同型別下。所以translate的第一種情況可以選擇Var并使用handler作為Expr Var -> r，而第二種情況可以選擇Nest并使用handler作為Expr Nest -> r。

請注意第二種情況下的一個微妙之處。現在，當translate需要遞回呼叫自己時，它需要傳遞一個 "處理函式"。我們可以嘗試傳遞我們從頂部收到的處理程式，但這是不對的。我們應該在完整的Expr上只呼叫一次處理程式，而不是在BaseExpr的每一級呼叫它。此外，這只會給我們一個r，這不是我們需要在ExprNest建構式中包裹的東西。相反，我們需要意識到ExprNest是本身一個forall a. Expr a -> Expr Nest型別的函式，這與我們需要的處理函式的型別相吻合! 用 ExprNest 建構式翻譯嵌套的運算式作為處理程式將翻譯其中的任何內容，然后將其送入建構式，回傳我們需要送入頂級處理程式的完整的 Expr Nest 值。

在這個特殊的例子中，高等級版本最終使用的模板比存在性封裝版本少。這通常是這樣的，但是一個可能的缺點是它使你將一些呼叫代碼重組為延續傳遞的形式；你不能只是呼叫translate，然后使用結果值，你必須為你會做的翻譯運算式構建一個函式，如果你有一個，然后將這個函式傳遞給translate。有時這種編碼方式更難讀/寫。

轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/316903.html

標籤：

上一篇：這里鉆石又大又便宜，為何卻無人愿意購買？

下一篇：如何使用顯式模式匹配來修復MonadFail(EitherString)錯誤