什么是Hindley-Milner?


124

我遇到过这个术语Hindley-Milner,我不确定是否理解它的含义。

我已阅读以下帖子:

但是维基百科中没有一个词条可以为我提供简要的解释。
注意 - 现在已添加一个

它是什么?
哪些语言和工具实现或使用它?
您能提供一个简洁的答案吗?

Answers:


167

Hindley-Milner是由Roger Hindley(正在研究逻辑)和后来的Robin Milner(正在研究编程语言)独立发现的类型系统。Hindley-Milner的优点是

  • 它支持多态功能;例如,一个函数可以为您提供列表的长度,而与元素的类型无关,或者一个函数进行二叉树查找,而与存储在树中的键的类型无关。

  • 有时一个函数或值可以具有多个类型,例如在长度函数的示例中:它可以是“整数列表到整数”,“字符串列表到整数”,“线对列表到整数”等等上。在这种情况下,Hindley-Milner系统的信号优势在于,每个类型良好的术语都具有唯一的“最佳”类型,称为主体类型。列表长度函数的主要类型是“对于任何a,函数从列表a到整数”。这a是所谓的“类型参数”,在lambda演算中显式的,在大多数编程语言中都是隐式的参数多态性。(如果您在ML中编写了长度函数的定义,则可以看到type参数,因此:

     fun 'a length []      = 0
       | 'a length (x::xs) = 1 + length xs
    
  • 如果一个术语具有Hindley-Milner类型,则可以推断主体类型,而无需程序员进行任何类型声明或其他注释。(这是好坏参半的事情,因为任何人都可以证明谁曾经处理过大块的ML代码且没有注释。)

Hindley-Milner是几乎所有静态类型化功能语言的类型系统的基础。此类常用语言包括

所有这些语言都扩展了Hindley-Milner。Haskell,Clean和Objective Caml以雄心勃勃且与众不同的方式做到了这一点。(需要扩展来处理可变变量,因为基本的Hindley-Milner可以使用例如保存未指定类型的值列表的可变单元来颠覆。此类问题通过称为值限制的扩展来解决。)

许多其他次要语言和基于类型化功能语言的工具都使用Hindley-Milner。

Hindley-Milner是System F的限制,它允许更多类型,但需要程序员注释


2
@NormanRamsey我知道这很糟糕,但是感谢您清理无休止地困扰我的事情:每当我提到印度斯坦-米尔纳类型系统时,都会有人在谈论类型推断时大声疾呼,以至于我开始质疑HM是否是类型系统或只是推理算法...三江源是为了我猜维基百科misinforming人们了解这一点,他们甚至混淆我..
吉米·霍法

1
为什么它是参数多态的,而不是简单的多态?您给出的Any的示例,我将其视为多态的示例-多态可以使用子类型代替定义中指定的超类型,而不是参数多态ala C ++,在这种情况下程序员指定实际类型以创建一个新功能。
corazza 2014年

1
@jcora:几年晚,但对于未来的读者的好处:这就是所谓的参数多态性由于物业parametricity,这意味着你将任何类型的,这样的函数的所有实例length :: forall a. [a] -> Int,无论其行为必须相同a-它的不透明; 你对此一无所知。instanceof除非您添加额外的类型约束(Haskell类型类),否则就没有(Java泛型)或“鸭子类型”(C ++模板)。通过参数化,您可以获得有关函数可以/不能做什么的一些很好的证明。
乔恩·珀迪

8

您也许可以使用Google Scholar或CiteSeer或您当地的大学图书馆找到原始论文。第一个已经足够老了,您可能必须找到该日记本的装订本,但我在网上找不到。我为另一个找到的链接已断开,但可能还有其他链接。您当然可以找到引用这些内容的论文。

Hindley,Roger J,《组合逻辑中对象的主体类型方案》,《美国数学学会》,1969年。

米尔纳·罗宾(Milner,Robin),类型多态性理论,计算机与系统科学学报,1978年。




6

C#中的简单Hindley-Milner类型推断实现:

在650行以下C#中对(Lisp-ish)S表达式进行Hindley-Milner类型推断

请注意,该实现仅在C#的270行左右范围内(对于适当的算法W和支持它的少量数据结构而言)。

用法摘录:

    // ...

    var syntax =
        new SExpressionSyntax().
        Include
        (
            // Not-quite-Lisp-indeed; just tolen from our host, C#, as-is
            SExpressionSyntax.Token("\\/\\/.*", SExpressionSyntax.Commenting),
            SExpressionSyntax.Token("false", (token, match) => false),
            SExpressionSyntax.Token("true", (token, match) => true),
            SExpressionSyntax.Token("null", (token, match) => null),

            // Integers (unsigned)
            SExpressionSyntax.Token("[0-9]+", (token, match) => int.Parse(match)),

            // String literals
            SExpressionSyntax.Token("\\\"(\\\\\\n|\\\\t|\\\\n|\\\\r|\\\\\\\"|[^\\\"])*\\\"", (token, match) => match.Substring(1, match.Length - 2)),

            // For identifiers...
            SExpressionSyntax.Token("[\\$_A-Za-z][\\$_0-9A-Za-z\\-]*", SExpressionSyntax.NewSymbol),

            // ... and such
            SExpressionSyntax.Token("[\\!\\&\\|\\<\\=\\>\\+\\-\\*\\/\\%\\:]+", SExpressionSyntax.NewSymbol)
        );

    var system = TypeSystem.Default;
    var env = new Dictionary<string, IType>();

    // Classic
    var @bool = system.NewType(typeof(bool).Name);
    var @int = system.NewType(typeof(int).Name);
    var @string = system.NewType(typeof(string).Name);

    // Generic list of some `item' type : List<item>
    var ItemType = system.NewGeneric();
    var ListType = system.NewType("List", new[] { ItemType });

    // Populate the top level typing environment (aka, the language's "builtins")
    env[@bool.Id] = @bool;
    env[@int.Id] = @int;
    env[@string.Id] = @string;
    env[ListType.Id] = env["nil"] = ListType;

    //...

    Action<object> analyze =
        (ast) =>
        {
            var nodes = (Node[])visitSExpr(ast);
            foreach (var node in nodes)
            {
                try
                {
                    Console.WriteLine();
                    Console.WriteLine("{0} : {1}", node.Id, system.Infer(env, node));
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            Console.WriteLine();
            Console.WriteLine("... Done.");
        };

    // Parse some S-expr (in string representation)
    var source =
        syntax.
        Parse
        (@"
            (
                let
                (
                    // Type inference ""playground""

                    // Classic..                        
                    ( id ( ( x ) => x ) ) // identity

                    ( o ( ( f g ) => ( ( x ) => ( f ( g x ) ) ) ) ) // composition

                    ( factorial ( ( n ) => ( if ( > n 0 ) ( * n ( factorial ( - n 1 ) ) ) 1 ) ) )

                    // More interesting..
                    ( fmap (
                        ( f l ) =>
                        ( if ( empty l )
                            ( : ( f ( head l ) ) ( fmap f ( tail l ) ) )
                            nil
                        )
                    ) )

                    // your own...
                )
                ( )
            )
        ");

    // Visit the parsed S-expr, turn it into a more friendly AST for H-M
    // (see Node, et al, above) and infer some types from the latter
    analyze(source);

    // ...

...产生:

id : Function<`u, `u>

o : Function<Function<`z, `aa>, Function<`y, `z>, Function<`y, `aa>>

factorial : Function<Int32, Int32>

fmap : Function<Function<`au, `ax>, List<`au>, List<`ax>>

... Done.

另请参阅Brian McKenna在bitbucket上的JavaScript实现,这也有助于入门(为我工作)。

'HTH,

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.