小编Tur*_*rin的帖子

我知道这是一个非常不精确的问题,可能被认为不适合stackoverflow.不幸的是,较小的应用程序(就演员数量而言)和"类似教程"的应用程序无法帮助我发展关于消息调度开销的直觉以及"scala对象"和"CORBA对象"之间的粒度的快速点.

虽然几乎肯定保持与客户的对话状态,例如值得一个演员,但在大多数实际使用案例中,它将涉及由许多类建模的条件/并行/替代交互.这样就可以选择将actor视为非常复杂的服务的外观,类似于刚刚退役的EJB,或者类似于smalltalk对象,只要通信可能以异步方式实现,就可以在相互之间发送消息.

除了消息传递本身的开销之外,还会有生命周期管理所涉及的开销,并且我对由于根目录中的异常或其他错误导致整个子树的链接重新启动而导致的潜在问题持谨慎态度.

为了这个问题,我们可以假设绝大多数通信发生在一台机器上,并且网络交叉是微不足道的.

标题说明了一切,真的; 迭代集合同时保持循环之间的状态和基于终止条件的完成迭代以及简单地耗尽元素可能是在命令式编程中完成任何事情的最常见模式.在我看来,像但它的东西功能gentleprogrammers同意不谈,至少我从来没有遇到过的成语,或一个半标化的名称,如用map,fold,reduce等.

我经常在scala中使用followinig代码:

implicit class FoldWhile[T](private val items :Iterable[T]) extends AnyVal {
    def foldWhile[A](start :A)(until :A=>Boolean)(op :(A, T)=>A) :A = {
        if (until(start)) start
        else {
            var accumulator = start
            items.find{ e => accumulator = op(accumulator, e); until(accumulator) }
            accumulator
        }

    }

}

但它很难看.每当我尝试一种更具声明性的方法时,我会使用更长,几乎肯定更慢的代码,类似于:

