haskell - 确定一个函数有多少类型孔的快速方法是什么？

Question

Typed holes提供了一种找出如何实现某事的好方法:如果您知道要使用什么函数，请说 foo , 你可以写出类似 foo _ _ _ 的东西让编译器告诉你它对每个参数期望什么类型。这使得在很大程度上无需查找任何文档。

但是，它只有在您实际写出正确数量的下划线时才能正常工作。目前，我通常通过一些反复试验来确定这一点，但要注意哪些提示并不总是很明显，因为在 Haskell 中，函数总是可以部分应用。

尽快找出这个数字的好方法是什么？

Answer 1

正如@chi 所暗示的那样，我发现的最好的事情是“将漏洞应用于函数”。我不知道这是否回答了问题，但希望它至少有所帮助。

我猜“函数总是可以部分应用”，你的意思是你可以拥有这样的功能:

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldr = undefined

对于它，您不能仅从类型中得知它应该采用多少个参数来对任何特定类型进行类型检查。类型检查器在这里可以做的最好的事情就是告诉您它将接受的最小参数数量:

bar :: String -> String
bar = _1 foldr

* Found hole:
    _1 :: ((a0 -> b0 -> b0) -> b0 -> t0 a0 -> b0) -> String -> String
  Where: `t0' is an ambiguous type variable
         `b0' is an ambiguous type variable
         `a0' is an ambiguous type variable
* In the expression: _
  In the expression: _ foldr
  In an equation for `bar': bar = _ foldr

* Ambiguous type variable `t0' arising from a use of `foldr'
  prevents the constraint `(Foldable t0)' from being solved.
  Probable fix: use a type annotation to specify what `t0' should be.
  These potential instances exist:
    instance Foldable (Either a) -- Defined in `Data.Foldable'
    instance Foldable Maybe -- Defined in `Data.Foldable'
    instance Foldable ((,) a) -- Defined in `Data.Foldable'
    ...plus one other
    ...plus 22 instances involving out-of-scope types
    (use -fprint-potential-instances to see them all)

旁白:第二个错误在这里并不是特别有用，如 t0真的可以是这些类型中的任何一种。但是，如果您发现自己经常处于这种情况，那么 -fprint-potential-instances实际上可能有用。

您现在可以在脑海中进行一些类型检查:

((a0 -> b0 -> b0) ->  b0  -> t0 a0  -> b0     ) -> 
  <_1>               <_2>    String -> String

为了匹配类型，您必须提供至少两个孔。您可能需要更多，但这取决于 b0 的实例化.替换这些漏洞，你会得到一个非常简单的问题

bar :: String -> String
bar = foldr _1 _2

* Found hole: _1 :: Char -> String -> String

* Found hole: _2 :: String

你甚至可能会遇到一个(在我看来，愚蠢的)函数，比如

class C a where foo :: a
instance C String where
instance C a => C (Int -> a) where

在这种情况下，您可以做同样的事情，类型检查器会帮助您通知所有可能的情况:

bar :: String -> String
bar = _ foo

test0.hs:6:7: warning: [-Wtyped-holes]
    * Found hole: _ :: t0 -> String -> String
      Where: `t0' is an ambiguous type variable
    * In the expression: _
      In the expression: _ foo
      In an equation for `bar': bar = _ foo
    * Relevant bindings include
        bar :: String -> String (bound at test0.hs:6:1)

test0.hs:6:9: warning: [-Wdeferred-type-errors]
    * Ambiguous type variable `t0' arising from a use of `foo'
      prevents the constraint `(C t0)' from being solved.
      Probable fix: use a type annotation to specify what `t0' should be.
      These potential instances exist:
        instance C a => C (Int -> a) -- Defined at test0.hs:3:10
        instance C String -- Defined at test0.hs:2:10
    * In the first argument of `_', namely `foo'
      In the expression: _ foo
      In an equation for `bar': bar = _ foo

在这里你真的要猜测。在这个(公认是人为的)例子中，我可能猜你想要一个参数，因为 bar需要一个参数。

bar :: String -> String
bar = foo . _

test0.hs:6:7: warning: [-Wdeferred-type-errors]
    * Ambiguous type variable `b0' arising from a use of `foo'
      prevents the constraint `(C (b0 -> String))' from being solved.
        (maybe you haven't applied a function to enough arguments?)
      Probable fix: use a type annotation to specify what `b0' should be.
      These potential instance exist:
        instance C a => C (Int -> a) -- Defined at test0.hs:3:10

test0.hs:6:13: warning: [-Wtyped-holes]
    * Found hole: _ :: String -> b0
      Where: `b0' is an ambiguous type variable

现在它告诉你有一个潜在的实例，所以你可以猜测那个洞的类型真的应该是 String -> Int .