`PartialFunction extends Function` 是否违反了 LSP？

Question

里氏替换原则指出

如果S 是T 的子类型，则T 类型的对象可以替换为S 类型的对象，而不会改变该程序的任何所需属性。

但是，在 Scala 中，PartialFunction 并非在所有情况下都适用/定义。

trait Function1 {
  def apply(x: A): R
}

trait PartialFunction extends Function1 {
  def apply(x: A): R
  def isDefinedAt(x: A): Boolean
}

如果您将PartialFunction 应用于未定义的值，您将收到异常。

在 scala 中创建PartialFunction 的一种便捷方法是使用模式匹配。这样做，您会收到未定义值的 MatchError。

val fn:Function1[String, Int] = s => s.length

val pf:PartialFunction[String, Int] = {
  case "one" => 3
}

def program(f:Function1[String, Int], s:String):(Boolean, Int) = (
  f.isInstanceOf[Function1[String, Int]], f(s)
)

program(fn, "one") == program(pf, "one")
program(fn, "two") == program(pf, "two")

fn: String => Int =

pf: PartialFunction[String,Int] =

程序：程序[](val f: String => Int,val s: String) => (Boolean, Int)

res0: Boolean = true

scala.MatchError: 两个（属于 java.lang.String 类）

  在 scala.PartialFunction$$anon$1.apply(delme.sc:249)

  在 scala.PartialFunction$$anon$1.apply(delme.sc:247)

  在 ...

fn 和 pf 都是 Function1 的子类型，但我不能在不更改 program 的情况下将 fn 替换为 pf。所以在我看来，这违反了 LSP。

你怎么看？

Answer 1

fn 和pf 不是Function1 的子类型，因为它们根本不是类型。它们是值，LSP 并没有说你可以取T 类型的任何对象并将其替换为S 类型的任何对象：Int 肯定是Int 的子类型，但是将1 替换为2 可以使正确的程序不正确。

PartialFunction[String, Int] 是Function1[String, Int] 的子类型，但Function1 的合约并没有禁止apply 抛出异常，实际上明确允许它：

将此函数的主体应用于参数。 可能会抛出异常。

因此，如果您的程序可以处理 Function1[A, B] 类型的对象，它必须已经以某种方式处理 apply 抛出异常，而 PartialFunction 抛出 MatchError 只是一个特定情况。

Answer 2

根据维基百科，LSP 需要一个附加条款才能应用。

子类型的方法不应抛出新的异常，除非这些异常本身是超类型方法抛出的异常的子类型。

所以（假设维基百科是正确的），没有 PartialFunction 不违反 LSP，因为它不适用于这种情况。

编辑：scaladoc 中有附加信息：(Scaladoc Function1)

请注意，Function1 没有定义一个总函数，PartialFunction 的存在可能暗示了这一点。 Function1 和 PartialFunction 之间的唯一区别是后者可以指定它不会处理的输入。

所以另一种思考方式是 pf 不是 fn 的子类型。

fn: 字符串 => 整数

pf: String 的子集 => Int

针对评论的进一步编辑： 不，我认为 LSP 根本不适用。应用 S 的 LSP 不能抛出新的异常。这里的 S 确实抛出了新的异常，因此 LSP 不能被违反，因为它不适用。