Iterator.iterate((start, items.iterator)){
    case (acc, i) if until(acc) => (acc, i)
    case (acc, i) if i.hasNext => (op(acc, i.next()), i)
    case x => x
}.dropWhile {
    case (acc, i) => !until(acc) …

我在scala中玩反射.我选择了

class CloneSubject(val a :Int, b :String, private var c :Boolean)

作为主题并迭代typeOf[CloneSubject].members以查找fields(sym.isTerm && (sym.asTerm.isVar || sym.asTerm.isVal))但是当我尝试创建FieldMirror时,(cm mirrorField sym.asTerm)我得到此异常:

Exception in thread "main" scala.ScalaReflectionException: Scala field b isn't represented as a Java field, 
neither it has a Java accessor method
note that private parameters of class constructors don't get mapped onto fields and/or accessors,
unless they are used outside of their declaring constructors.` 

现在,我完全理解为什么会发生这种情况,但我无法找到一种方法来检查这一点而不会抛出异常.当然,使用Java反射工作得很好,但那是违背这一点的.有任何想法吗？

基本上,我希望能够写出这样的东西:

val x :('k1.type, Int) = 'k1 -> 1
val y :('k2.type, Int) = 'k2 -> 2

如果x和y的类型不兼容,但是要么共享一个超类型,要么可以用上下文边界注释,允许我做这样的事情:

def mlt[T :MyLittleType](x :(T, Int)) = ???
mlt(x); mlt(y)

这里仅使用关键字作为示例,目标是能够为某些标识符/关键字/字符串提供文字和单例类型.这些类型也可能在运行时被擦除/统一,我只对静态类型检查感兴趣.我想应该可以使用宏来实现这一点,但我宁愿不这样做.

我相信泛型类可能只使用其类型参数符合一些额外的限制,例如(现场即兴语法),使其方法之一可用:

trait Col[T] extends Traversable[T] {
    def sum[T<:Int] :T = (0/:this)(_+_)
}

我想我可以使用隐式参数作为证据......是否有语言功能？

是否可以动态强制在scala中运行时装箱？我想要一个功能:

    def box(value :Any) :AnyRef

要么

    def box[T](value :T) :AnyRef

我有一个泛型类,可以使用AnyVals进行参数化,但需要将它们传递给接受对象集合的旧Java方法.当然,我可以自己使用模式匹配来实现它,但是它必须一次又一次地做它有点烦人,并且它对用户值类不起作用.

编辑

答案变得简单,令人惊讶.现在,我可以通过反思来做到吗？假设

class Box[T :TypeTag](private var value :T) {
    def get :T = value
    def set(o :Any) {
        ...
    }
}

我想做一个安全集,检查运行时是否o是T的子类,如下所示:

runtimeMirror(getClass.getClassLoader).classSymbol(o.getClass).toType <:< typeOf[T]

不幸的是,Box [Long]的typeOf [T]将是一个原语,并且以下检查将在java.lang.Long上失败,例如,Seq [Long]的元素的运行时类型.最后,当使用泛型与AnyVals时,编译器有时会将它们设置为使得运行时类检查不可预测.

假设我有一个专门的类和一个关联的伴生对象：

trait Slice[@specialized +T] {
    ...

    override def equals(that :Any) = that match {
        case s :Slice[_] => ???
        case _ => false
    }
}

object Slice {
    def newInstance[@specialized T] = ???
}

有什么办法可以查

1. 在 Slice 的方法中，如果这个实例是一个特殊的子类，
2. 在 Slice 的方法中，如果另一个实例是同一原语的特殊子类，
3. 如果我正在运行已擦除或专用变体，则在伴随对象的专用方法中

不诉诸 ClassTags 或手动传递 Class[_]？似乎该信息应该可用，但我能想到的唯一方法是检查类的名称。

用例 2) 特别重要，因为如果我知道我在比较苹果和苹果，我可以求助于更快的算法。它可能可以通过反射来完成，但是当您考虑到我们也必须处理 Slice 的非合成子类时，这将非常棘手；如果我们也有

trait ArraySlice[@specialized T] extends Slice[T] { ... }

只要它们都是专门的（或都被擦除），就应该被认为与 Slice[T] 实例“兼容”？

从我第一次读到：

for {
  harpo<-list1 if harpo.length>0
  groucho<-list2
  chico<-list3
} yield (harpo, groucho, chico)

翻译成：

list1.filter(_.length>0).flatMap(harpo =>      
      list2.flatMap(groucho=>list3.map((harpo,groucho,_)))
)

我担心filter, flatMap&返回的不必要的中间集合map。第一个是通过添加withFilter方法在 Scala 2.8(?) 中修复的，我怀疑有一些魔法会根据使用情况改变这些方法的返回类型，因此当用作参数时，flatMap它们返回一个非严格集合，但我找不到任何证据。我的怀疑是对的吗，它并不像乍一看那样无效？

我使用spray-can,spray-http 1.3.2和akka 2.3.6设置了一个http服务器.我的application.conf没有任何akka(或spray)条目.我的演员代码:

class TestActor extends HttpServiceActor with ActorLogging with PlayJsonSupport {
  val route = get { 
    path("clientapi"/"orders") { 
       complete {{
            log.info("handling request")
            System.err.println("sleeping "+Thread.currentThread().getName)
            Thread.sleep(1000)
            System.err.println("woke up "+Thread.currentThread().getName)
            Seq[Int]()
       }}
    }
  }

  override def receive: Receive = runRoute(route)
}

像这样开始:

val restService = system.actorOf(Props(classOf[TestActor]), "rest-clientapi")

IO(Http) ! Http.Bind(restService, serviceHost, servicePort)

当我发送10个并发请求时,它们都被喷射立即接受并转发给不同的调度程序参与者(根据我从applicaiton.conf中删除的akka​​的日志配置,以免影响结果),但所有都由同一个线程处理,睡觉,只有在醒来之后才会收到下一个请求.

我应该在配置中添加/更改什么？从我在reference.conf中看到的,默认执行程序是fork-join-executor,所以我希望所有请求都是开箱即用的并行执行.

好吧,我知道比使用null作为设计选择更好,但在这种情况下我必须这样做.为什么以下不编译？

def test[T<:AnyRef](o :Option[T]) :T = o getOrElse null

Error:(19, 53) type mismatch;
               found   : Null(null)
               required: T
               Note: implicit method foreignKeyType is not applicable here because it comes  after the application point and it lacks an explicit result type
def test[T<:AnyRef](o :Option[T]) :T = o getOrElse null
                                                   ^

我正在为执行浮点数计算的代码编写测试.很可能,结果很少是准确的,我想在计算结果和预期结果之间设置一个容差.我已经验证了在实践中,使用双精度,在舍入最后两位有效小数后,结果总是正确的,但通常在舍入最后一个小数之后.我知道存储doubles和floats 的格式,以及舍入的两种主要方法(精确通过BigDecimal和通过乘法math.round和除法更快).由于尾数以二进制形式存储,是否有办法使用基数2而不是10来执行舍入？

只是清除最后3位几乎总能产生相同的结果,但是如果我可以推动它而是在尾数"加2",如果它的第二个最小有效位被设置,我可能达到精度极限.这很容易,我希望我不知道如何处理溢出(当所有位52-1都置位时).

Java解决方案将是首选,但如果我理解的话,我可能会将其中一个用于另一种语言.

编辑:作为问题的一部分,我的代码在算术方面是通用的(依赖于scala.Numeric类型类),我所做的是将答案中建议的舍入结合到一个新的数字类型中,该数字类型带有计算的数字(浮点数)在这种情况下)和舍入误差,基本上代表一个范围而不是一个点.然后我重写等于如果它们的误差范围重叠两个数字是相等的(并且它们共享算术,即数字类型).

问题：

trait UpperBound[O]
trait High[F[O] <: UpperBound[O]]

def canEqual(that :Any) = that.isInstanceOf[High[_]]

def high(h :High[_]) = ???

不编译，因为 scalac 看到的是_类型而不是它期望的类型构造函数。如何解决它，理想情况下不写小说？

原始问题（在对 Dmytro 的回答进行编辑之前）有：

def canEqual(that :Any) = that.isInstanceOf[High[m forSome { type m[O] <: UpperBound[O] }]]

def high(h :High[m forSome { type m[O] <: UpperBound[O] }] = ???

是否有使用通配符表达式编写上述两种方法的更短方法？简单地使用_inHigh的类型参数位置不起作用，因为类型不匹配，_[_]甚至不是有效的类型表达式。