Haskell和一般类型

Question

我是Haskell的新手，我想了解一般类型的工作原理。

什么应该是一种“系统的”思维方式来获得表达的类型？

举个例子，如果我们有：

(\x y z -> x (y z))

我想到的方式，只是使用直觉，但它总是不起作用。

在这种情况下，我会说：

   (y z) :: (t -> t1) --function y takes t and return t1
 x (y z) :: (t1 -> t2) --function x takes argument of type (return type of y)

(\x y z -> x (y z)) :: (t1 -> t2) -> (t -> t1) -> t -> t2 --return type is t2 (of x) with argument of type t for function y

我很确定这应该是正确的，但有时它更难以这种方式去思考似乎不起作用。

例如，如果我们有：

1.  (\x -> x (<))  or
2.  (.) . (.)

在这种情况下，我不知道如何找到类型，因为我猜第一个（<）是两个返回Bool元素的函数，但是我在编写孔表达式时遇到了麻烦。

所以问题是，使用这种练习的最佳方法是什么？

---

补充：我知道如何用ghci检查类型，问题是如何在没有它的情况下实际找到它们（了解Haskell如何工作）。

Answer 1

您可以使用以下命令轻松检查表达式的类型:t in ghci ：

Prelude> :t (\x y z -> x (y z))
(\x y z -> x (y z)) :: (r1 -> r) -> (r2 -> r1) -> r2 -> r
Prelude> :t (\x -> x (<))
(\x -> x (<)) :: Ord a => ((a -> a -> Bool) -> r) -> r
Prelude> :t (.) . (.)
(.) . (.) :: (b -> c) -> (a -> a1 -> b) -> a -> a1 -> c

但我认为你想自己推导出这些类型。

1. 首先，我们可以从查看变量开始。 那些是x ， y和z 。 我们首先为它们分配“泛型类型”，因此：

    x :: a y :: b z :: c 

   现在我们查看表达式的右侧并查看(yz) 。 这意味着我们用z作为参数“调用” y 。 因此，我们“专注”的类型y至y :: c -> d 。 的类型的(yz)然后是(yz) :: d 。 现在我们看到x (yz) 。 所以我们再次将x的类型“特化”为x :: d -> e 。 结果我们得到：

    x :: d -> e y :: c -> d z :: c 

   最后，lambda表达式映射\\xyz -> x (yz) 。 所以这意味着我们在“伪代码”中查看结果类型： type(x) -> type(y) -> type(z) -> type('x (yz)') 。 要么：

    \\xyz -> x (yz) :: (d -> e) -> (c -> d) -> c -> e 

2. 对于第二个表达式，我们首先必须导出(<)的类型：

    Prelude> :t (<) (<) :: Ord a => a -> a -> Bool 

   这是因为(<)是Prelude使用该类型定义的某个地方。

   现在我们知道了，我们可以看一下类型签名。 我们将首先假设x :: b的类型。 现在我们向右看，看到我们调用x (<) 。 所以这意味着我们知道x的类型为Ord a => (a -> a -> Bool) -> c ，我们知道x (<) :: c 。 然后我们再次有一个lambda表达式，正如我们上面所看到的，我们可以解决它：

    (\\x -> x (<)) :: Ord a => ((a -> a -> Bool) -> c) -> c 

3. 最后，对于第三个表达式，让我们先将其重写为：

    (.) (.) (.) 

   这里的第一个 (.)函数原来是. （没有括号），但我们将首先删除操作符语法糖。

   接下来我们将给操作员一个名字（只是为了让我们更方便地命名它们）。 这不是在Haskell允许的，但我们会忽视现在。 我们这样做的原因是稍后引用特定(.)函数的类型：

    (.  ) (.  ) (.  ) 

   接下来我们查找(.)的类型：

    Prelude> :t (.) (.) :: (b -> c) -> (a -> b) -> a -> c 

   所以我们先分配一些类型：

    (.1) :: (b -> c) -> (a -> b) -> a -> c (.2) :: (e -> f) -> (d -> e) -> d -> f (.3) :: (h -> i) -> (g -> h) -> g -> i 

   现在我们需要进一步分析这些类型。 我们用(.2)作为参数调用(.1) ，因此我们知道(b -> c) （ (.1)的第一个参数等价于(e -> f) -> (d -> e) -> d -> f 。这意味着：

    (b -> c) ~ (e -> f) -> (d -> e) -> d -> f 

   由于类型箭头是右关联的 ， (e -> f) -> (d -> e) -> d -> f实际上意味着(e -> f) -> ((d -> e) -> (d -> f)) 。 所以现在我们可以做一个分析：

     b -> c ~ (e -> f) -> ((d -> e) -> (d -> f)) 

   这意味着b ~ (e -> f)和c ~ ((d -> e) -> (d -> f)) 。 所以我们“专门化”我们的第一个(.1) :: (b -> c) -> (a -> b) -> a -> c进入

    (.1) :: ((e -> f) -> ((d -> e) -> (d -> f))) -> (a -> (e -> f)) -> a -> ((d -> e) -> (d -> f)) 

   现在(.1) (.2)的类型是

    (.1) (.2) :: (a -> (e -> f)) -> a -> ((d -> e) -> (d -> f)) 

   但现在我们用(.3)调用该函数，所以我们必须派生((.1) (.2)) (.3) 。 因此，我们必须进行类型解析：

     a -> (e -> f) ~ (h -> i) -> ((g -> h) -> (g -> i)) 

   所以这意味着a ~ (h -> i) ， e ~ (g -> h)和f ~ (g -> i) 。 所以现在我们已经将类型解析为：

    ((.1) (.2)) (.3) :: a -> c = (h -> i) -> ((d -> (g -> h)) -> (d -> (g -> i))) = (h -> i) -> (d -> g -> h) -> d -> g -> i 

   最后一行只是一种语法简化。 如您所见，这映射了我们从ghci派生的类型。

正如您可以看到的所有三个查询我们获得相同的类型（当然类型变量的名称是不同的）。

Answer 2

使用GHC编译器，您可以通过使用类型孔询问类型， _

例如：

thing :: _
thing = (\x -> (<))

收益率：

Found hole ‘_’ with type: t -> a0 -> a0 -> Bool
Where: ‘t’ is a rigid type variable bound by
           the inferred type of thing :: t -> a0 -> a0 -> Bool
           at src/Expat/Data/E.hs:555:1
       ‘a0’ is an ambiguous type variable
To use the inferred type, enable PartialTypeSignatures
In the type signature for ‘thing’: _

我有时会在where子句中使用它来隔离更大函数中的表达式，例如

myFun :: a -> b
myFun a = otherFun thing
  where 
    thing :: _
    thing = (\x -> (<))

您也可以使用孔代替术语。 例如，如果我不确定otherFun到底应该是什么，我可以在_替换。