我有一个空的程序(module Main where main = return ()),如果我在build-depends中包含一个特定的库,在cabal文件中会出现段错误.
这个库是我自己的,而segfault是bumblebee驱动程序与opengl和haskell的某种交互(只有当我optirun和其他程序一起使用时才会出现段错误,在堆栈跟踪中我只能看到libGL.so),但这不是'我的问题.
我的问题是,一个没有代码段错误的程序怎么样？更准确地说,我的库的哪些代码只是因为它在构建中依赖而运行？我该如何调试这个废话？
编辑.如果我更改了列出额外库的顺序,那么在编译库时,问题就会消失.具体来说,我在sfml-*之前移动了GL,GLEW.但问题仍然存在.我怎么能发现这个,除了漫无目的地摆弄构建文件？
我有以下代码片段,我传递给withFile:
text <- hGetContents hand
let code = parseCode text
return code
这里hand是一个有效的文件句柄,打开ReadMode并且parseCode是我自己的函数,它读取输入并返回一个Maybe.实际上,函数失败并返回Nothing.如果,而是我写:
text <- hGetContents hand
putStrLn text
let code = parseCode text
return code
我得到了一个Just,就像我应该的那样.
如果我openFile和hClose我自己,我有同样的问题.为什么会这样？我怎样才能干净利落地解决它？
谢谢
我遇到过以下几次代码
class Foo {
private Object lock = new Object();
public void doSomething() {
synchronized(lock) {
...
我感兴趣的是为什么创建一个锁对象而不是写synchronized(this)？是否可以共享锁定？我依稀记得读到这是一个优化.真的吗？另外,在某些情况下,将锁定声明为有意义final吗？
Monad是一个幺半群,但它是一个不同于它的幺半群Integer.我不知道是否有写的方式Monoid',并Monad'使得这两个Integer和Monad'可表示为相同的实例Monoid'的类型类？
COM文件中使用了哪些指令集？我以为它是8086,但似乎我错了.在我发现的8086手册中,shl只能接受1或cl作为其第二个参数,而1以外的立即值对我来说工作正常.如果重要,我正在使用NASM.
谢谢你的时间.
我想将Float转换为字节列表[Word8](反之亦然).我看到有一个Storable类可以用于此,但我想避免使用IO monad,因为这与IO无关.
我对Scala很新.我想写几个数学对象(Complex,Polynomial等),这些对象在某些操作(+, - ,*)下是封闭的,它们可以在泛型中使用,并且可以使用隐式强制转换.
我似乎已经解决了第一点.
trait GroupUnderAddition[T] {
def + (t : T) : T
}
case class Real(d : Double) extends GroupUnderAddition[Real] {
def + (r : Real) = Real(d + r.d)
}
case class Complex(re : Double, im : Double) extends GroupUnderAddition[Complex] {
def + (c : Complex) = Complex(re + c.re, im + c.im)
}
object Test {
implicit def real_to_complex(r : Real) = Complex(r.d, 0)
def test[G <: GroupUnderAddition[G]](a : G, b : G) = a + …实体框架有时会生成可怕的导航属性名称.使用数据库第一种方法,解决这个问题的最佳方法是什么？
我可以根据自己的喜好编辑t4模板,但是如何将这些修改后的名称绑定到实际关系？我应该编写一个脚本来修改edmx文件吗？显然,手工制作并不是一种选择.
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/test', {user: 'mongod'});
mongoose.connection.once('open', function () {
我创建了一个带有一个字段和严格的模型:false
var Foo = mongoose.model('Foo', mongoose.Schema({
foo: String
}, {strict: false}));
然后保存带有两个字段的模型
Foo.create({foo: "FOO", bar: "BAR"}, function () {
然后阅读并用字段打印
Foo.findOne(function (err, f) {
console.log(f, f.foo, f.bar);
});
});
});
输出是{ foo: 'FOO', bar: 'BAR', _id: 53c249e876be58931f760e70, __v: 0 },'FOO',undefined.新元素已正确保存并console.log可以看到'BAR',但我不能.只要我在架构中添加栏,我也可以看到它.这是预期的行为吗？如何bar在不将其包含在架构中的情况下进行访问？
我有一个抽象类,有三个方法是等同的意义 - 它们都可以使用一些昂贵的转换函数相互定义.我希望能够编写一个派生类,只需要覆盖其中一个方法并自动获取另外两个方法.例
class FooBarBaz(object):
def foo(self, x):
return foo_from_bar(self.bar(x))
# OR return foo_from_baz(self.baz(x))
def bar(self, x):
return bar_from_foo(self.foo(x))
# OR return bar_from_baz(self.baz(x))
def baz(self, x):
return baz_from_bar(self.bar(x))
# OR return baz_from_foo(self.foo(x))
class Derived1(FooBarBaz):
def bar(self, x):
return 5
# at this point foo = foo_from_bar(5) and
# baz = baz_from_bar(5), which is what I wanted
class Derived2(FooBarBaz):
def foo(self, x):
return 6
# at this point bar = bar_from_foo(6) and
# baz = baz_from_bar(bar_from_foo(6)),
# which is not ideal, …我想将函数转换A -> IO B为IO (A -> B),知道只有有限数量的可能值A.目前我只是这样做
convert :: (A -> IO B) -> IO (A -> B)
convert f = do
b1 <- f a1
b2 <- f a2
...
let f' a1 = b1
f' a2 = b2
...
return f'
但是我对这需要的代码量不满意.
我有一个df包含列"timestamp"和的表"Y"。我想添加另一列"MaxY"，其中包含Y未来最多 24 小时内的最大值。那是
df.MaxY.iloc[i] = df[(df.timestamp > df.timestamp.iloc[i]) &
(df.timestamp < df.timestamp.iloc[i] + timedelta(hours=24))].Y.max()
显然，这样计算是非常慢的。有没有更好的办法？
在类似的计算情况下，"SumY"我可以使用 的技巧来完成cumsum()。然而，在这里类似的技巧似乎不起作用。
根据要求，一个示例表（MaxY 是输出。输入仅是前两列）。
-------------------------------
| timestamp | Y | MaxY |
-------------------------------
| 2016-03-29 12:00 | 1 | 3 | rows 2 and 3 fall within 24 hours, so MaxY = max(2,3)
| 2016-03-29 13:00 | 2 | 4 | rows 3 and 4 fall in the time interval, so …我想实现一堆可以在事件中交换的对象.在接收到上方或下方的事件表单时,对象可以向Ether侧发出其他事件或更改状态(但保持其在堆栈中的位置).
目前我有这个工作.我有一个类型Animation a b,它是事件处理程序的容器,它接收(从上面)类型的事件a并发出(向上)类型的事件,b我有一个函数handle :: Handler -> Animation g h -> Animation e f来堆叠它们.
实际的类型Handler是
Animation g h -> (Either e h) ->
WriterT [Either g f] IO (Either (Animation e f) (Animation g h))
以下(Either e h)是来自上方或下方[Either g f]的事件,是向下或向上发出的事件,并且Either (Animation e f) (Animation g h)是作为独立对象或使用相同处理程序的结果.而且我不高兴.
有没有更优雅的方式来做到这一点？