0x00000000004004b6 <main+30>: callq 0x400398 <printf@plt>
有谁知道？
UPDATE
为什么两个disas printf给我不同的结果？
(gdb) disas printf
Dump of assembler code for function printf@plt:
0x0000000000400398 <printf@plt+0>: jmpq *0x2004c2(%rip) # 0x600860 <_GLOBAL_OFFSET_TABLE_+24>
0x000000000040039e <printf@plt+6>: pushq $0x0
0x00000000004003a3 <printf@plt+11>: jmpq 0x400388
(gdb) disas printf
Dump of assembler code for function printf:
0x00000037aa44d360 <printf+0>: sub $0xd8,%rsp
0x00000037aa44d367 <printf+7>: mov %rdx,0x30(%rsp)
0x00000037aa44d36c <printf+12>: movzbl %al,%edx
0x00000037aa44d36f <printf+15>: mov %rsi,0x28(%rsp)
0x00000037aa44d374 <printf+20>: lea 0x0(,%rdx,4),%rax
0x00000037aa44d37c <printf+28>: lea 0x3f(%rip),%rdx # 0x37aa44d3c2 <printf+98>
val x = for(i <- 1 to 3) yield i
x match {
case 1 :: rest => ... // compile error
}
构造函数无法实例化为期望的类型; found:collection.immutable.::: [B] required:scala.collection.immutable.IndexedSeq [Int]
当匹配收到IndexedSeq而不是LinearSeq时,这与MatchError的问题相同.
问题是,怎么做对了？.toList到处添加似乎不对.并创建一个自己的提取器来处理每一个Seq(如另一个问题的答案所述)如果每个人都这样做会导致一团糟......
我想问题是,为什么我不能影响序列理解的返回类型,或者:为什么不是Seq标准库的这种通用提取器部分？
在Haskell中你可以写:
x :: (Int,Int) -> Int
x (p,s) = p
在Scala中你会写:
def x(a: (Int, Int)) = a._1
要么:
def x(a: (Int, Int)) = a match {
case (p, s) => p
}
为什么不喜欢这样的东西
def x(_: (p: Int, s: Int)) = p
要么
def x(foo: (p @ Int, s @ Int)) = p
？
我的问题很简单,但我还没有找到有效的实现.
假设有一个像这样的矩阵A:
0 0 0 0 0 0 0
4 4 2 2 2 0 0
4 4 2 2 2 0 0
0 0 2 2 2 1 1
0 0 0 0 0 1 1
现在我想找到这个矩阵中具有给定大小的矩形区域的所有起始位置.区域是A的子集,其中所有数字都相同.
我们说宽度= 2和高度= 3.有3个区域有这样的大小:
2 2 2 2 0 0
2 2 2 2 0 0
2 2 2 2 0 0
函数调用的结果将是这些区域的起始位置(x,y从0开始)的列表.
List((2,1),(3,1),(5,0))
以下是我目前的实施情况."区域"在这里被称为"表面".
case class Dimension2D(width: Int, height: Int)
case class Position2D(x: Int, y: Int)
def findFlatSurfaces(matrix: Array[Array[Int]], surfaceSize: Dimension2D): List[Position2D] …我对泛型等很满意,但在这个特殊情况下,我有一个关于"类型安全:未经检查从...转换为......"警告的问题.
基本上我有一个Class对象列表,现在我想得到一些实现特殊接口的子集,但结果List也应该有那个特殊的Type:
...
private List<Class<?>> classes;
public List<Class<? extends Concrete>> getConcreteClasses() {
List<Class<? extends Concrete>> concreteClasses = new LinkedList<Class<? extends Concrete>>();
for (Class<?> clazz: this.classes) {
for (Class<?> i : clazz.getInterfaces()) {
if (i.equals(Concrete.class)) {
concreteClasses.add((Class<? extends Concrete>) clazz);
}
}
}
return concreteClasses;
}
警告当然与类型转换相关:
Type safety: Unchecked cast from Class<?> to Class<? extends Concrete>
我可以摆脱类型转换,还是应该使用@SuppressWarnings("unchecked")来抑制警告？
谢谢你的回答!
PS:环境是Java 6.
解决方案:而不是
concreteClasses.add((Class<? extends Concrete>) clazz);
使用
concreteClasses.add(clazz.asSubclass(Concrete.class));
在一个特定的项目中,我(目前)只允许使用JRE6来执行Java应用程序.因此,我maven-compiler-plugin为源和目标配置了1.6.
在我的Maven依赖项中,我包含了一个依赖项,它本身以1.7为目标,并且还使用了1.7个功能,比如try-with-resources - 我认为这会在我自己的项目中导致一些编译时错误或警告(我正在使用Eclipse) .但它没有,所以我的问题是:在特定目标JRE(在我的例子中是JRE6)上运行应用程序(或测试)之前是否可以检测到此类问题？
我有一些代码片段,我生成多个列表(通过for comprehensions),然后连接它们.有一些单元素列表,但这不起作用.在Haskell中,我会做类似的事情
[42 | i == j]
等价的是
(do guard (i == j)
return 42) :: [Int]
要么
(guard (i == j) >>= \_ -> return 1) :: [Int]
在斯卡拉我试过
for (if i == j) yield 42
但它说"非法启动简单模式".
在回答Scala的收益时,作者说"Scala"对于理解"等同于Haskell的"do"符号.
此外,在Scala网站上,它说"理解具有(枚举)产生e的形式,其中枚举是指以分号分隔的枚举器列表.枚举器是引入新变量的生成器,或者是过滤器".但很明显,事实并非如此,因为过滤器似乎只能在发电机之后才能使用.
目前我使用
if (i == j) List(42) else Nil
对于这种特殊情况,我可能不会更喜欢for comprehension语法,而只是使用if-then-else代替.在Haskell中,由于与数学集合构造符号的相似性,它看起来相当不错.
我的问题不是关于风格,而是更多关于技术细节:为什么Haskell和Scala之间的这种特殊情况存在差异？为什么不for (if i == j) yield 42工作？
data Foo = Bar1
| Bar2 Foo Foo
| Bar3 Foo
| Bar4 Foo Foo Foo
现在,假设有人构建了一个Foo树,我想检查Foo值的参数是否有效.构造函数参数的规则是:
Bar2 Bar1 FooBar3 (Bar2|Bar3|Bar4)Bar4 Bar1 Bar1 (Bar1|Bar4)我知道值的构造函数,只想检查立即参数,没有任何递归.像这样:
bar2 Bar1 Bar1 = True
bar2 Bar1 (Bar2 {}) = True
bar2 Bar1 (Bar3 _) = True
bar2 Bar1 (Bar4 {}) = True
bar2 _ _ = False
例如Bar4:
bar4 Bar1 Bar1 Bar1 = True
bar4 Bar1 Bar1 (Bar4 {}) = True
bar4 _ _ _ = False
我怎样才能最简洁地表达这些条件？列出所有组合在某些情况下有点太多了.据我所知,不存在用于模式匹配的"OR"-syntax.
UPDATE
我改编了Daniel的解决方案并且已经解决了这个问题: …
我有以下简单的xml:
<root>
<item>
<d>2002-05-30T09:00:00</d>
</item>
<item>
<d>2005-05-30T09:00:00</d>
</item>
<item>
<d>2003-05-30T09:00:00</d>
</item>
</root>
现在我想找到使用XPath的最小或最大dateTime节点.
我现在的解决方案是:
/root/item[not(number(translate(./d, 'TZ:-', '.')) <= number(translate(following-sibling::item, 'TZ:-', '.')))][not(number(translate(./d, 'TZ:-', '.')) <= number(translate(preceding-sibling::item, 'TZ:-', '.')))][1]/d
它有效,但是很难看,而且效率不高.基本上它将dateTime转换为数字,然后将它们相互比较.我从这里改编了这个.
最好的方法是什么？
干杯
新
foo (a1,a2) (b1,b2) (c1,c2) = (bar a1 b1 c1, bar2 a2 b2 c2)
我有很多具有不同数量的参数元组的构造.如果是
foo' (a1,a2) = (bar' a1, bar2' a2)
我想"嘿,那是箭头!":
foo' = bar' *** bar2'
但我还不知道具有多个输入元组的函数(如第一个代码行中)是否以及如何映射到箭头样式.什么是处理这些功能的通用方法？理想情况下,我总是想要这样的东西foo = bar ... bar2.