使用jedis管道获取值(Getting values with jedis pipeline)

 在第9章第4节“编写新的控制结构”中，Odersky说（所有的拼写错误都是我的）： 
 
 
 
 让客户端代码看起来更像一个内置控制结构的一种方法是使用大括号而不是括号来包围参数列表。 在Scala中只传入一个参数的任何方法调用中，您可以选择使用大括号来包围参数而不是括号。 
 
 
 在第3章“第7步”中，他还谈到了apply ： 
 
 
 
 当您将一个或多个值的括号应用于变量时，Scala会将代码转换为对该变量名为apply的方法的调用。 
 
 
 一起应用这两个规则会导致 
 
Thingy { ... }
 
 被重写入 
 
Thingy( ... )
 
 然后进入 
 
Thingy.apply(...)
 
 它隐含的参数变得更有趣。 例如，对于类型类，通常定义一个如下的apply ： 
 
trait MyTypeClass[A]
object MyTypeClass {
  def apply[A](implicit inst: MyTypeClass[A]) = inst
}
 
 以便值表达式MyTypeClass[Int]解析为MyTypeClass.apply[Int](someImplicitlyInjectedInstance) ，因此是MyTypeClass[Int]类型的值。 因此， MyTypeClass[Int]值和MyTypeClass[Int]类型看起来完全一样。 
 
 
 事实上，没有明确告诉特质也可以有伴侣对象：有很多事情没有被明确地告知。 例如，没有明确告诉你可以在Scala中写下类型lambda表达式，但事实证明你确实可以。 

In Chapter 9, section 4 "Writing new control structures", Odersky says (all typos are mine):
 
 
 
One way in which you can make the client code look a bit more like a built-in control structure is to use curly braces instead of parentheses to surround the argument list. In any method invocation in Scala in which you're passing in exactly one argument, you can opt to use curly braces to surround the argument instead of parentheses.
 
 
In Chapter 3, "Step 7" he also talks about apply:
 
 
 
When you apply parentheses surrounding one or more values to a variable, Scala will transform the code into an invocation of a method named apply on that variable.
 
 
Applying these two rules together results in
 
Thingy { ... }
 
being rewritten into
 
Thingy( ... )
 
and then into 
 
Thingy.apply(...)
 
It gets even funnier with implicit parameters. For example, for typeclasses it is common to define an apply that looks as follows:
 
trait MyTypeClass[A]
object MyTypeClass {
  def apply[A](implicit inst: MyTypeClass[A]) = inst
}
 
so that the value-expression MyTypeClass[Int] desugars into MyTypeClass.apply[Int](someImplicitlyInjectedInstance), and thus is a value of type MyTypeClass[Int]. So, both the value MyTypeClass[Int] and the type MyTypeClass[Int] look exactly the same.
 
 
On the fact that it is not told explicitly that traits can also have companion objects: there are a lot of things that aren't told explicitly. For example, it was not told explicitly that you can write down type-lambdas in Scala, but it turned out that you actually can.