小编kir*_*uku的帖子

我在XML文档中有以下节点:

<node>This is some text.</node>

我想选择文本的前10个字符.我怎样才能做到这一点？

我有几个与咖喱功能有关的问题.我在这里逐一问他们

1)http://twitter.github.com/scala_school/basics.html给出了一个curried函数的例子 - 我认为它是一个函数定义,但实际上并非如此.REPL根本不承认这是一个有效的声明.

multiplyThenFilter { m: Int =>   m * 2 } { n: Int =>   n < 5}

2)为什么我们不能从部分参数化方法定义函数？即,以下定义有什么问题？

scala> def multiply(m: Int, n: Int): Int = m * n
multiply: (m: Int, n: Int)Int

scala> val timesTwo = multiply(2,_)
<console>:11: error: missing parameter type for expanded function ((x$1) => multiply(2, x$1))
       val timesTwo = multiply(2,_)
                                 ^

3)为什么我们不能使部分参数化函数curry？即,以下定义有什么问题？

scala> (multiply(_,_)).curried
  res13: Int => (Int => Int) = <function1>  // THIS IS OK

scala> (multiply(20,_)).curried
<console>:12: error: …

我正在使用Scala嵌入式DSL,宏正在成为实现我的目的的主要工具.我在尝试将传入宏表达式中的子树重用到结果宏中时遇到错误.情况非常复杂,但(我希望)我已将其简化为理解.

假设我们有这个代码:

val y = transform {
  val x = 3
  x
}
println(y) // prints 3

其中'transform'是涉及的宏.虽然看起来它什么都没有,但它确实将显示的块转换为这个表达式:

3 match { case x => x }

这是通过这个宏实现来完成的:

def transform(c: Context)(block: c.Expr[Int]): c.Expr[Int] = {
  import c.universe._
  import definitions._

  block.tree match {
    /* {
     *   val xNam = xVal
     *   xExp
     * }
     */
    case Block(List(ValDef(_, xNam, _, xVal)), xExp) =>
      println("# " + showRaw(xExp)) // prints Ident(newTermName("x"))
      c.Expr(
        Match(
          xVal, 
          List(CaseDef(
            Bind(xNam, Ident(newTermName("_"))),
            EmptyTree,
            /* xExp */ Ident(newTermName("x")) ))))
    case …

我有兴趣手动创建一个TypeTag(从2.10M5开始):

object X {
  import reflect.runtime.universe._
  def tt[A : TypeTag](a: A) = typeTag[A] // how to do this manually?
  val t = tt(List("")(_))
}

scalac -Xprint:typer <file>.scala 结果是

package <empty> {
  object X extends scala.AnyRef {
    def <init>(): X.type = {
      X.super.<init>();
      ()
    };
    import scala.reflect.runtime.`package`.universe._;
    def tt[A >: Nothing <: Any](a: A)(implicit evidence$1: reflect.runtime.universe.TypeTag[A]): reflect.runtime.universe.TypeTag[A] = scala.reflect.runtime.`package`.universe.typeTag[A](evidence$1);
    private[this] val t: reflect.runtime.universe.TypeTag[Int => String] = X.this.tt[Int => String](((x$1: Int) => immutable.this.List.apply[String]("").apply(x$1)))({
      val $u: reflect.runtime.universe.type = scala.this.reflect.runtime.`package`.universe;
      val $m: $u.Mirror = …

我需要知道如何找出共享库中的内存泄漏,这将被加载到发布二进制文件中.我的意思是我使用-g选项构建的共享库,但加载共享库的二进制文件不是使用-g选项构建的.

我得到泄漏报告如下.

==739==    at 0x4A05809: malloc (vg_replace_malloc.c:149)
==739==    by 0x84781B1: ???
==739==    by 0x87507F5: ???
==739==    by 0x874CF47: ???
==739==    by 0x874E657: ???
==739==    by 0x874F7C2: ???
==739==    by 0x8779C0C: ???

请告诉我如何从共享库中获取泄漏的堆栈跟踪？

ScalaSignature是一个注释.它包含元信息.

• https://github.com/scala/scala/blob/v2.9.2/src/library/scala/reflect/ScalaSignature.java

然后提供解析器.但scala-library.jar不包含解析器.它似乎是秘密的API.

• https://github.com/scala/scala/blob/v2.9.2/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSig.scala

但我知道一些使用ScalaSignature的库.

• https://github.com/lift/framework/blob/2.4-release/core/json/src/main/scala/net/liftweb/json/ScalaSig.scala
• https://github.com/msgpack/msgpack-scala/blob/version-0.6.6/src/main/scala/org/msgpack/scalautil/ScalaSigUtil.scala
• https://github.com/havocp/beaucatcher/blob/v0.5.0/caseclass/src/main/scala/org/beaucatcher/caseclass/ClassAnalysis.scala

顺便说一句,我找不到ScalaSignature的正式规范.我担心ScalaSignature的规范可能会因Scala版本更改而改变.此外,我认为使用ScalaSignature还存在一些其他风险,因为规范不存在.

此外,Scala2.10将提供新的反射API.我认为当2.10发布时,使用ScalaSignature的原因会减少.

因此,如果使用ScalaSignature？

在我的代码的许多方面,三个注释一起出现:

@BeanProperty
@(SpaceProperty @beanGetter)(nullValue="0")

where nullValue="0"是注释的参数SpaceProperty.

是否可以为单个类型别名定义@BeanProperty @(SpaceProperty @beangetter)？

我能做的最好的事情是:

type ScalaSpaceProperty = SpaceProperty @beanGetter

@BeanProperty
@(ScalaSpaceProperty)(nullValue = "0")

是否可以为两个注释定义一个类型别名,其中参数应用于最后一个？

当然,我知道所有类型做有一个共同的祖先,但我的意思是这样的:

在动态类型语言中,通常的做法是使用"混合"返回类型.常见的情况是尝试从数据库检索数据,然后返回对象(使用找到的数据初始化)或FALSE(如果没有找到数据)的函数.

一个小伪代码来演示这样的反模式:

function getObjectFromDatabase(object_id) {
  if(result = db_fetch_object("SELECT * FROM objects WHERE id = %d", object_id) {
    return result
  } else {
    return FALSE
  }
}

如果找到我的对象id的数据,我将DB记录作为对象返回.如果没有,我得到一个布尔值.然后,当然,我,客户端,处理多种可能的返回类型.

在Scala中实现此目的的唯一方法是为所有可能的返回类型找到一个共同的祖先,并将其声明为签名中的返回类型？

// Like so:
def getObjectFromDatabase(objectId: Int): Any = {
   val result = dbFetchObject("SELECT * FROM objects WHERE id = %d", object_id) 
   if(result) {
     return result
   } else {
     return false
  }
}

或者是否可以注释多种可能的返回类型？

(请注意,我不希望有可能这样做,因为我希望强制执行函数返回类型尽可能明确.对我来说,学习语言禁止模糊返回类型会让我感到宽慰,这就是我要问的原因.)

这是我之后的格式化时间:

2009-10-08 04:31:33.918700000 -0500

我目前正在使用这个:

strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %Z", ts);

这使:

2009-10-11 13:42:57 CDT

哪个很接近,但不准确.我似乎无法-0500在最后显示任何内容.另外我把秒作为int.

我该如何解决这两个问题？

我在Scala中有两个列表,如何合并它们以便将元组组合在一起？

是否有现成的Scala列表API可以执行此操作或需要我自己执行此操作？

输入:

 List((a,4), (b,1), (c,1), (d,1))
 List((a,1), (b,1), (c,1))

预期产量:

List((a,5),(b,2),(c,2),(d,1))