标签: scala

我理解Ruby和Python的收益率.Scala的收益率是多少？

在Scala中将整个文件读入内存的简单和规范方法是什么？(理想情况下,控制字符编码.)

我能想到的最好的是:

scala.io.Source.fromPath("file.txt").getLines.reduceLeft(_+_)

或者我应该使用Java的一个令人难以置信的习语,其中最好的(不使用外部库)似乎是:

import java.util.Scanner
import java.io.File
new Scanner(new File("file.txt")).useDelimiter("\\Z").next()

从阅读邮件列表讨论来看,我不清楚scala.io.Source甚至应该是规范的I/O库.我完全不明白它的目的是什么.

...我想要一些简单易记的东西.例如,在这些语言中,很难忘记这些成语......

Ruby    open("file.txt").read
Ruby    File.read("file.txt")
Python  open("file.txt").read()

我从来没有从设计的解组和修饰名词中理解它(一个AddTwo类apply增加了两个!)的例子.

我理解它是语法糖,所以(我从上下文推断)它必须被设计为使一些代码更直观.

具有apply函数的类有什么意义？它用于什么,以及它使代码变得更好的目的(解组,修改名词等)？

在伴侣对象中使用时如何帮助？

我正在通过Scala playframework教程,我遇到了这段令我困惑的代码片段:

def newTask = Action { implicit request =>
taskForm.bindFromRequest.fold(
        errors => BadRequest(views.html.index(Task.all(), errors)),
        label => {
          Task.create(label)
          Redirect(routes.Application.tasks())
        } 
  )
}

所以我决定调查并发现这篇文章.

我还是不明白.

这有什么区别:

implicit def double2Int(d : Double) : Int = d.toInt

和

def double2IntNonImplicit(d : Double) : Int = d.toInt

除了明显的事实,他们有不同的方法名称.

我implicit什么时候应该使用？为什么？

Scala中的a var和val定义之间有什么区别？为什么语言需要两者？你为什么选择a val而不是var反之？

我在很多例子中看到有时使用Seq,而其他时候是List ......

除了前一个是Scala类型和List来自Java之外,有什么区别吗？

我试图调用Shapeless从内宏quasiquote用Scala,我没有得到什么,我想获得.

我的宏不会返回任何错误,但它不会扩展Witness(fieldName)到Witness.Lt[String]

val implicits = schema.fields.map { field =>
  val fieldName:String = field.name
  val fieldType = TypeName(field.valueType.fullName)
  val in = TermName("implicitField"+fieldName)
  val tn = TermName(fieldName)
  val cc = TermName("cc")
  q"""implicit val $in = Field.apply[$className,$fieldType](Witness($fieldName), ($cc:   $className) => $cc.$tn)"""
}

这是我的Field定义:

sealed abstract class Field[CC, FieldName] {
  val  fieldName: String
  type fieldType

  // How to extract this field
  def  get(cc : CC) : fieldType
}

object Field {
  // fieldType …

我如何打破循环？

var largest=0
for(i<-999 to 1 by -1) {
    for (j<-i to 1 by -1) {
        val product=i*j
        if (largest>product)
            // I want to break out here
        else
           if(product.toString.equals(product.toString.reverse))
              largest=largest max product
    }
}

如何将嵌套for循环转换为尾递归？

来自FOSDEM 2009 上的Scala Talk http://www.slideshare.net/Odersky/fosdem-2009-1013261在第22页:

打破并继续Scala没有它们.为什么？他们有点必要; 更好地使用许多较小的函数问题如何与闭包交互.他们不需要!

解释是什么？

您可以在网上找到以下内容:

1. 更高的kinded类型==类型构造函数？

   class AClass[T]{...} // For example, class List[T]
   

   Run Code Online (Sandbox Code Playgroud)

   有人说这是一种更高的kinded类型,因为它抽象了符合定义的类型.

   较高的kinded类型是采用其他类型并构造新类型的类型

   这些虽然也称为类型构造函数.(例如,在Scala中编程).

2. 更高的kinded type == type构造函数,它将类型构造函数作为类型参数？

   在更高级别的Generics中,您可以阅读

   ...抽象类型抽象的类型("更高级的类型")......"

   这表明

   class XClass[M[T]]{...} // or
   
   trait YTrait[N[_]]{...} // e.g. trait Functor[F[_]]
   

   Run Code Online (Sandbox Code Playgroud)

   是一种更高级的类型.

因此,考虑到这一点,很难区分类型构造函数,更高的kinded类型和类型构造函数,它将类型构造函数作为类型参数,因此上面的问题.

简单来说,什么是上下文和视图边界,它们之间有什么区别？

一些易于理解的例子也很棒!