关于输入：Scala是否有像ML这样的值限制，如果不是，为什么呢？

Does Scala have a value restriction like ML, if not then why?

这是我对这个问题的看法。有人能证实、否认或详细说明吗？

我写道：

Scala doesn’t unify covariant List[A] with a GLB ? assigned to List[Int], bcz afaics in subtyping"biunification" the direction of assignment matters. Thus None must have type Option[⊥] (i.e. Option[Nothing]), ditto Nil type List[Nothing] which can’t accept assignment from an Option[Int] or List[Int] respectively. So the value restriction problem originates from directionless unification and global biunification was thought to be undecidable until the recent research linked above.

您可能希望查看上述评论的上下文。

ML的值限制将不允许在(以前被认为是罕见的，但可能更普遍的)情况下进行参数多态，否则这样做是合理的(即类型安全的)，例如，特别是对于部分应用课程函数(这在函数式编程中很重要)，因为可选的类型解决方案创建了一个功能和命令式编程之间的分层以及模块化抽象类型的中断封装。哈斯克尔有一个类似的双重单态限制。在某些情况下，OCAML可以放松限制。我详细阐述了其中的一些细节。

编辑：我在上面的引语中表达的原始直觉(值限制可以通过子类型消除)是不正确的。我的答案很好地阐明了这个问题，我无法决定在包含亚历克赛、安德烈亚斯或我的答案的集合中，哪一个是最好的答案。我觉得他们都是值得的。

正如我前面所解释的，当您将参数多态性与可变引用(或某些其他效果)结合起来时，就需要进行值限制(或类似的事情)。这完全独立于语言是否有类型推断，或者语言是否允许子类型。一个典型的反例

1
2
3

let r : ?A.Ref(List(A)) = ref [] in
r := ["boo"];
head(!r) + 1

不受删除类型批注的能力或向量化类型添加绑定的能力的影响。

因此，当您添加对f<：的引用时，您需要施加一个值限制，以避免失去可靠性。同样，MLSUB也无法摆脱价值限制。scala已经通过其语法强制了一个值限制，因为甚至没有办法编写一个具有多态类型的值的定义。

相关讨论

