javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

scala-语法糖:_ *用于将Seq作为方法参数

我只是在网上某个地方注意到了这个构造:

val list = List(someCollection: _*)

_*是什么意思? 这是某些方法调用的语法糖吗? 我的自定义类应满足哪些约束,以便可以利用此语法糖?

trans by 2020-02-29T14:08:47Z

多线程-与Scala / Akka参与者相比,Java线程的负担如何?

我只是在比较Scala actor和Java线程的性能。

我惊讶地看到了两者之间的差异,我发现使用我的系统我最多只能产生约2000个线程(一次处于活动状态),但是使用同一系统,我可以产生约500,000个scala参与者。

这两个程序都使用了大约81MB的JVM堆内存。

您能解释一下java线程比scala / akka演员有多大的负担吗?是什么让scala-actor如此轻量级的关键因素是什么?

如果我想获得最佳的可伸缩性,是否应该选择基于actor的Web服务器,而不是像JBoss或Tomcat这样的基于Java的传统Web /应用服务器?

谢谢。

trans by 2020-02-29T10:59:46Z

Scala参考相等

您如何在Scala中测试引用相等性?

val x = new Obj
val y = x
x.referenceEquals(y) // evaluates to true
trans by 2020-02-22T13:33:53Z

中的运算符优先级

我喜欢Scala提出的运算符优先级的提议,但在极少数情况下,未修改的规则可能会带来不便,因为您在命名方法时有限制。 是否可以在Scala中为类/文件等定义其他规则? 如果没有,将来会解决吗?

trans by 2020-02-22T11:32:55Z

scala-使用Scalaz Stream解析任务(替换Scalaz Iteratees)

介绍

我在许多项目中使用了Scalaz 7的迭代器,主要用于处理大型文件。 我想开始切换到Scalaz流,该流旨在替代iteratee包(坦率地说,它缺少很多组件,使用起来有点痛苦)。

流基于机器(迭代器思想的另一种变体),该机器也已在Haskell中实现。 我曾经使用过Haskell机器库,但是机器和流之间的关系并不十分明显(至少对我而言),并且流库的文档仍然很少。

这个问题是关于一个简单的解析任务,我希望看到它是使用流而不是迭代来实现的。 如果没有其他人能击败我,我会自己回答这个问题,但是我敢肯定,我不是唯一一个正在(或至少考虑)进行这种过渡的人,并且由于我仍然需要完成此练习,因此我 我想我也应该在公开场合这样做。

任务

假设我有一个文件,其中包含已被标记并用词性标记的句子:

no UH
, ,
it PRP
was VBD
n't RB
monday NNP
. .

the DT
equity NN
market NN
was VBD
illiquid JJ
. .

每行只有一个标记,单词和词性由一个空格分隔,空白行代表句子边界。 我想解析该文件并返回一个句子列表,我们也可以将其表示为字符串元组列表:

