正如标题所述,我希望有一种方法可以应用于任何类型的参数,如Array[Array[_]]or Seq[Array[_]]或Array[Seq[_]]or Seq[Seq[_]].参数应转换为2D数组(Array[Array[_]]),因此只更改所涉及的集合的类型.

我有以下签名似乎接受任何这样的组合,但我不能建立阵列.

  def apply[A: Manifest, S[_] <: Seq[_], U <% S[S[A]]](components: U): CombinationIterator[A] = {
    new CombinationIterator(Array(components.map((s: S[A]) => s.toArray)))
  }

本CombinationIterator类需要一个Array[Array[T]]作为其参数.我收到以下错误:

error: could not find implicit value for evidence parameter of type ClassManifest[A]
new CombinationIterator(Array(components.map((s: S[A]) => s.toArray)))

为了完整性,这里是构造函数; 也许它很重要,因为它需要一个Manifest对A.

class CombinationIterator[A: Manifest](components: Array[Array[A]]) extends Iterator[Array[A]]

失败的REPL会话

以下适用于Array[Seq[_]]但不适用于Seq[Array[_]]:

scala> def f[T:Manifest](s: Seq[Seq[T]]) = s.map(_.toArray).toArray
f: [T](s: Seq[Seq[T]])(implicit …

有人可以解释为什么以下不编译？我想这BB[A]也是一个List[A].方法主体仅强制执行此视图.

scala> def x[A, BB[_] <: List[_]](p: BB[A]) {p: List[A]}
<console>:8: error: type mismatch;
 found   : BB[A]
 required: List[A]

       def x[A, BB[_] <: List[_]](p: BB[A]) {p: List[A]}
                                             ^

以下代码无法编译:

var next: (A, A) = (null, n)

错误:

error: type mismatch;
found   : Null(null)
required: A
var next: (A, A) = (null, n)

也var next: (A, A) = ((null: A), n)失败了同样的错误.

不知怎的,我认为它应该编译.

我目前正在使用以下代码,它似乎有效:

var next: (A, A) = (null.asInstanceOf[A], n)

为什么不起作用？错误或功能？

编辑

阅读didiers之后回答问题很明显.我错过了null只能分配给AnyRef类型.对于我的问题,我选择制作元组(n,n)并使用布尔标志,无论第一个条目是否有效.根据应用程序Option可能是更好的解决方案.

给定一个序列，Seq[Matcher[A]]我想获得一个Matcher[A]当序列内的所有匹配器都成功时成功的单个序列。

编辑

我自己提供的答案似乎有点笨拙，此外，如果序列中所有失败的匹配器都产生一个结果，那就太好了

我按照本指南设法在Linux下运行JavaFX 2.0 .通过使用Wine运行Windows版本的Java,它可以很好地工作.此Java进程可以获取Windows版JavaFX的本机.dll文件.

现在我想知道是否有一个不同的解决方案运行Linux版本的Java,但不知何故通过Wine访问.dll文件.

以图形方式总结:

• 作品: Wine - > Java(win) - > DLL(win)
• 我在问什么: Java(linux) - > Wine - > DLL(win)

我为什么要这样做

我希望使应用程序像任何其他Java应用程序一样启动,并且只需要安装Wine.已经运行的解决方案需要Wine安装和 Windows版本的Java.

我希望实现以下内容:

(_ : Map[K,Int]).mapKey(k, _ + 1)

并且该mapKey函数仅将第二个参数(Int => Int)应用于存储在其下的值k.标准库中有什么东西吗？如果不是我打赌Scalaz中有什么东西.

当然我可以自己编写这个函数(m.updated(k,f(m(k)))并且这样做很简单.但是我已经多次遇到这个问题,所以也许它已经完成了？

对于Scalaz,我想象下面的代码:

(m: Map[A,B]).project(k: A).map(f: B => B): Map[A,B]

原谅我英语不好,但我会尽力表达我的问题.

假设我想处理一个大文本,其操作是通过关键字过滤内容; 把它们改成小写; 然后将它们打印到标准输出上.众所周知,我们可以使用Linux BASH脚本中的管道执行此操作:

cat article.txt | grep "I" | tr "I" "i" > /dev/stdout

其中cat article.txt,grep "I",tr "I" "i" > /dev/stdout并行运行.

在Scala中,我们可能会这样做:

//or read from a text file , e.g. article.txt 
val strList = List("I", "am", "a" , "student", ".", "I", "come", "from", "China", ".","I","love","peace")  
strList.filter( _ == "I").map(_.toLowerCase).foreach(println)

我的问题是,我们如何才能使filter,map和foreach水货？

谢谢

我有一个特质Outer与成员F是一个类型构造.我想提供类型类实例F,但不知何故,在某一点上隐式解决方案scalac停止工作.

我尝试构建一个较小的最小示例,但我必须添加下面的所有内容才能显示错误.注意倒数第二行仍在编译,正确地从嵌套的伴随对象中拾取隐含的行sub.

但是最后一行不再编译了.另请注意,在倒数第二行中指定隐式方法时,它会进行编译.

任何人都可以提供为什么会发生这种情况的线索？

trait TC[F[_]]

trait Outer[N[_]] {
  trait F[_]
  object F {
    implicit val tcInst: TC[F] = new TC[F]{}
  }
}

case class Sub[N[_]]() extends Outer[N]

object Test{
  implicit val optionInst: TC[Option] = new TC[Option]{}

  val sub = Sub[Option]()
  val sub2 = Sub[sub.F]()

  implicitly[TC[sub.F]]                  //compiles
  implicitly[TC[sub2.F]](sub2.F.tcInst)  //compiles
  implicitly[TC[sub2.F]]                 //doesn't compile
}

最后一行产生以下错误:

Error:(22, 13) could not find implicit value for parameter e: test.novariance.TC[test.novariance.Test.sub2.F]
  implicitly[TC[sub2.F]]                 //doesn't compile
            ^
Error:(22, …

使用哈希映射时,通常会出现性能瓶颈equals.equals对于深度数据结构来说可能非常昂贵.

注意,以下是关于不可变哈希映射.因此,至少你永远不会删除密钥.我认为添加密钥应该没问题.

不安全 get

假设您查询哈希映射,确定它包含查询的密钥.然后,如果给定键没有冲突,则可以仅基于散列命中返回找到的单个条目,因为它必须是查询的对象.

这可避免调用equals在get大多数情况下(当没有冲突).

问题

1. 这个概念怎么称呼？
2. 是否有可用于Java或Scala的哈希映射实现,它们支持这种不安全的get操作？

顺便说一句,我愿意接受更好主题的建议.

我正在尝试寻找解决问题的实用方法(例如在工程方面的努力),其中我有一堆未知值:

val a: Int32 = ???
val c: Int32 = ???
val d: Bool = ???

和表达式二进制树(在内存中),最终返回一个布尔值,例如

((a > 4) || (b == (c+2))) && (a < b) && ((2*d)) || e

我有的布尔运算符and or xor not和32位整数有比较的东西,以及加法,乘法,除法(注意:这些必须尊重32位溢出!)以及一些按位的东西(移位,按位&,| ^).但是,我不一定需要支持所有这些操作[参见:LOL_NO_IDEA]

我想得到三个答案中的一个:

• ES_POSSIBLE [我不需要知道如何,只是被告知它有可能存在的方式]
• 不可能[无论我的变量保持什么值,这个方程永远不会是真的]
• LOL_NO_IDEA [如果问题太复杂或耗时,这是可以接受的]

我正在解决的问题都不是太大或太复杂,而且条款太多(最多的是大约数百个).并且有大量的LOL_NO_IDEA可以.然而,我正在解决数以百万计的这些问题,因此不断的成本将会刺痛(例如转换为文本格式,并唤起外部解算器)

因为我是用scala做的,所以使用SAT4J看起来非常吸引人.虽然,文档很糟糕(特别是像我这样的人,他们只关注这个SAT世界几天)

但我目前的想法是,首先将每个Int32变为32个布尔值.这样我可以通过将它作为嵌套布尔表达式来表达像(a <b)这样的关系(比较msb,如果它们是eq,那么下一个等等)

然后当我有一个布尔变量和布尔表达式的大表达式树时 - 然后遍历它,同时逐步建立一个:http: //en.wikipedia.org/wiki/Conjunctive_normal_form

然后将其喂入SAT4J.

然而,所有这些看起来都非常具有挑战性 - 甚至构建CNF似乎效率很低(以天真的方式做,我实现它)并且容易出错.更不用说尝试将所有整数数学编码为布尔表达式.而且我无法为像我这样的人找到好的资源,一个想要使用SAT解决问题的工程师主要是一个黑盒子

我很感激任何反馈,即使它像"哈哈,你的白痴 - 看看X"或"是的,你的想法是正确的.享受!"