相关疑难解决方法(0)

我见过一个implicitly在Scala示例中使用的函数.它是什么,它是如何使用的？

这里的例子:

scala> sealed trait Foo[T] { def apply(list : List[T]) : Unit }; object Foo {
     |                         implicit def stringImpl = new Foo[String] {
     |                             def apply(list : List[String]) = println("String")
     |                         }
     |                         implicit def intImpl = new Foo[Int] {
     |                             def apply(list : List[Int]) =  println("Int")
     |                         }
     |                     } ; def foo[A : Foo](x : List[A]) = implicitly[Foo[A]].apply(x)
defined trait Foo
defined module Foo
foo: [A](x: List[A])(implicit evidence$1: Foo[A])Unit

scala> foo(1)
<console>:8: error: …

说我有以下两个case classes:

case class Address(street: String, city: String, state: String, zipCode: Int)
case class Person(firstName: String, lastName: String, address: Address)

和以下Person类的实例:

val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg", 
                                           "Mumbai", 
                                           "Maharashtra", 
                                           411342))

现在,如果我想更新zipCode,raj那么我将不得不做:

val updatedRaj = raj.copy(address = raj.address.copy(zipCode = raj.address.zipCode + 1))

随着嵌套水平的提高,这将变得更加丑陋.是否有更清洁的方式(像Clojure的东西update-in)来更新这样的嵌套结构？

通过Scala 2.8 Predef类,我发现有一种"本地"方法.尽管我可以说,它与Predef.identity相同,只是有"@inline"注释.它有什么用,为什么它在Predef中很重要(因此可以在Scala的任何地方使用)？

我理解Scala中的隐式参数和隐式转换,但我今天第一次看到这个:匿名函数中参数前面的隐式关键字:

Action { implicit request =>
  Ok("Got request [" + request + "]")
}

隐式关键字在这里做什么？

网络上是否有资源可以更详细地描述用例？

尽管多次阅读"Scala编程",我仍然经常发现书中未解释的重要Scala结构,如

@uncheckedVariance
@specialized

和其他奇怪的结构一样

new { ... }  // No class name!

等等.

考虑到这本书是由斯卡拉"发明家"本人和其他人写的,我觉得这很令人沮丧.

我试图阅读语言规范,但它是为学者而不是练习程序员.它让我头晕目眩.

在Scala中有"Everything"编程的网站"没有告诉你"吗？

还有是日常斯卡拉博客,但它在一年前去世了.

Scala允许关闭

def newCounter = {
  var a=0
  () => {a+=1;a}
}

它定义了在每次调用返回一个新的独立的反函数开始一个函数1:

scala> val counter1 = newCounter
counter1: () => Int = <function0>

scala> counter1()
res0: Int = 1

scala> counter1()
res1: Int = 2

scala> val counter2 = newCounter
counter2: () => Int = <function0>

scala> counter2()
res2: Int = 1

scala> counter1()
res3: Int = 3

这是非常令人印象深刻的,因为通常a会在newCounter的堆栈帧上代表内存地址.我刚刚阅读了"Scala编程"的封闭章节,并且在此事上只有以下内容(第155页):

Scala编译器在这种情况下重新排列事物,以便捕获的参数在堆上而不是堆栈中存在,因此可以比创建它的方法调用更长.这种重新安排都是自动完成的,因此您不必担心.

任何人都可以详细说明它如何在字节码级别上工作？访问是否类似于具有所有相关同步和性能影响的类的成员变量？

在此链接:https://stackoverflow.com/a/4055850/82609

它解释了这一点

case class Person(name: String, age: Int) {
   override def productPrefix = "person: "
}

// prints "person: (Aaron,28)" instead of "Person(Aaron, 28)"
println(Person("Aaron", 28)) 

有没有办法做一些事情,比如将case类与一些trait混合,提供比默认值更好的ToString？

我真的不喜欢没有打印字段名称,对于大型案例类,有时很难阅读日志.

是否有可能有这样的输出？

Person(
  name="Aaron",
  age=28
)

我正在学习斯卡拉.感谢Odersky和所有其他作者的出色工作,这是非常有前途的.

我把一个欧拉问题(http://projecteuler.net/)带到了一个更加极小的例子.而我正试图以功能的方式.所以这不是"请立即回答我,否则我的老板会杀了我",但是"如果你有时间,请你帮助一位势在必行的语言程序员去实现功能世界吗？"

问题:我想要一个扑克牌课.一个扑克之手是由一些卡片组成的,从0到5.我想建立一个卡片列表,这就是:我的Hand类将是不可变的,如果我想添加一张卡片,那么我创建了一个新的Hand对象.所以我需要一个可以创建为"val"的Card集合,而不是var.第一步:构造函数,每个卡数一个.但是Card的集合在每个构造函数中处理,所以我必须将它作为var!

这是代码,Card类只是一个Suit和一个Value,作为一个字符串传递给构造函数("5S"是黑桃的5个):

class Hand(mycards : List[Card]) {
  // this should be val, I guess
  private var cards : List[Card] = {
    if (mycards.length>5)
      throw new IllegalArgumentException(
        "Illegal number of cards: " + mycards.length);
    sortCards(mycards)
  }

  // full hand constructor
  def this(a : String, b : String, c : String, d : String, e : String) = {
      this(Nil)

      // assign cards
      val cardBuffer = new ListBuffer[Card]()
      if ( a!=null ) cardBuffer += new Card(a)
      if ( …

我使用以下代码来满足我的需求:

 (1 to 5)..map(i => s"\\x${i}")  // Produces List("\\x1", "\\x2", "\\x3", "\\x4", "\\x5")

但我想使用占位符.根据字符串插补器文档:

(1 to 5).map(s"\\x${_}")

应该扩展到:

(1 to 5).map(StringContext("\\\\x","").s(_))

但后者的作品,而不是前者,这将引发error: unbound placeholder parameter上_.为什么？

我可以理解如何使用隐式参数，但我怀疑它对 Scala 播放动作的必要性......在播放文档中出现这个：

It is often useful to mark the request parameter as implicit so it can be implicitely used by other APIs that need it

现在...正在阅读其他 stackoverflow 答案： Scala 中匿名函数中的参数之前的隐式关键字

似乎在这里使用隐式参数只是一个“语法糖”

 Action { request =>
   Ok("Got request [" + request + "]",request)  //with implicit request I avoid pass the request parameter...
  }

我的问题是：

1) 隐式参数的范围只是来自我的 lambda 的范围吗？... 2) 我是否忽略了它的某些内容？...

阅读另一个答案： 我什么时候应该在 Scala 中创建带有隐式参数的方法？

似乎在这种情况下使用隐式参数是“过度使用” 3）不使用隐式参数的代码看起来如何以及我避免使用什么样板？

我重写了这段代码/sf/answers/351061301/没有隐式参数和定义，代码更易读和清晰（更少隐式：D）......我知道隐式参数非常有用的有用情况（例如：akka api）但我不明白它的模式有多大用处以及为什么必须使用...

谢谢！