function - Core Haskell 将类型应用于函数意味着什么？

Question

我为 Core Haskell 编写了一个自定义的 pretty-print ，以便更好地研究 Core 的结构。这台 pretty-print 的要点是它需要 CoreModule并在输出中包含数据构造函数，默认的 Outputable 实现似乎没有这样做。

这是我运行 pretty-print 的模块的代码:

module Bar2 where

add :: Int -> Int -> Int
add a b = a + b

add2 a b = a + b

这是 pretty-print 输出:

------------------------------- Module Metadata --------------------------------
Module { "main" :: modulePackageId, "Bar2" :: moduleName }
-------------------------------- Type Bindings ---------------------------------
[r0 :-> Identifier ‘add’, rjH :-> Identifier ‘add2’]
-------------------------------- Core Bindings ---------------------------------
NonRec (Id "add2")
       (Lam (TyVar "a")
            (Lam (Id "$dNum")
                 (Lam (Id "a1")
                      (Lam (Id "b")
                           (App (App (App (App (Var (Id "+"))
                                               (Type (TyVar (TyVar "a"))))
                                          (Var (Id "$dNum")))
                                     (Var (Id "a1")))
                                (Var (Id "b")))))))

NonRec (Id "add")
       (Lam (Id "a")
            (Lam (Id "b")
                 (App (App (App (App (Var (Id "+"))
                                     (Type (TyConApp (Int) [])))
                                (Var (Id "$fNumInt")))
                           (Var (Id "a")))
                      (Var (Id "b")))))
--------------------------------- Safe Haskell ---------------------------------
Safe
------------------------------------- End --------------------------------------

令我困惑的是，在这两种情况下，Core 似乎都将类型变量或类型构造函数应用于 + 函数，以及一些 $dNum 或 $fNumInt 在接受参数之前。

对于 add 函数，类型也是显式给出的，而 add2 则留给编译器推断。这似乎也会影响 lambda 函数链求值所需的参数数量，add 需要 2 个，而 add2 需要 4 个。

这一切意味着什么？

Answer 1

核心几乎是SystemF (从技术上讲SystemFC)。在 SystemF 中，类型变量也需要作为函数的参数。在你的例子中，Haskell 推断

add2 :: Num a => a -> a -> a 
add2 a b = a + b

这解释了TyVar "a" add2 的参数.

此外，Haskell 必须找到一种方法来分派(dispatch)到“正确”的 Num 集。函数取决于参数的类型 a和b是。它通过为每个类型类约束提供一个字典参数来实现这一点。这就是Id $dNum争论。以add为例, Haskell 已经知道哪个字典合适 (+)可以找到该函数，因为它知道该操作位于 Int (所以不需要传入:它只是 $fNumInt )。

本质上，在幕后发生的事情是，Haskell 为每个类型类创建一条记录 data $d<Class> = ...字段是类型类内的函数。然后，对于每个实例，它都会生成另一个 $f<Class><Type> :: $d<Class> 。 This is explained in more detail here

Here is another excellent answer describing Core related things.