List((no,UH), (,,,), (it,PRP), (was,VBD), (n't,RB), (monday,NNP), (.,.))
List((the,DT), (equity,NN), (market,NN), (was,VBD), (illiquid,JJ), (.,.)

像往常一样,如果遇到无效的输入或文件读取异常,我们希望优雅地失败,我们不必担心手动关闭资源等。

迭代解决方案

首先是一些常规的文件读取内容(它确实应该是iteratee程序包的一部分,该程序包目前不提供此类高级功能)。

import java.io.{ BufferedReader, File, FileReader }
import scalaz._, Scalaz._, effect.IO
import iteratee.{ Iteratee => I, _ }

type ErrorOr[A] = EitherT[IO, Throwable, A]

def tryIO[A, B](action: IO[B]) = I.iterateeT[A, ErrorOr, B](
  EitherT(action.catchLeft).map(I.sdone(_, I.emptyInput))
)

def enumBuffered(r: => BufferedReader) = new EnumeratorT[String, ErrorOr] {
  lazy val reader = r
  def apply[A] = (s: StepT[String, ErrorOr, A]) => s.mapCont(k =>
    tryIO(IO(Option(reader.readLine))).flatMap {
      case None       => s.pointI
      case Some(line) => k(I.elInput(line)) >>== apply[A]
    }
  )
}

def enumFile(f: File) = new EnumeratorT[String, ErrorOr] {
  def apply[A] = (s: StepT[String, ErrorOr, A]) => tryIO(
    IO(new BufferedReader(new FileReader(f)))
  ).flatMap(reader => I.iterateeT[String, ErrorOr, A](
    EitherT(
      enumBuffered(reader).apply(s).value.run.ensuring(IO(reader.close()))
    )
  ))
}

然后我们的句子阅读器:

def sentence: IterateeT[String, ErrorOr, List[(String, String)]] = {
  import I._

  def loop(acc: List[(String, String)])(s: Input[String]):
    IterateeT[String, ErrorOr, List[(String, String)]] = s(
    el = _.trim.split(" ") match {
      case Array(form, pos) => cont(loop(acc :+ (form, pos)))
      case Array("")        => cont(done(acc, _))
      case pieces           =>
        val throwable: Throwable = new Exception(
          "Invalid line: %s!".format(pieces.mkString(" "))
        )

        val error: ErrorOr[List[(String, String)]] = EitherT.left(
          throwable.point[IO]
        )

        IterateeT.IterateeTMonadTrans[String].liftM(error)
    },
    empty = cont(loop(acc)),
    eof = done(acc, eofInput)
  )
  cont(loop(Nil))
}

最后是我们的解析动作:

val action =
  I.consume[List[(String, String)], ErrorOr, List] %=
  sentence.sequenceI &=
  enumFile(new File("example.txt"))

我们可以证明它有效:

scala> action.run.run.unsafePerformIO().foreach(_.foreach(println))
List((no,UH), (,,,), (it,PRP), (was,VBD), (n't,RB), (monday,NNP), (.,.))
List((the,DT), (equity,NN), (market,NN), (was,VBD), (illiquid,JJ), (.,.))

我们完成了。

我想要的是

使用Scalaz流而不是迭代程序实现的程序大致相同。

trans by 2020-02-22T09:09:03Z

如何在IntelliJ IDEA中使用Scala(或者:为什么很难获得适用于Scala的IDE)?

我最近放弃了在Eclipse中使用Scala的尝试(完成之类的基本操作不起作用)。 所以现在我正在尝试IntelliJ。 我走的不远。

我已经能够编辑程序(在语法高亮显示和完成中...是的!)。 但是我什至无法运行最简单的“ Hello World”。 这是原始错误:

Scala signature Predef has wrong version
Expected 5.0
found: 4.1 in .... scala-library.jar

但这是昨天发布的IDEA 9.0.1。 见下文...

更新

今天,我使用4/14稳定版的Scala插件卸载了IntelliJ 9.0.1,并安装了9.0.2 Early Availability。

然后,我通过向导从头开始设置一个项目:

  • 从头开始的新项目
  • JDK是1.6.u20
  • 接受默认(项目)而不是全局/模块
  • 接受将Scala 2.8.0beta1下载到项目的lib文件夹中

创建了一个新类:

object hello {
  def main(args: Array[String]) {
    println("hello: " + args);
  }
}

为了我的努力,我现在遇到了一个全新的错误:)

这里是:

Scalac内部错误:类java.lang.ClassNotFoundException [java.net.URLClassLoader $ 1.run(URLClassLoader.java:202),java.security.AccessController.doPrivileged(本机方法),java.net.URLClassLoader.findClass(URLClassLoader.java :190),java.lang.ClassLoader.loadClass(ClassLoader.java:307),sun.misc.Launcher $ AppClassLoader.loadClass(Launcher.java:301),java.lang.ClassLoader.loadClass(ClassLoader.java:248) ,java.lang.Class.forName0(本机方法),java.lang.Class.forName(Class.java:169),org.jetbrains.plugins.scala.compiler.rt.ScalacRunner.main(ScalacRunner.java:72) ]

最后更新

我卸载了9.0.2 EA,然后重新安装了9.0.1,但是这次使用的是2.7.3版本的Scala而不是默认的2.7.6,因为2.7.3是IntelliJ网站上的屏幕快照中显示的版本( 我猜这些屏幕截图证明了他们实际上已经测试过该版本!)。 现在一切正常!!!

trans by 2020-02-22T00:34:51Z

如何在Scala中进行投射?

例如,假设我有

val myDouble = 25.7
val myInt = 5

我该怎么做

val divide = (Int) (myDouble / myInt)
trans by 2020-02-21T12:55:45Z

运算符-中的有效标识符字符

我感到很困惑的一件事是知道我可以在方法和变量名中使用哪些字符和组合。 例如

val #^ = 1 // legal
val #  = 1 // illegal
val +  = 1 // legal
val &+ = 1 // legal
val &2 = 1 // illegal
val £2 = 1 // legal
val ¬  = 1 // legal

据我了解,字母数字标识符和运算符之间是有区别的。 您可以将一个匹配项或另一个匹配项混合在一起,但不能同时混合两者,除非用下划线(混合标识符)分隔。

从Scala中的编程第6.10节中,

操作员标识符由一个或多个操作员字符组成。   操作符是可打印的ASCII字符,例如+,:,?,〜   要么 #。

更准确地说,运算符属于Unicode集   数学符号(Sm)或其他符号(So)或7位   不是字母,数字,括号,正方形的ASCII字符   方括号,花括号,单引号或双引号或下划线,   句号,分号,逗号或反斜杠字符。

因此,我们无法使用+和`

我在Wikipedia上查找了Unicode数学符号,但是发现的却不包括+:?等。在运算符字符的确切位置上是否有明确的列表?

还有,为什么Unicode数学运算符(而不是符号)不算作运算符?

trans by 2020-02-20T18:28:31Z

范围-在Scala中有通用的记忆方式吗?

我想记住这一点:

def fib(n: Int) = if(n <= 1) 1 else fib(n-1) + fib(n-2)
println(fib(100)) // times out

因此,我编写了此文件,并完成了令人惊讶的编译和工作(我很惊讶,因为fib在其声明中引用了自己):

case class Memo[A,B](f: A => B) extends (A => B) {
  private val cache = mutable.Map.empty[A, B]
  def apply(x: A) = cache getOrElseUpdate (x, f(x))
}

val fib: Memo[Int, BigInt] = Memo {
  case 0 => 0
  case 1 => 1
  case n => fib(n-1) + fib(n-2) 
}

println(fib(100))     // prints 100th fibonacci number instantly

但是,当我尝试在val fib内声明fib时,出现编译器错误:

def foo(n: Int) = {
  val fib: Memo[Int, BigInt] = Memo {
    case 0 => 0
    case 1 => 1
    case n => fib(n-1) + fib(n-2) 
  }
  fib(n)
} 

以上未能编译val fib

为什么在def内部声明val fib失败,但在类/对象范围之外进行声明呢?

为了澄清,为什么我可能想在def范围内声明递归的备忘函数-这是我对子集和问题的解决方案:

/**
   * Subset sum algorithm - can we achieve sum t using elements from s?
   *
   * @param s set of integers
   * @param t target
   * @return true iff there exists a subset of s that sums to t
   */
  def subsetSum(s: Seq[Int], t: Int): Boolean = {
    val max = s.scanLeft(0)((sum, i) => (sum + i) max sum)  //max(i) =  largest sum achievable from first i elements
    val min = s.scanLeft(0)((sum, i) => (sum + i) min sum)  //min(i) = smallest sum achievable from first i elements

    val dp: Memo[(Int, Int), Boolean] = Memo {         // dp(i,x) = can we achieve x using the first i elements?
      case (_, 0) => true        // 0 can always be achieved using empty set
      case (0, _) => false       // if empty set, non-zero cannot be achieved
      case (i, x) if min(i) <= x && x <= max(i) => dp(i-1, x - s(i-1)) || dp(i-1, x)  // try with/without s(i-1)
      case _ => false            // outside range otherwise
    }

    dp(s.length, t)
  }
trans by 2020-02-20T12:17:48Z

如何避免Scala案例类限制为22个字段?

Scala case类在构造函数中的限制为22个字段。 我想超过此限制,有没有办法与案例类一起使用的继承或组合呢?

trans by 2020-02-19T13:49:08Z

语法-Scala中=和:=有什么区别?

Scala中的=:=和有什么不一样?

我已经在Google上广泛搜索“ scala Colon-equals”,但找不到任何确定的信息。

trans by 2020-02-18T15:55:21Z

scala-Spark:将2元组键RDD与单键RDD结合在一起的最佳策略是什么?

我有两个RDD要加入,它们看起来像这样:

val rdd1:RDD[(T,U)]
val rdd2:RDD[((T,W), V)]

碰巧情况是rdd2的键值是唯一的,并且rdd2的元组键值也是唯一的。 我想加入两个数据集,以便获得以下rdd:

val rdd_joined:RDD[((T,W), (U,V))]

最有效的方法是什么? 这是我想到的一些想法。

选项1:

val m = rdd1.collectAsMap
val rdd_joined = rdd2.map({case ((t,w), u) => ((t,w), u, m.get(t))})

选项2:

val distinct_w = rdd2.map({case ((t,w), u) => w}).distinct
val rdd_joined = rdd1.cartesian(distinct_w).join(rdd2)

选项1将收集所有数据以掌握,对吗? 因此,如果rdd1很大(在我的情况下它相对较大,虽然比rdd2小一个数量级),但这似乎不是一个好选择。 选项2做得很丑陋,而且笛卡尔积,看来效率也很低。 我不曾想到(但尚未尝试过)的另一种可能性是执行选项1并广播地图,尽管最好以“智能”的方式进行广播,以使地图的按键与 rdd2的密钥。

有人遇到过这种情况吗? 有您的想法我将很高兴。

谢谢!

trans by 2020-02-18T13:24:35Z

大量的Android开发

有没有人成功在Scala中开发了一个强大的Android应用程序? 这是可行的选择吗? 有没有成熟的开发环境? 考虑到Scala Eclipse插件的状态,看起来似乎除了IntelliJ Ultimate之外根本没有很好的IDE支持。

一些人发布了教程,描述了如何使用Eclipse ADT来对Scala进行某种程度的支持,以及如何使用Proguard来简化Scala库,但是令人担忧的是,关于该主题的讨论很少。

2011-08-01更新:Bump应用程序背后的开发人员在Android + Scala上发表了一篇有趣的文章:Bump开发博客-我们如何在Android版Bump中使用Scala

trans by 2020-02-17T16:11:25Z

scala-计算机上的“原因”一词是什么意思?

在学习函数式编程时,我经常碰到“原因”一词,尤其是在纯函数和/或引用透明性的情况下。 有人可以解释这到底是什么意思吗?

trans by 2020-02-17T09:30:02Z

scala-嵌套方法的成本

在Scala中,可能会在其他方法中定义方法。 这将它们的使用范围限制在定义块内部。 我使用它们来提高使用多个高阶函数的代码的可读性。 与匿名函数文字相反,这允许我在传递它们之前给它们赋予有意义的名称。

例如:

class AggregatedPerson extends HashSet[PersonRecord] {
  def mostFrequentName: String = {
    type NameCount = (String, Int)
    def moreFirst(a: NameCount, b: NameCount) = a._2 > b._2
    def countOccurrences(nameGroup: (String, List[PersonRecord])) =
      (nameGroup._1, nameGroup._2.size) 

    iterator.toList.groupBy(_.fullName).
      map(countOccurrences).iterator.toList.
      sortWith(moreFirst).head._1
  }
}

由于我应该了解的嵌套方法定义,是否需要任何运行时成本?

闭包的答案是否有所不同?

trans by 2020-02-16T21:55:08Z

如何查找Scala字符串是否可解析为Double?

假设我在scala中有一个字符串,并且想尝试从中解析出一个double。

我知道,只要失败,我就可以致电toDouble,然后捕获java num格式异常,但是有没有更干净的方法可以做到这一点? 例如,如果有一个parseDouble函数返回了Option[Double],则该函数符合条件。

如果它已经存在于标准库中,我不想将其放入自己的代码中,而只是在错误的位置寻找它。

感谢您的任何帮助,您可以提供。

trans by 2020-02-16T19:53:17Z

Scala-Lambda参数可以匹配元组吗?

所以说我有一些像

val l = List((1, "blue"), (5, "red"), (2, "green"))

然后我想过滤掉其中一个,我可以做类似的事情

val m = l.filter(item => {
    val (n, s) = item          // "unpack" the tuple here
    n != 2
}

我有什么办法可以直接将“元组”作为参数“拆包”到lambda,而不是使用此中间变量2750210825981002002752?

像下面这样的东西是理想的,但是日食告诉我wrong number of parameters; expected=1

val m = l.filter( (n, s) => n != 2 )

任何帮助将不胜感激-使用2.9.0.1

trans by 2020-02-16T14:24:22Z

2.10中的scala会发生什么?

显然有反射库,但是在下一个scala版本中我们还能看到什么呢? 语言有变化吗? 有可以查看路线图的网站吗?

trans by 2020-02-16T08:00:44Z

scala-使用sbt和testng时如何获取测试中引发的异常的完整堆栈跟踪?

堆栈跟踪被截断-例如 他们以last结尾

使用last或更改traceLevel都无济于事-它只是打印sbt包装程序的完整堆栈跟踪。

这是用testng测试(我也相信使用scalatest和sl4j)

trans by 2020-02-15T20:27:05Z

Scala Map foreach

给出:

val m = Map[String, Int]("a" -> 1, "b" -> 2, "c" -> 3)
m.foreach((key: String, value: Int) => println(">>> key=" + key + ", value=" + value))

为什么编译器抱怨

error: type mismatch
found   : (String, Int) => Unit
required: (String, Int) => ?
trans by 2020-02-15T19:12:45Z

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 下一页 共35页