小编par*_*tic的帖子

这是一个设计问题而不是其他任何问题......

我非常喜欢Scala的案例类并经常使用它们.但是,我发现我经常在我的参数中包含Options(或者更确切地说,提升Boxes)并设置默认值以允许灵活性并且考虑到用户可能并不总是指定所有参数.我想我采用了这种做法.

我的问题是,这是一种合理的方法吗？鉴于一切都可以是可选的,可以有很多样板和检查,到目前为止我是否想知道我是不是只是使用我的案例类,Map[String, Any]并且想知道我是否会因为使用a而变得更好Map.

让我举个一个真实的例子.我在这里建模汇款:

case class Amount(amount: Double, currency: Box[Currency] = Empty)
trait TransactionSide
case class From(amount: Box[Amount] = Empty, currency: Box[Currency] = Empty, country: Box[Country] = Empty) extends TransactionSide
case class To(amount: Box[Amount] = Empty, currency: Box[Currency] = Empty, country: Box[Country] = Empty) extends TransactionSide
case class Transaction(from: From, to: To)

我认为比较容易理解.在这个最简单的我们可能会声明Transaction如下:

val t = Transaction(From(amount=Full(Amount(100.0)), To(country=Full(US)))

我已经可以想象你认为它很冗长.如果我们指定一切:

val t2 = Transaction(From(Full(Amount(100.0, Full(EUR))), Full(EUR), Full(Netherlands)), To(Full(Amount(150.0, Full(USD))), Full(USD), …

我正在寻找阿拉伯语的Java词干分析器.我发现了一个名为"AraMorph"的lib,但它的输出是无法控制的,它会形成不需要的单词.

阿拉伯语还有其他的词干吗？

我正在尝试编写一个允许我在给定时间窗口中运行计算的构造.就像是:

def expensiveComputation(): Double = //... some intensive math

val result: Option[Double] = timeLimited( 45 ) { expensiveComputation() }

这timeLimited将以expensiveComputation45分钟的超时运行.如果它达到超时它返回None,否则它将结果包装进去Some.

我正在寻找一个解决方案:

• 在性能和记忆方面相当便宜;
• 将在当前线程中运行限时任务.

有什么建议吗？

编辑

我理解我的原始问题没有解决方案.假设我可以为计算创建一个线程(但我更喜欢不使用线程池/执行器/调度程序).什么是最快,最安全,最干净的方法？

我有以下代码:

class Animal(hair: Option[Hair])

class Cat(var hair: Option[Hair]) extends Animal(hair)
class Dog(var hair: Option[Hair]) extends Animal(hair)
class Sheep(var hair: Option[Hair]) extends Animal(hair)

//then somewhere else:

def what(animal: Animal) {

  animal match {
    case Cat(hair) => println("processing cat, hair=" + hair)
    case Dog(hair) => println("processing dog, hair=" + hair)
    case Sheep(hair) => {
      println("processing sheep, cutting hair...")
      hair = None
    }
  }
}

问题是:

1)当模式匹配与绵羊成功时,我怎样才能进入它的头发并改变它？它抱怨重新分配给val,然后我把它放在var构造函数中但仍然......

2)我能想到的另一种方法是将整个匹配值分配给变量,有没有办法将一些case类构造函数模式匹配的值绑定到变量？

(我知道我可能会在类似的东西上进行模式匹配s: Sheep然后调用,s.changeHairTo(None)但这是最不可取的方式).

play.api.libs.iterateeplay2中有一个包,它有一个Iteratee超过1000行的大对象.

为什么play2需要这么大的对象以及如何理解它？

在浏览play框架的scala文档(Play Docs)时,我看到了一种我从未见过的语法.

val populations:List[String~Int] = {
  SQL("select * from Country").as( str("name") ~ int("population") * ) 
}

可能有人请告诉我这是什么"〜"的List[String~Int]意思吗？

我是Play和Scala的新手,我正在阅读Manning媒体的Play for Scala.我想使用说明来使用Squeryl而不是Anorm.

该书提到我需要在扩展GlobalSettings的类中初始化Squeryl.

import org.squeryl.adapters.H2Adapter
import org.squeryl.{Session, SessionFactory}
import play.api.db.DB import play.api.{Application, GlobalSettings}

object Global extends GlobalSettings {
    SessionFactory.concreteFactory = Some(() =>
    Session.create(DB.getConnection()(app), new H2Adapter) ) 
...

由于这是一个早期版本(MEAP),目前尚不清楚这个代码的放置位置......所以我在游戏网站上进行了一些挖掘后发现了以下扩展GlobalSettings的示例

import play.api._

object Global extends GlobalSettings {

    override def onStart(app: Application) {
        Logger.info("Application has started")
    }  

    override def onStop(app: Application) {
        Logger.info("Application shutdown...")
    }  

}

播放示例提供了更多帮助但我仍然无法遵循指示,其中说明:此对象必须在默认(空)包中定义.

这引出了我的问题:将Scala文件放在Play Framework 2.0中的哪个位置,以便将其作为默认包的一部分进行编译？

谢谢你的帮助...

假设我们在Java中具有以下结构:

class List {
  // we're immutable
  final List next;
  final int value;

  public List(int value, List next) {
    this.next = next;
    this.value = value;
  }
}

Scala内置了对不可变单链表的支持.这将是:

val l = List(1, 2, 3) // immutable

那么,是否有可能在这种列表中创建一个循环(不可变的单链表).按周期,我的意思是:

我正在尝试了解如何使用新akka.http库.我想向服务器发送一个http请求,并将整个响应主体作为单个String读取,以便生成一个Source[String,?].

这是迄今为止我能够制作的最佳解决方案:

 def get(
   modelID: String,
   pool: Flow[(HttpRequest,Int),(Try[HttpResponse],Int),Http.HostConnectionPool]
 ): Source[String,Unit] = {
   val uri = reactionsURL(modelID)
   val req = HttpRequest(uri = uri)
   Source.single( (req,0) )
     .via( pool )
     .map { 
       case (Success(resp),_) =>
         resp.entity.dataBytes.map( _.decodeString("utf-8") )
     }.flatten(FlattenStrategy.concat)
     .grouped( 1024 )
     .map( _.mkString )

它似乎工作得很好(除了缺少的错误路径),但对于这样简单的任务来说它有点笨拙.有更聪明的解决方案吗？我可以避免grouped/ mkString？

在与朋友讨论操作员重载之后.我正在研究Scala中运算符重载的创造性和/或有用的示例用法.我有一些很酷的插图:

• 数学结构,如线性代数或复数(+ * -)
• 模仿shell管道和重定向(| > < >>)
• 语法中的替代表达式(|)

你有其他好的例子吗？