很抱歉，有点争论，但是scala的语法并不能阻止我编写val r : List[A] = Nil，但是类型检查程序会抱怨"找不到：类型A"。然而，scala并没有强制执行在ml中看到的其他值限制，例如，当我在repl def id[A](x:A):A = xdef f[A](x:A):A = id(id(x))中成功编译时所观察到的。
@谢尔比穆雷伊，你不能用scala写的等价物是var r[A] : List[A] = Nil。def形式总是定义一个函数，因此不需要任何进一步的限制。
研究一个例子，我现在同意这个问题并不是由于缺少子类型、推理或注释而产生的，而是仅仅因为let绑定能够在函数外部实例化r(仅一次)，而在函数的参数多态性中在词汇范围内。也许这就是你所说的"参数多态性和可变引用"的语法组合？暗示scala不是参数多态的吗？scala有可变的引用，那么scala没有哪一个标准？
@ShelbyMooreiii，scala两者都有，它有一个包含价值限制的句法限制，见上面的注释。
如果在scala中，我将var r : List[A]放在A上参数化的函数的词法范围内，那么A对于该函数类型变量的每一个量化都是多态的w.r.t，即从外部词法范围调用(即应用)该函数。我认为你的意图是，即使在内部词汇量范围内，var r : ?A.List[A](又名var r[A] : List[A])对上述功能的每一个应用都是多态的w.r.t.？那么，let绑定是一个与memoization隐式闭包无关的细节？我现在明白了吗？
@ShelbyMooreiii，更准确地说，前者不是一个多态值，而是一个周围类型或类型参数范围内的单态值。这没有问题，这正是ML中的值限制所产生的结果。我不理解您关于let绑定的问题，但是闭包和内存化在语义上是不相关的实现细节。
TY。我知道你是专家，但从理论上讲，它和(函数的类型变量)函数一样具有多态性，我怀疑你会说类型参数化函数不是参数化多态性。单态似乎是一个超负荷的术语(通常意味着在不改变不变形状的情况下专门化函数实现)，因此IMO并不是一个外行的描述性术语。你说scala的限制是完全相同的，但我已经在我第一次对miltonml限制的评论中展示了一个在scala中不适用的例子。我很感兴趣，如果有人知道这两种方法之间的权衡是什么？
oic，我为scala提供的例子是内在地进行val id: 'a -> 'a = fn x => xval f: 'a -> 'a = fn z => (id id) z的eta扩展，它也不受ml值限制。问题是id id的评估和记忆顺序，其中val f: 'a -> 'a = id id在构建f时只评估一次id。那么scala的设计选择是否和ml中的值限制一样严格？或者它正是价值限制？
@ShelbyMooreiii，我说scala的句法限制包含了值限制，所以它更强大：在ml中，我可以将let l = []定义为一个多态值，这很好，但在scala中我不能。单态完全没有过载，它是由类型变量的绑定器/量词的位置定义的。当某事物有一个量化的类型时，它就是多态的。不幸的是，ML通常不会使量词在其语法中显式，只在其类型规则中显式。
我对scala中没有多态值感到困惑(主要是因为我缺乏scala和ml的语法+语义方面的经验)的根源是因为我没有辨别出val r[A] : List[A] = Nil的不可用性与val f[A] : A -> A = id(id)的限制相同，因为我没有意识到隐含的eta扩展等价性。在scala中使用def f[A](x:A):A = id(id(x))时。所以scala更严格，更规则，不允许上述任何一个值，而ml允许前者在某些情况下，但并非所有情况下都是安全的。
oic如果在函数调用点对类型参数A进行量化，则函数体中的val r : List[A]对函数是单态的w.r.t，A的多态性仅对不可分割的函数有效。因此，在AdHoc多态性(特别是C++模板的专用化)中调用函数的类型集的单形化专门化意味着该函数的主体是多态性的单形W.R.T。存在主义(又称rust的特征对象)将类边界绑定到对象(而不是函数)上，因此动态调度(多态性)不能使函数单态化。
我假设绝大多数程序员都觉得这些细节令人困惑，因此我假设我们需要对概念进行简化，以使这些PLS成为主流。斯卡拉的限制更为规则是K.I.S.S.原则。另外，我从来没有使用过ML，直到昨天才第一次使用了ML repl(也就是说，我在阅读之前的示例/规范时一直在脑子里做这一切)。而斯卡拉，这些年来我只玩过一个开着又关着的回复。即使从1999开始我还没有更新我的C++经验。我是因为对scala和ml几乎完全没有经验而来的。
谢谢你帮助我了解这个问题。仅供参考，我已经完全重写了我的答案，以收集我获得的理解。如果您有时间和兴趣的话，也许您可以检查它是否有错误。我现在的问题是，我不知道选择哪一个答案是最好的，我在回答的开头部分对比了这三个答案的优点。干杯。希望我们的努力能成为读者的学习资源。

比那简单多了。在scala中，值不能有多态类型，只有方法可以。例如，如果你写

1	val id = x => x

它的类型不是[A] A => A。

如果你采用多态的方法，例如

1	def id[A](x: A): A = x

并尝试将其赋值

1	val id1 = id

编译器将再次尝试(在本例中失败)推断特定的A，而不是创建多态值。

所以这个问题没有出现。

编辑：

如果你试图复制http://mlton.org/value restriction u替代品来代替scala中的"值限制"示例，你遇到的问题并不是缺乏let：val与之完全对应。但你需要这样的东西

1
2
3
4

val f[A]: A => A = {
var r: Option[A] = None
{ x => ... }
}

这是违法的。如果你写了def f[A]: A => A = ...，这是合法的，但是每次通话都会创建一个新的r。以毫升计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

val f: unit -> ('a -> 'a) =
fn () =>
let
val r: 'a option ref = ref NONE
in
fn x =>
let
val y = !r
val () = r := SOME x
in
case y of
NONE => x
| SOME y => y
end
end

val _ = f () 13
val _ = f ()"foo"

值限制允许的值。

也就是说，scala的规则等价于只允许lambda作为ML中的多态值，而不允许任何值限制。

相关讨论

