基础：

Question

Scala中语法糖的所有实例是什么？

它们很难搜索，因为它们大部分/全部都是纯粹的符号，因此在不知道概念名称的情况下难以搜索。

TODO：

隐含转化
_匿名函数的语法
我忘记的其他事情

Answer 1

基础：

a b相当于a.b
a b c相当于a.b(c)，除非b以:结尾。在这种情况下，a b c相当于c.b(a)
a(b)相当于a.apply(b)这就是为什么匿名函数的以下定义是相同的： val square1 =（x：Int）=＆gt; X X val square2 = new Function1 [Int，Int] { def apply（x：Int）= x x }

在致电square1(y)时，您实际上正在调用square1.apply(y) square1必须拥有的Function1特征（或Function2等等）... ）
a(b) = c相当于a.update(b,c)同样，a(b,c) = d相当于a.update(b,c,d)，依此类推。

a.b = c相当于a.b_=(c)。在类/对象中创建val / var x时，Scala会为您创建方法x和x_=。您可以自己定义，但如果您定义y_=，必须定义y，否则它将无法编译，例如，

scala> val b = new Object{ def set_=(a: Int) = println(a) }
b: java.lang.Object{def set_=(Int): Unit} = $anon$1@17e4cec

scala> b.set = 5
<console>:6: error: value set is not a member of java.lang.Object{def set_=(Int): Unit}
       b.set = 5
         ^

scala> val c = new Object{ def set = 0 ; def set_=(a:Int) = println(a) }
c: java.lang.Object{def set: Int; def set_=(Int): Unit} = $anon$1@95a253

scala> c.set = 5
5

-a对应a.unary_-同样适用于+a，~a和!a

a <operator>= b，其中<operator>是一组特殊字符，仅相当于a = a <operator> b ，如果a没有使用<operator>=方法，例如，

class test(val x:Int) {
    def %%(y: Int) = new test(x*y)
}

var a = new test(10)
a.x // 10
a %%= 5 //Equivalent to a = a %% 5
a.x // 50

Answer 2

除了Jaxkson的回答：

type F[A,B]可用作A F B。

例如：

type ->[A,B] = (A,B)
def foo(f: String -> String)

在方法定义中使用=> type会使编译器在方法调用中将表达式包装在函数thunk中。

例如

def until(cond: => Boolean)(body: => Unit) = while(!cond) body

var a = 0
until (a > 5) {a += 1}

Answer 3

特殊类：元组和符号

如Rahul G所述，元组和符号的语法略有特殊。

符号：语法'x是Symbol("x")
元组：(p1,p2,..,pn)是案例类Tuplen[T1,T2,..,Tn](p1,p2,..,pn)

例如，以下两个是等效的。

val tuple1 = ("Hello",1)
val tuple2 = Tuple2[String,Int]("Hello",1)

Answer 4

提取器：

提取器有两种方法，unapply和unapplySeq。这些用于多个变量赋值和模式匹配。

第一个用例是unapply接受它应该匹配的对象，并根据它是否匹配返回Boolean，例如

trait Gender
trait Male extends Gender
trait Female extends Gender
object Male extends Male
object Female extends Female
class Person(val g: Gender, val age: Int)

object Adult {
    def unapply(p: Person) = p.age >= 18
}

def check(p: Person) = p match {
    case Adult() => println("An Adult")
    case _ => println("A Child")
}

//Will print: An Adult since Adult.unapply returns true.
check(new Person(Female, 18))

//Will print: A Child as it falls through to the _ case.
check(new Person(Male, 17))

老实说，我并没有真正达到上述语法的目的，因为只需将代码放在case语句中就可以轻松完成。当然，如果你有一个更好的例子，请在下面留下评论

unapply获取一些固定数量参数并返回单个参数的Option[T]或多个Option[(p1,p2,...)]的一般情况，即带有匹配的值，例如，从上面的代码继续：

object Person {
    def apply(g: Gender, age: Int) = new Person(g, age)
    def unapply(p: Person) = if(p.age < 0) None else Some((p.g, p.age))
}

//Using Person.apply as described in the Basics section
val alice = Person(Female, 30)
val bob = Person(Male, 25)

//This calls Person.unapply(alice), which returns Some((Female, 30)).
//alice_gender is assigned Female and alice_age 30.
val Person(alice_gender, alice_age) = alice

bob match {
    //Calls Person.unapply(bob), but sees that g is Male, so no match.
    case Person(Female, _) => println("Hello ma'am")
    //Calls Person.unapply(bob) and assigns age = bob.age, but it doesn't pass
    //the 'if' statement, so it doesn't match here either.
    case Person(Male, age) if age < 18 => println("Hey dude")
    //So bob falls through to here
    case _ => println("Hello Sir")
}

Person(Male,-1) match {
    //Person.unapply(Person.apply(Male,-1)) returns None because p.age < 0.
    //Therefore this case will not match.
    case Person(_, _) => println("Hello person")
    //Thus it falls through to here.
    case _ => println("Are you Human?")
}

注意： Case classes为您执行所有apply / unapply定义（以及其他内容），因此请尽可能使用它们以节省时间和减少代码。

unapplySeq。这与上面的unapply类似，但它必须返回某种序列的Option。

作为一个简单的例子，

scala> List.unapplySeq(List(1,2,3))
res2: Some[List[Int]] = Some(List(1, 2, 3))

Answer 5

匿名函数：

_ + _是(a, b) => a + b

的缩写

Answer 6

上下文将desugar限制为implicit个参数，例如考虑一个利用Monoid类型类的函数：

def suml[T: Monoid](xs: List[T]) = {
  val T = implicitly[Monoid[T]]
  xs.foldLeft(T.mzero)(T.mplus)
}

其中: Monoid部分是上下文绑定，转换为：

def suml[T](xs: List[T])(implicit evidence$1: Monoid[T]]) = {
  ...
}

因此以下编译：

def suml[T: Monoid](xs: List[T]) = {
  val T = evidence$1
  ...
}

Scala中语法糖的所有实例是什么？

6 个答案:

基础：

特殊类：元组和符号

提取器：