依赖类限制的模糊类型变量

Question

我正在为Snap web framework写一个新的身份验证系统，因为内置模块不够模块化，并且它的某些功能对于我的应用程序来说是冗余/“自重” 。尽管这个问题与Snap完全无关。

虽然这样做，我遇到了模糊类型约束的问题。在下面的代码中，似乎很明显，back的类型只能是函数类型中的类型变量b，但GHC却抱怨该类型不明确。

如何更改以下代码，使back的类型为b，而不使用例如。 ScopedTypeVariables（因为问题与约束有关，而不是具有过于普通的类型）？有什么地方需要功能依赖吗？

相关类型类：

data AuthSnaplet b u = 
    AuthSnaplet 
    { _backend :: b 
    , _activeUser :: Maybe u 
    } 
-- data-lens-template:Data.Lens.Template.makeLens 
-- data-lens:Data.Lens.Common.Lens 
-- generates: backend :: Lens (AuthSnaplet b u) b 
makeLens ''AuthSnaplet 

-- Some encrypted password 
newtype Password = 
    Password 
    { passwordData :: ByteString 
    } 

-- data-default:Data.Default.Default 
class Default u => AuthUser u where 
    userLogin :: Lens u Text 
    userPassword :: Lens u Password 

class AuthUser u => AuthBackend b u where 
    save :: MonadIO m => b -> u -> m u 
    lookupByLogin :: MonadIO m => b -> Text -> m (Maybe u) 
    destroy :: MonadIO m => b -> u -> m() 

-- snap:Snap.Snaplet.Snaplet 
class AuthBackend b u => HasAuth s b u where 
    authSnaplet :: Lens s (Snaplet (AuthSnaplet b u)) 

失败代码：

-- snap:Snap.Snaplet.with :: Lens v (Snaplet v') -> m b v' a -> m b v a 
-- data-lens-fd:Data.Lens.access :: MonadState a m => Lens a b -> m b 
loginUser :: HasAuth s b u 
      => Text -> Text -> Handler a s (Either AuthFailure u) 
loginUser uname passwd = with authSnaplet $ do 
    back <- access backend 
    maybeUser <- lookupByLogin back uname -- !!! type of back is ambiguous !!! 
    -- ... For simplicity's sake, let's say the function ends like this: 
    return . Right . fromJust $ maybeUser 

完整的错误：

src/Snap/Snaplet/Authentication.hs:105:31: 
    Ambiguous type variables `b0', `u0' in the constraint: 
     (HasAuth s b0 u0) arising from a use of `authSnaplet' 
    Probable fix: add a type signature that fixes these type variable(s) 
    In the first argument of `with', namely `authSnaplet' 
    In the expression: with authSnaplet 
    In the expression: 
     with authSnaplet 
     $ do { back <- access backend; 
      maybeUser <- lookupByLogin back uname; 
       ... } 

src/Snap/Snaplet/Authentication.hs:107:16: 
    Ambiguous type variable `b0' in the constraint: 
     (AuthBackend b0 u) arising from a use of `lookupByLogin' 
    Probable fix: add a type signature that fixes these type variable(s) 
    In a stmt of a 'do' expression: 
     maybeUser <- lookupByLogin back uname 
    In the second argument of `($)', namely 
     `do { back <- access backend; 
      maybeUser <- lookupByLogin back uname; 
       ... }' 
    In the expression: 
     with authSnaplet 
     $ do { back <- access backend; 
      maybeUser <- lookupByLogin back uname; 
       ... } 

Answer 1

我冒昧地猜测，你的问题的根源是在表达式with authSnaplet。原因如下：

∀x. x ⊢ :t with authSnaplet 
with authSnaplet 
    :: AuthUser u => m b (AuthSnaplet b1 u) a -> m b v a 

不介意上下文，我只是在GHCi中加载了一些假实例。请注意这里的类型变量 - 很多不明确的地方，至少有两个我希望你打算成为相同的类型。处理这种情况最简单的方法可能是创建一个小的辅助功能与类型签名缩小东西下来了一点，如：

withAuthSnaplet :: (AuthUser u) 
       => Handler a (AuthSnaplet b u) (Either AuthFailure u) 
       -> Handler a s (Either AuthFailure u) 
withAuthSnaplet = with authSnaplet 

再次，原谅废话，我实际上没有安装在快那一刻，这让事情变得尴尬。介绍此功能并使用它代替with authSnaplet的loginUser，允许代码为我输入检查。您可能需要稍微调整一下以处理实际的实例约束。

---

编辑：如果上面的方法不会让你通过某种手段明确b，并假设类型的真正意图是为他们写为通用，然后b是不可能暧昧并没有办法绕过它。

使用with authSnaplet完全从实际类型中消除了b，但是使其具有多态性并具有类限制。这与像show . read这样的表达式具有相同的含糊性，具有依赖于实例的行为，但没有办法选择它。

为了避免这种情况，你有大致有三种选择：

• 保留暧昧类型明确，使b在实际类型的loginUser，而不仅仅是上下文发现某处。由于其他原因，在您的应用程序中，这可能不合需要。

• 通过仅将with authSnaplet应用于适当的单形值来消除多态性。如果事先知道这些类型，就没有多余的余地。这可能意味着放弃处理程序中的某些多态性，但是通过将事物分开，可以将单态限制为只关注b的代码。

• 使类别约束本身明确无误。如果到HasAuth的三个类型参数实际上在某种程度上相互依赖，使得对于任何s和u只有一个有效实例，则从其他人到b的功能依赖性将是完全适当的。