1。但没有明确说明值是受限制的"它在"3.3非值类型"2"下。即的子类型和？"的超类型正好相反3。[A >: Nothing <: Any]不是推断类型，它是它的一部分，就像Int =>不是类型一样。
此外，还有带有子类型的ML版本，例如lambda-the-ultimate.org/node/5393。它不影响多态值："由于MLSUB的类型规则只是具有额外(子)规则的ML的类型规则，因此在ML中可键入的任何表达式在具有相同类型的MLSUB中都是可键入的。"
你在哪里写的"正好相反"，你指的是一个打字错误，我把和？但这一修正并不能排除我的"无法填充"的说法。当我之前回答时，我想你可能指的是List[A]型，它的协方差限制方向与A相反。刚刚注意到打字错误。谢谢。但是我已经解释过，结合我的答案，没有办法用List[A]的类型来构造一个值，这样A的类型就是[A >: Nothing <: Any]。正如您所暗示的，该类型只在函数的上下文中有意义。
"ml型'a list ref不是多态值'a的类型"，"A的类型是[A >: Nothing <: Any]的类型"对我来说似乎是类别错误：甚至是错误的。'a和A是类型变量，而不是表达式，它们没有类型。
不过，'a list是一种多态值[]的类型(方案)。
我已经添加了一个解释，说明该示例如何在scala中工作，并更直接地比较了scala的"无多态值"限制和值限制。
您添加的引用r的一个新实例的示例是为类型变量A的每个量化创建的，它消除了scala&ml中的类型安全问题。ml的特性(scala中不可用)声明了一个引用类型，该引用类型通过其词法范围(甚至由于在所述范围内的重新应用)进行量化。如果r的构造的评估顺序不在上述重新应用的范围内(例如let绑定)，则不会创建新的实例。
我删除了我那些吵闹的评论，但它们都存档了。你的解释使我困惑。安德烈亚斯最后向我澄清了他将val r[A] : List[A](又称?A.List[A])与val r : List[A])区分开来，从而强调了词汇范围的量化。现在，我试图了解ML在这个特性上有哪些优点和缺点，以及scala没有这个特性时各自的权衡？你能详细解释一下吗？
我对scala中没有多态值感到困惑(主要是因为我缺乏scala和ml的语法+语义方面的经验)的最初原因是因为我没有辨别出val r[A] : List[A] = Nil的不可用性与val f[A] : A -> A = id(id)的限制相同，因为我没有意识到隐含的eta扩展等价性和在scala中使用def f[A](x:A):A = id(id(x))。所以scala更严格，更规则，不允许上述任何一个值，而ml允许前者在某些情况下，但并非所有情况下都是安全的。
谢谢你帮助我了解这个问题。仅供参考，我已经完全重写了我的答案，以收集我获得的理解。如果您有时间和兴趣的话，也许您可以检查它是否有错误。我现在的问题是，我不知道选择哪一个答案是最好的，我在回答的开头部分对比了这三个答案的优点。干杯。希望我们的努力能成为读者的学习资源。

编辑：此答案以前不正确。我已经完全重写了下面的解释，以便从安德烈亚斯和亚历克赛的回答下面的评论中获得新的理解。好的。

_{The edit history and the history of archives of this page at archive.is provides a recording of my previous mission and discussion.我选择编辑而不是删除并编写新答案的另一个原因是保留对此答案的评论。在我看来，这个答案仍然是需要的，因为尽管亚历克赛正确、最简洁地回答了主题，但安德烈亚斯的阐述对我获得理解是最有帮助的，但我认为外行读者可能需要一个不同的、更全面的(但希望仍然是生成的本质)解释，以便快速获得一些DEP。理解这个问题。另外，我认为其他的答案掩盖了一个整体性的解释是多么复杂，我希望天真的读者可以选择去品味它。我发现之前的解释并不是用英语描述所有细节，而是(数学家为了提高效率而做的)依靠读者从符号编程语言示例和前提域知识的细微差别中辨别细节(例如，关于编程语言设计的背景事实)。_好的。}

值限制出现在referenced1类型参数化对象2的突变处。在下面的MLTON代码示例中演示了在没有值限制的情况下会导致的类型不安全：好的。

1
2
3
4
5

val r: 'a option ref = ref NONE
val r1: string option ref = r
val r2: int option ref = r
val () = r1 := SOME"foo"
val v: int = valOf (!r2)

r引用的对象中包含的NONE值(类似于null的值)可以分配给类型参数'a的任何具体类型的引用，因为r具有多态类型a'。这将允许类型不安全，因为如上面的示例所示，由r引用的同一对象(已分配给string option ref和int option ref)可以通过r1引用使用string值写入(即突变)，然后通过r2引用读取为int值。值限制为上述示例生成编译器错误。好的。

一种类型复杂的情况出现，以防止(重新)量化(即绑定或确定)所述引用(及其指向的对象)的类型参数(aka类型变量)到一个类型，当重用先前用不同类型量化的所述引用的实例时，该类型会有所不同。好的。

例如，连续函数应用程序(aka调用)重用此类引用的同一个实例时，就会出现这种情况(可以说是令人困惑和费解)。iow，每次应用函数时，引用的类型参数(与对象相关)都被(重新)量化的情况，但是相同的引用实例(及其指向的对象)被重用到函数的每个后续应用(和量化)中。好的。

