【问题标题】:Why Type Check Error are not detected when Pattern Matching on Generic Type in Scala为什么在Scala中对通用类型进行模式匹配时未检测到类型检查错误
【发布时间】:2021-02-27 21:48:51
【问题描述】:

定义如下结构:

sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[A](head: A, tail: List[A]) extends List[A]

和以下函数(请注意,第二行是类型检查错误点也是短路结果的算法错误,但仍然出现了,我想知道为什么类型检查没有发现它)

    def foldRight[A, B] (list: List[A], z: B)(f: (A,B) => B ): B = list match {
        case Nil => z
        case Cons(0, _) => z // problematic line
        case Cons(s, xs) => f(s, foldRight(xs, z) (f))
    }

我知道 scala 也遭受类型擦除,但我很惊讶在这种情况下,这在编译时无法检测到? Cons 在这种情况下是 Cons[A],而 z 显然是 B 类型?

这样的代码实际编译的任何原因?

编辑1

这里https://gist.github.com/jkpl/5279ee05cca8cc1ec452fc26ace5b68b 似乎有一个冗长的解释,但读起来很长。如果有人可以让它更简单:)

【问题讨论】:

  • 我看不出这里有什么问题
  • 出于同样的原因,你可以写def foo(a: Any): Boolean = a match { case 0 => true; case _ => false } 不管你喜不喜欢,Scala 中的模式匹配 非常灵活但不安全。 - 简而言之,由于模式匹配在运行时有效,这种情况只是说如果 A 原来是字面值 0 等于的东西,那么你可以走这条路,否则不行。
  • 嗯,我不确定你是否会关注这个? Any 是一切的祖先,所以是的,应该可以。在这种情况下,这不一样吗?
  • 不,删除后 A 是 Any。如果A 不可能成为AnyVal,那么看看编译器会做什么会很有趣。 - 哈!编译器是smart enough
  • Type-wise A 是一种你一无所知的类型。模式匹配允许您检查您的值是否匹配某个模式 - 等于某个值,属于某个指定的类型 - 即使它对类型一无所知(因为检查某些假设是否正确是模式匹配所做的)。滥用它是一种不好的做法,但它是完全合法的。

标签: scala generics pattern-matching type-inference


【解决方案1】:

为什么做出这些或那些关于语言设计的决定是基于意见的。

在 Scala 规范中是这样写的:

https://scala-lang.org/files/archive/spec/2.13/08-pattern-matching.html#type-parameter-inference-for-constructor-patterns

8.3.2 构造函数模式的类型参数推断

假设构造函数模式?(?1,…,??),其中类?具有类型 参数?1,…,??。这些类型参数在同一个中推断 输入模式的方式(_:?[?1,...,??])。

因此,对于模式 Cons(h, t),Cons[A](h, t) 中的类型参数 A 被推断为模式为 _: Cons[A](由于擦除,在运行时变为 _: Cons[_])。

规范中有如何推断类型的示例

class Term[A]
class Number(val n: Int) extends Term[Int]
def f[B](t: Term[B]): B = t match {
  case y: Number => y.n
}

这里解释了为什么模式y: Number类型参数B(新类型参数B)被推断为Int。

类似地,在我们的例子中,Cons(0, _) 模式(好像是_: Cons[A])A 被推断为Int。

经过typer阶段(scalacOptions ++= Seq("-Xprint:typer", "-Xprint-types"))代码变为

def foldRight[A, B](list: App.List[A], z: B)(f: (A, B) => B): B = list{App.List[A]} match {
  case App.this{App.type}.Nil{App.Nil.type} => z{B}
  case (head: A, tail: App.List[A]): App.Cons[?A1](0{Int(0)}, _{App.List[A]}){App.Cons[?A1]} => z{B}
  case (head: A, tail: App.List[A]): App.Cons[?A2]((s @ _{A}){A}, (xs @ _{App.List[A]}){App.List[A]}){App.Cons[?A2]} => f.apply{(v1: A, v2: B): B}(s{A}, App.this{App.type}.foldRight{[A, B](list: App.List[A], z: B)(f: (A, B) => B): B}[A, B]{(list: App.List[A], z: B)(f: (A, B) => B): B}(xs{App.List[A]}, z{B}){(f: (A, B) => B): B}(f{(A, B) => B}){B}){B}
}{B}

在erasure (scalacOptions += "-Xprint:erasure") 之后变成

def foldRight(list: App$List, z: Object, f: Function2): Object = {
  <synthetic> var rc9: Boolean = false;
  <synthetic> <stable> var x2: App$Cons = (null: App$Cons);
  {
    case <synthetic> val x1: App$List = list;
    case11(){
      if (App$Nil.==(x1))
        matchEnd10(z)
      else
        case12()
    };
    case12(){
      if (x1.$isInstanceOf[App$Cons]())
        {
          rc9 = true;
          x2 = (x1.$asInstanceOf[App$Cons](): App$Cons);
          {
            <synthetic> val p3: Object = x2.head();
            if (scala.Int.box(0).==(p3))
              matchEnd10(z)
            else
              case13()
          }
        }
      else
        case13()
    };
    case13(){
      if (rc9)
        {
          val s: Object = x2.head();
          val xs: App$List = x2.tail();
          matchEnd10(f.apply(s, App.this.foldRight(xs, z, f)))
        }
      else
        case14()
    };
    case14(){
      matchEnd10(throw new MatchError(x1))
    };
    matchEnd10(x: Object){
      x
    }
  }
};

实际上,如果我们将类型参数 a 属于类型类 Eq 和 Num 的信息添加到函数签名的上下文中,即使在 Haskell 中,与您类似的代码也可以编译

https://ideone.com/qqOsI2

data List a = Nil | Cons a (List a)
 
foldRight :: (Eq a, Num a) => List a -> b -> (a -> b -> b) -> b
foldRight list z f = case list of
  Nil -> z
  Cons 0 _ -> z
  Cons s xs -> f s (foldRight xs z f)

类型类不是 Scala 中的一等公民。所以 Scala 不能要求类似 Num 之类的东西(在 Scala 中,一切都可以与 == 进行比较,所以 Eq 是“自动的”)。

【讨论】:

  • 我需要挖掘一点。一如既往地感谢您提供的详细信息。
  • @MaatDeamon 既然您提到了著名的博文“Scala 中模式匹配泛型类型的方法”,也许您也可以对lptk.github.io/programming/2018/12/12/… 感兴趣
【解决方案2】:

Cons 在这种情况下是 Cons[A]

这是不正确的,或者至少是令人困惑的。这里A有两种类型:Cons[A]中的类型参数和foldRight[A,B]中的类型参数。没有什么可以说它们是同一类型。你同样可以定义

case class Cons[Z](head: Z, tail: List[Z]) extends List[Z]

所以在有问题的那一行

case Cons(0, _) => z // problematic line

编译器将此视为Cons[Int](0, _),因为head 的类型是Int。在这种情况下,编译器是混杂的,并且在所有情况下都允许这个match,即使它只有在使用List[Int] 调用foldLeft 时才能成功。

【讨论】:

  • 不同意这两种类型的cmets。定义了数据类型,这是一回事,是的,它与折叠权定义分开。这里的问题完全与修复 A 的 foldright 有关。这就是问题所在。我们修复了 A 并且模式匹配允许我匹配 Bologne 类型,这是不对的....但我知道这是语言的限制
猜你喜欢
  • 2020-06-19
  • 1970-01-01
  • 2013-04-10
  • 1970-01-01
  • 2014-10-12
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2013-12-18
相关资源
最近更新 更多