在Scala中，下划线有哪些用途？

22 浏览
0 Comments

在Scala中，下划线有哪些用途？

我查看了名单上关于scala-lang.org的调查，并注意到一个奇特的问题：“你能列举出“_”的所有用法吗？”你能吗？如果可以，请在这里列出。解释性示例将不胜感激。

admin 更改状态以发布 2023年5月25日
0

2 答案

0 Comments

以下内容来自我在FAQ中的条目（我不保证完整性，我两天前添加了两个条目）：

import scala._    // Wild card -- all of Scala is imported
import scala.{ Predef => _, _ } // Exception, everything except Predef
def f[M[_]]       // Higher kinded type parameter
def f(m: M[_])    // Existential type
_ + _             // Anonymous function placeholder parameter
m _               // Eta expansion of method into method value
m(_)              // Partial function application
_ => 5            // Discarded parameter
case _ =>         // Wild card pattern -- matches anything
val (a, _) = (1, 2) // same thing
for (_ <- 1 to 10)  // same thing
f(xs: _*)         // Sequence xs is passed as multiple parameters to f(ys: T*)
case Seq(xs @ _*) // Identifier xs is bound to the whole matched sequence
var i: Int = _    // Initialization to the default value
def abc_<>!       // An underscore must separate alphanumerics from symbols on identifiers
t._2              // Part of a method name, such as tuple getters
1_000_000         // Numeric literal separator (Scala 2.13+)

这也是这个问题的一部分。

0
0 Comments

我能想到的有：

存在类型

def foo(l: List[Option[_]]) = ...

高阶类型参数

case class A[K[_],T](a: K[T])

被忽略的变量

val _ = 5

被忽略的参数

List(1, 2, 3) foreach { _ => println("Hi") }

被忽略的自类型名称

trait MySeq { _: Seq[_] => }

通配符模式

Some(5) match { case Some(_) => println("Yes") }

内插表达式中的通配符模式

"abc" match { case s"a$_c" => }

序列通配符模式

C(1, 2, 3) match { case C(vs @ _*) => vs.foreach(f(_)) }

通配符导入

import java.util._

隐藏导入

import java.util.{ArrayList => _, _}

将字母和运算符连接起来

def bang_!(x: Int) = 5

赋值运算符

def foo_=(x: Int) { ... }

占位符语法

List(1, 2, 3) map (_ + 2)

方法值

List(1, 2, 3) foreach println _

将按名调用参数转换为函数

def toFunction(callByName: => Int): () => Int = callByName _

默认初始化器

var x: String = _   // unloved syntax may be eliminated

可能还有其他我忘记的！

例子展示为什么foo(_)和foo _是不同的：

这个例子来自0__：

trait PlaceholderExample {
  def process[A](f: A => Unit)
  val set: Set[_ => Unit]
  set.foreach(process _) // Error 
  set.foreach(process(_)) // No Error
}

在第一个情况下，process _表示一个方法；Scala取出多态方法并尝试通过填充类型参数将其变为单态方法，但发现没有类型可以填充到A中，使得得到的类型是(_ => Unit) => ?（存在类型_不是一种类型）。

在第二种情况下，process(_)是一个lambda表达式；当编写一个没有显式参数类型的lambda表达式时，Scala从foreach期望的参数中推断出类型，而_ => Unit是一种类型（而单独的_则不是），因此它可以被替换和推断出来。

这可能是我在Scala中遇到的最棘手的陷阱。

请注意，此示例在2.13中编译。忽略它就像它被分配给下划线一样。

0