Question

我使用scotty和persistent在Haskell服务器上工作。许多处理程序需要访问数据库连接池，因此我采取了以这种方式在整个应用程序中传递池：

main = do
    runNoLoggingT $ withSqlitePool ":memory:" 10 $ \pool ->
        liftIO $ scotty 7000 (app pool)

app pool = do
    get "/people" $ do
        people <- liftIO $ runSqlPool getPeople pool
        renderPeople people
    get "/foods" $ do
        food <- liftIO $ runSqlPool getFoods pool
        renderFoods food

其中getPeople和getFoods是适当的persistent数据库操作，分别返回[Person]和[Food]。

在游泳池中调用liftIO和runSqlPool的模式会在一段时间后变得令人厌烦 - 如果我能将它们重构为单个函数（例如Yesod＆＃39; s runDB，它只接受查询并返回适当的类型。我写这样的东西的尝试是：

runDB' :: (MonadIO m) => ConnectionPool -> SqlPersistT IO a -> m a
runDB' pool q = liftIO $ runSqlPool q pool

现在，我可以这样写：

main = do
    runNoLoggingT $ withSqlitePool ":memory:" 10 $ \pool ->
        liftIO $ scotty 7000 $ app (runDB' pool)

app runDB = do
    get "/people" $ do
        people <- runDB getPeople
        renderPeople people
    get "/foods" $ do
        food <- runDB getFoods
        renderFoods food

除了GHC抱怨：

Couldn't match type `Food' with `Person'
Expected type: persistent-2.1.1.4:Database.Persist.Sql.Types.SqlPersistT
                 IO
                 [persistent-2.1.1.4:Database.Persist.Class.PersistEntity.Entity
                    Person]
  Actual type: persistent-2.1.1.4:Database.Persist.Sql.Types.SqlPersistT
                 IO
                 [persistent-2.1.1.4:Database.Persist.Class.PersistEntity.Entity
                    Food]
In the first argument of `runDB', namely `getFoods'

似乎GHC说实际上runDB的类型在某种程度上变得专业化。但那么runSqlPool这样的函数是如何定义的呢？它的类型签名看起来与我的类似：

runSqlPool :: MonadBaseControl IO m => SqlPersistT m a -> Pool Connection -> m a

但它可以用于返回许多不同类型的数据库查询，就像我最初做的那样。我认为这里有一些基本的东西，我对这里的类型有误解，但我不知道如何找出它是什么！任何帮助将不胜感激。

修改

在Yuras＆＃39;建议，我已添加：

type DBRunner m a = (MonadIO m) => SqlPersistT IO a -> m a
runDB' :: ConnectionPool -> DBRunner m a
app :: forall a. DBRunner ActionM a -> ScottyM ()

，其中typedef需要-XRankNTypes。但是，编译器错误仍然相同。

修改

评论员的胜利。这允许代码编译：

app :: (forall a. DBRunner ActionM a) -> ScottyM ()

对此我感激不尽，但仍感到神秘！

该代码目前看起来像this和this。

Answer 1

似乎GHC说实际上runDB的类型在某种程度上变得专业化。

你的猜测是正确的。您的原始类型为app :: (MonadIO m) => (SqlPersistT IO a -> m a) -> ScottyM ()。这意味着runDB类型的SqlPersistT IO a -> m a参数可以在任何一个类型a中使用。但是，app的主体想要在两种不同的类型（runDB和Person）中使用Food参数，所以我们需要传递一个可以适用于任何类型的参数身体中不同类型的数量。因此app需要类型

app :: MonadIO m => (forall a. SqlPersistT IO a -> m a) -> ScottyM ()

（我建议将MonadIO约束保留在forall之外，但你也可以把它放在里面。）

编辑：

幕后发生的事情如下：

(F a -> G a) -> X表示forall a. (F a -> G a) -> X，表示/\a -> (F a -> G a) -> X。 /\是类型级lambda。也就是说，调用者可以传入单个类型a和类型为F a -> G a的函数，用于特定选择a。

(forall a. F a -> G a) -> X表示(/\a -> F a -> G a) -> X，并且调用方必须传入一个被调用者可以专门用于许多选项a的函数}。

Answer 2

让我们玩游戏：

Prelude> let f str = (read str, read str)
Prelude> f "1" :: (Int, Float)
(1,1.0)

按预期工作。

Prelude> let f str = (read1 str, read1 str) where read1 = read
Prelude> f "1" :: (Int, Float)
(1,1.0)

也适用。

Prelude> let f read1 str = (read1 str, read1 str)
Prelude> f read "1" :: (Int, Float)

<interactive>:21:1:
    Couldn't match type ‘Int’ with ‘Float’
    Expected type: (Int, Float)
      Actual type: (Int, Int)
    In the expression: f read "1" :: (Int, Float)
    In an equation for ‘it’: it = f read "1" :: (Int, Float)

但这并不是。有什么区别？

最后一个f具有下一个类型：

Prelude> :t f
f :: (t1 -> t) -> t1 -> (t, t)

因此，它没有明确的原因，元组的两个元素应该具有相同的类型。

修复就是这样：

Prelude> :set -XRankNTypes 
Prelude> let f read1 str = (read1 str, read1 str); f :: (Read a1, Read a2) => (forall a . Read a => str -> a) -> str -> (a1, a2)
Prelude> f read "1" :: (Int, Float)
(1,1.0)

我不太可能对RankNTypes有很好的解释，所以我甚至都没有尝试过。网络上有足够的资源。

Answer 3

要真正回答明显继续使你神秘化的标题问题：当你不提供明确的签名时，Haskell总是为函数选择最通用的rank-1类型。因此，对于表达式app中的app (runDB' pool)，GHC将尝试使用类型

app :: DBRunner ActionM a -> ScottyM ()

实际上是

的简写

app :: forall a. ( DBRunner ActionM a -> ScottyM () )

这是rank-1多态，因为所有类型变量都是在签名之外引入的（签名本身没有进行量化;参数DBRunner ActionM a实际上是单态的，因为a是固定在那一点）。实际上，它是最通用的类型：它可以使用像(runDB' pool)这样的多态参数，但也可以使用单态参数。

但事实证明app的实现无法提供这种一般性：需要多态行为，否则它无法提供两种不同类型的{ {1}}对该操作的值。因此，您需要手动请求更具体的类型

这是rank-2，因为它有一个包含rank-1多态参数的签名。 GHC无法真正知道这是你想要的类型 - 对于表达式没有明确定义的“最通用的可能的rank-n类型”，因为你总是可以推出额外的量词。因此，您必须手动指定rank-2类型。

通用函数何时不通用？

3 个答案: