我知道你可以 间接定义它们 与同伴对象实现类似的东西,但我想知道为什么语言设计是从类定义中删除静态.
将各种SBT任务与本机库(例如,来自JOGL,LWGL或JCuda的那些)集成的好方法是什么？具体来说,
是否有推荐的方法在run任务中包含本机库？关于SBT邮件列表的讨论表明了这些可能性:
JavaOptions为包含-Djava.library.path=<path to native libraries>,然后修改run任务以分叉JVM.(有关示例,请参阅此插件.)initialize设置运行调用System.setProperty(...)configure的代码java.library.path.再次,run必须分叉.最后一个的优点是run不需要fork,但缺点是配置必须在SBT之外完成.
我可以自动在sbteclipse插件生成的Eclipse项目中包含本机库吗？可以在后处理步骤中重写.project文件.有示例代码吗？有没有更好的办法？
本机库是否可以包含在由sbt-assembly,sbt-onejar或sbt-proguard等插件生成的可运行Jar中？
我假设本机库没有直接的SBT设置.如果存在类似的东西,上述任务是否可以透明地处理本机库？
给定一个键k在一个SortedMap,我怎么能有效地找到最大的关键m是小于或等于k,也是最小的关键n是大于或等于k.谢谢.
以下伪Scala产生"非法循环引用"错误:
trait GenT[A]
trait T extends GenT[T#A] {
type A
}
问题:为什么这是非法的？是否存在稳健性的基本问题,或者它是Scala类型系统的限制？有解决方法吗？
我的目的是创建一个T具有类型成员的特征,该特征A可以通过超级特征按需提升到类型参数GenT[A].例如,一个应用程序可能是约束的表达
def foo[A, S1 <: GenT[A], S2 <: GenT[A]] ...
这可以像使用def foo[S1 <: T, S2 <:T] ...约束那样使用S1#A == S2#A.
如果技术可行,它也可能有助于解决这个问题:如何专注于Scala中的类型投影？
注意:我可以使用GenT而不是在T任何地方,但我试图避免这种情况,因为它会导致许多类型参数在我的所有代码中传播"感染".
下面的两个问题看似相似,但是关于不同类型的循环引用:
我正在为最新版本的FFTW寻找一个最小的Java包装器.在FFTW网站上列出的包装器要么过时(jfftw-1.2.zip),要么包含太多额外的东西(Shared Scientific Toolbox).谷歌搜索建议JFFTW3看起来很有前景,但下载链接已经破了(有人有镜子吗？)
对于那些想要纯Java FFT库的人来说,JTransforms看起来非常好.我更喜欢使用FFTW,因为它大约快两倍,它处理任意尺寸d> 3.
我对静态类型语言没有多少经验(目前正在学习Scala并喜欢它!)但我注意到的一件事是它们似乎没有像Ruby的method_missing或ColdFusion的onMissingMethod那样的东西.静态类型语言是否存在一些固有的限制,可以防止或使其变得困难？
问题陈述
考虑一个T包含抽象类型成员的类型A:
trait T {
type A
}
我想创建一个类T0 <: T作为类型参数,但专注于类型投影 T0#A.例如,在下面,该方法foo可以是专用的吗？
class Foo[T0 <: T] {
def foo(a: T0#A, f: T0#A => T0#A) = f(a)
}
需要注意的是注释T0与@specialized不会达到预期的效果.是否有一种专门foo研究类型投影的好方法T#A？
有限的解决方案:从具有额外参数的专用父类继承
在这种特殊情况下,这是一种专门研究的方法T0#A:
trait SpecializedFoo[@specialized A0, T0 <: T] {
def foo(a: A0, f: A0 => A0) = f(a)
}
class Foo2[T0 <: T] extends SpecializedFoo[T0#A, T0]
通过继承专门的父类SpecializedFoo,我们确保它Foo2.foo是专门的.
验证专业化 …
正如Scala邮件列表中的这个帖子所要求的那样,我如何创建一个继承父程序类路径的嵌入式Scala REPL？假设父Scala程序是使用启动的scala -cp <classpath> ...; 可以<classpath>作为字符串访问并用于初始化嵌入的REPL？(可用的Java类路径System.getProperty("java.class.path")似乎与Scala类路径不同.)
或者,也许嵌入式Scala REPL可以从父进程继承或构造其ClassLoader(MichaelDürig的ScalaDays 2010谈话可能是相关的).这是推荐的方法吗？
在Scala类中,我可以方便地声明方法的返回类型,this.type以保证它将返回调用它的同一对象:
class Foo {
def bar: this.type = this
}
有没有一种方法可以类似地指定接受给定AnyRef参数的方法将完全返回该引用？以下代码段不提供此保证,我可以返回以下任何实例A:
def processAndReturn[A <: AnyRef](obj: A): A = {
// work with obj
obj
}
我是Scala的新手,我遇到了一个错误,我无法通过自己或通过互联网搜索解决.
我有一个名为"GUI"的Scala类,它代表一个JFrame以及一个伴侣类.当我尝试使用import GUI._我导入伴侣类时,我得到错误"需要稳定的标识符,但发现了GUI.this.GUI()".
我创建了一个空类和伴随对象,导入工作正常,所以我假设错误与我的代码特定的东西有关.以下是有问题的代码:
object GUI {
def test:Integer = 1
}
class GUI extends JFrame{
import GUI._
val ICON_LOCATION:File = new File("Images/iMovies.ico");
val ICON:BufferedImage = Ootil.createImage("iMovies.png");
val TITLE:String = "iVideos";
val LICENSE_NAME:String = "OpenBSD";
def GUI(){
setLayout(new BorderLayout());
createGUI();
pack();
setSize(100,100);
setLocationRelativeTo(null);
setVisible(true);
}
def versionMajor: Integer = 1
def versionMinor: Integer = 0
def versionRevision: Integer = 0
def versionPreReleaseID: String = "alpha"
def versionBuildNumber: String = "1b"
private def createGUI():Unit = {
val panel = …我有一个数组,我想切换轴的顺序.它类似于转置,除了我想在尺寸大于2的数组上执行它.在Python中我会使用np.transpose和Matlab中的permute,但我似乎无法在Julia中找到它.例如,
a = ones(2, 3, 4)
size(a)
(2,3,4)
从此我想通过将轴(尺寸)重新排列为(2,3,1)来得到一个形状(3,4,2)的数组.我正在寻找一个名为new_func的函数.
b = new_func(a, (2, 3, 1))
size(b)
(3,4,2)
我试图编写一些抽象代码,使其逐步变得更加复杂.它已经破坏了其中一个步骤.
第一步,正确
trait Base
trait C1 extends Base
trait Abst extends Base
trait Conc extends Abst with C1
第二步,正确
object BaseHolder {
trait Data
}
object C1Holder {
trait Data extends BaseHolder.Data
}
trait Abst extends BaseHolder.Data
trait Conc extends Abst with C1Holder.Data
第3步,越野车错误
trait BaseHolder {
trait Data
}
object BaseHolder extends BaseHolder
trait C1Holder extends BaseHolder {
trait Data extends super.Data
}
object C1Holder extends C1Holder
trait Abst extends BaseHolder.Data
trait Conc extends Abst with C1Holder.Data
我有错误:非法继承; trait …
我想我已经实现了一些错误的代码.我无法弄清楚为什么我的排序(使用arrays.sort)在"并行"版本中比在非并行版本中花费更长时间(显然是将两个数组重新组合在一起,但我认为它不会添加更多的时间).如果有人可以指出我正在犯的任何错误或任何改进非并行版本的并行版本的技巧,我将不胜感激.我能够更有效地进行阵列合并,甚至可以并行进行吗？如果是这样,实施的最佳做法是什么.任何帮助将不胜感激.
import java.util.Arrays
import scala.concurrent._
import scala.collection._
trait Sorts {
def doSort(a: Array[Double]): Array[Double]
}
object Simple extends Sorts {
def doSort(a: Array[Double]) = {
Arrays.sort(a)
a
}
}
object Parallel extends Sorts {
def doSort(a: Array[Double]) = {
val newArray = new Array[Double](a.length)
val aLength = (a.length)
val aSplit = ((a.length / 2).floor).toInt
ops.par(Arrays.sort(a, 0, aSplit), Arrays.sort(a, (aSplit + 1), aLength))
def merge(w: Int, x: Int, y: Int) {
var i = w
var j = x
var k …