小编J P*_*lar的帖子

如何使用scala 2.10中的新反射模型从scala中的case类中提取字段值？例如,使用下面的内容并没有提取字段方法

  def getMethods[T:TypeTag](t:T) =  typeOf[T].members.collect {
    case m:MethodSymbol => m
  }

我打算把它们抽进去

  for {field <- fields} {
    currentMirror.reflect(caseClass).reflectField(field).get
  }

是否有一种简单的方法可以展平一系列试验,以使试验值成功,或者只是失败？例如:

def map(l:List[Int]) = l map {
  case 4 => Failure(new Exception("failed"))
  case i => Success(i)
}

val l1 = List(1,2,3,4,5,6)
val result1 = something(map(l1))

result1: Failure(Exception("failed"))

val l2 = List(1,2,3,5,6)
val result2 = something(map(l2)) 

result2: Try(List(1,2,3,5,6))

您可以如何处理集合中的多个故障？

我希望扩展迭代器来创建一个新方法takeWhileInclusive,它将像takeWhile最后一个元素一样运行.

我的问题是扩展迭代器以返回一个我希望延迟评估的新迭代器的最佳实践.来自C#背景我正常使用IEnumerable并使用yield关键字,但这样的选项似乎不存在于Scala中.

例如,我可以

List(0,1,2,3,4,5,6,7).iterator.map(complex time consuming algorithm).takeWhileInclusive(_ < 6)

所以在这种情况下,takeWhileInclusive只有解析值的谓词,直到我得到大于6的结果,并且它将包括第一个结果

到目前为止我有:

object ImplicitIterator {
  implicit def extendIterator(i : Iterator[Any]) = new IteratorExtension(i)
}

class IteratorExtension[T <: Any](i : Iterator[T]) {
  def takeWhileInclusive(predicate:(T) => Boolean) = ?
}

假设我有一个abitrary KList,为了参数的缘故,它有类型构造函数Option [_],即;

type Example = Option[Int] :: Option[String] :: HNil

有没有办法可以检索由类型参数组成的Hlist？

type Params = Int :: String :: HNil

因此,例如,我可能能够定义某种任意的getOrElse方法

getOrElse(ex:Example, default:Params):Params

现在我正在寻找可能具有这种形式的东西(或类似我建议的类型结构可能不可行).

case class MyOptionList[L <: HList](maybes:L) {
  type Concrete = {somehow the hlist params types as an Hlist}
  def getOrElse(default:Concrete):Concrete = ???

}

给定一组具有两个不同子集的Adts例如:

sealed trait Domain[Y]
sealed trait Command[Y] extends Domain[Y]
sealed trait Query[Y] extends Domain[Y]

case class Add(value:String) extends Command[Ack]
case class Remove(value:String) extends Command[Ack]
case class Exists(value:String) extends Query[Boolean]
case object List extends Query[List[String]]

现在假设我有两个自然变换,对于一些任意的Monad M [_]:

val commandHandler:Command ~> M
val queryExecutor:Query ~> M

我希望以某种方式将这两个自然转换组合成一个转换:

val service:Domain ~> M = union(commandHandler, queryExecutor)

然而,我们正在努力通过拥有更高级别的副产品来摆脱起跑线.在这个阶段,即使是正确方向的一点也会有所帮助.

在Excel中,您可以System.Object[*]使用系列对象返回动态数组XValues.在.NET 3.5中,您可以通过将其转换为数组来访问此对象中的元素,即:

var values = (Array)series.XValues;

在.NET 4.0中,这不再起作用,而且消息也是如此

"无法将'System.Object [*]'类型的对象强制转换为'System.Object []'"

给出.

有任何想法吗？以下不起作用:

• 把它变成动态的.
• 把它投到一个System.Object[*].
• 只需将对象放入for循环中.
• 尝试直接使用该值values[1],而不是在转换为动态时.

但是,数组中的值确实显示在调试器中.

我希望只读和写sqlite的连接,当我打开一个写连接时,我希望它有一个独占锁.这看起来应该有效

val config = new SQLiteConfig();
config.setLockingMode(org.sqlite.SQLiteConfig.LockingMode.EXCLUSIVE)

val connection = DriverManager.getConnection("jdbc:sqlite:" + this.getPath() +"\\" + this.dbName, config.toProperties)

但不幸的是我得到了一个例外

Exception in thread "main" java.sql.BatchUpdateException: batch entry 0: query returns results

我也尝试过直接设置属性,而不是使用Sqlite jdbc SQLiteConfig类

val prop = new Properties();
prop.setProperty("locking_mode", "EXCLUSIVE");

有什么建议？

我想以编程方式将mixins中发送的值绑定到一个实例,我想知道是否有一个更不可变的方法来执行此操作然后使用隐藏的可变对象.主要是我想将它用于注册表.我目前的方法在施工后并非严格不变,有什么建议吗？

trait Numbers {
  lazy val values = holding
  private var holding = Set.empty[Int]
  protected def includes(i:Int) {
    holding += i
  }
}

trait Odd extends Numbers{
  includes(1)
  includes(3)
  includes(5)
  includes(7)
  includes(9)
}

trait Even extends Numbers {
  includes(2)
  includes(4)
  includes(6)
  includes(8)
}

这给出了我想要的结果

val n = new Odd with Even
println(n.values)

Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

我有一个演员从另一个演员那里获取结果并对它进行一些检查.

class Actor1(actor2:Actor2) {

  def receive = {
    case SomeMessage =>
      val r = actor2 ? NewMessage()
      r.map(someTransform).pipeTo(sender)
  }
}

现在,如果我问一下Actor1,我们现在已经生成了2个期货,这看起来并不过分.有没有办法提供某种延续的方法,或者我可以在这里使用的其他方法？

    case SomeMessage => actor2.forward(NewMessage, someTransform)

我目前正在尝试通过 JDBC 优化 Postgres 中的数据加载。我们正在使用 COPY FROM STDIN 和 FORMAT 'binary' 现在构建二进制字节数组对于字符串、长整型、uuid 等来说非常简单。但是在一个实例中，我们表中有一个 JSONB 字段，我不知道如何序列化我的json 对象转换为二进制 jsonb 格式。jsonb 有任何规范吗？

注意：我已经排除了只发送 utf-8 二进制序列化 json 字符串的可能性。