相切地说，这些现象的出现有时是不直观的，因为缺乏明确的通用量词？(由于隐含的rank-1 prenex词法范围量化可以通过构造(如let或协程)从词法评估顺序中去除，并且可以说，当ml的值限制中可能出现不安全的情况时，更大的不规则性(与scala相比)：好的。

安德烈亚斯写道：好的。

Unfortunately, ML does not usually make the quantifiers explicit in its syntax, only in its typing rules.

Ok.

例如，对于与数学符号类似的let表达式来说，重用引用的对象是需要的，它应该只创建和计算一次替换的实例化，即使它们在in子句中可能在词汇上被多次替换。因此，例如，如果函数应用程序在in子句中被评估为(无论是否在词法上)，而每个应用程序的替换类型参数被重新量化(因为替换的实例化仅在词法上在函数应用程序中)，那么类型安全性可以是los。如果应用程序没有全部强制只量化一次有问题的类型参数(即，不允许有问题的类型参数是多态的)，则不会。好的。

值限制是ML的折衷，它可以防止所有不安全的情况，同时也可以防止一些(以前被认为是罕见的)安全的情况，从而简化类型系统。价值限制被认为是一个更好的折衷方案，因为早期(过时？)使用更复杂的类型方法的经验没有限制任何或多个安全案例，导致了命令式编程和纯函数式编程(又称应用程序)之间的分歧，并且泄漏了ML函数模块中抽象类型的一些封装。我引用了一些资料，并在这里详细阐述。不过，切题地说，我在思考早期反对分歧的论点是否真的能站起来反对这样一个事实：名字调用根本不需要值限制(例如，haskell-sique lazy evaluation，当它也被需要记忆时)，因为概念上的部分应用程序不会在已经被评估的状态上形成闭包；以及-模块化组合推理需要名称，当与纯度结合时，模块化(范畴理论和等式推理)控制和效果组合。反对按名称调用的单变形限制参数实际上是关于强制类型注释的，但是当需要最佳记忆化(aka sharing)时，显式的说明就不那么麻烦了，因为模块化和可读性无论如何都需要所述注释。按值调用是一种精细的齿梳级别的控制，因此当我们需要低级别的控制时，也许我们应该接受值限制，因为更复杂的类型允许的罕见情况在命令式和应用式设置中会不太有用。但是，我不知道这两者是否可以以平滑/优雅的方式在相同的编程语言中分层/分离。代数效应可以在cbv语言(如ml)中实现，并且可以消除值限制。如果值限制影响到代码，可能是因为编程语言和库缺少处理效果的合适元模型。好的。

scala对所有这些引用都进行了语法限制，这是一种折衷，例如限制与ML的值限制相同甚至更多的情况(如果不限制的话是安全的)，但在我们不会为与值限制相关的错误消息感到头疼的意义上，它更为规则。在scala中，我们永远不允许创建这样的引用。因此，在scala中，我们只能表示当引用的类型参数被量化时创建新引用实例的情况。注：OCAML在某些情况下放宽了值限制。好的。

注意，scala和ml都不能声明引用是不可变的1，尽管它们指向的对象可以用val声明为不可变的。注意，没有必要对不能改变的引用进行限制。好的。型

为了使复杂的类型出现，需要引用类型1的可变性的原因是，如果我们用一个非参数化的对象(即不是None或Nil4，而是例如Option[String]或EDOCX1〔4)来实例化引用(例如，let的substitutions子句)。，那么引用就没有多态类型(与它指向的对象相关)，因此再量化问题就不会出现。因此，有问题的情况是，先实例化一个多态对象，然后在重新量化的上下文中分配一个新量化的对象(即改变引用类型)，然后在随后的重新量化的上下文中取消引用(读取)引用(指向的对象)。如前所述，当重新量化的类型参数发生冲突时，会出现类型并发症，必须防止/限制不安全的情况。好的。型

啊！如果你不复习相关的例子就理解了这一点，我会印象深刻。好的。型

1_{imo改为使用短语"可变引用"而不是"被引用对象的可变性"，"引用类型的可变性"将更容易混淆，因为我们的目的是改变对象的值(及其类型)，而该值由指针引用-而不是指指针的可变性。指的是什么。有些编程语言甚至不能明确区分什么时候不允许在基元类型的情况下改变引用或它们指向的对象。_好的。型}

2_{其中一个对象甚至可以是一个函数，在允许一级函数的编程语言中。_好的。型}

3_{以防止运行时由于访问(读取或写入)被引用对象而出现分段错误，并假定该对象为静态(即编译时)确定的类型，该类型不是对象实际拥有的类型。_好的。型}

4_{which are Noneand []respectively in ml._{好的。型好啊。}}