小编Rus*_*ell的帖子

是否可以before_save在模块中定义回调？这样的类是这样的:

class Model
  include MongoMapper::Document
  include MyModule
end

和这样的模块:

module MyModule
  before_save :do_something

  def do_something
    #do whatever
  end  
end 

do_something将在Model保存任何对象之前调用？我试过这样但是得到了undefined method 'before_save' for MyModule:Module.

抱歉,如果这很简单 - 我是Ruby和Rails的新手.

我正在使用Ruby on Rails 3.0.10,我想以条件方式构建一个哈希键\值对.也就是说,如果条件匹配,我想添加一个键及其相关值:

hash = {
  :key1 => value1,
  :key2 => value2, # This key2\value2 pair should be added only 'if condition' is 'true'
  :key3 => value3,
  ...
}

我怎么能这样做并保持代码的"良好"可读性？我"被迫"使用这种merge方法吗？

我曾经遇到过这个问题几次而且只是偶然发现了一个(半)可靠的解决方案,所以我想在这里发布它以防万一它可以帮助其他人,或者万一我忘了它,还要问是否有人知道根本原因是什么以及我的修复工作原因.

问题 - 我有一个spring 3 webapp,我想在Eclipse中使用Run on Server选项在Tomcat 7服务器上运行.对于一些项目,这只是起作用,但有些项目似乎处于破坏状态,每次服务器启动时,我都会找到一个未找到的类:org.springframework.web.servlet.DispatcherServlet.

经过一番调查,我发现,该项目的Maven依赖没有被复制到WEB-INF/lib中${PROJECT_LOCATION}/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/

在最终注意到项目在"问题"面板中发出警告之前,我尝试了很多事情:

Classpath entry org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER 
will not be exported or published. Runtime ClassNotFoundExceptions may result.

也许我应该早点注意到这一点.

无论如何,选择这个并执行"快速修复"可以解决问题,我可以愉快地运行我的项目.快速解决方法是:"将关联的原始类路径条目标记为发布/导出依赖项".

麻烦的是,虽然这有效,但我不知道这意味着什么.完成后,我的项目配置中看不到任何明显的变化.我很想知道实际问题是什么,以及我是否可以避免它再次发生.我还想知道是否有一些我本可以完成的事情(除了执行快速修复之外)可以修复它,因为我觉得我几乎尝试了其他一切.

谢谢你的帮助.

虽然Scala演员被描述为轻量级,但Akka演员更是如此,显然有一些使用它们的开销.

所以我的问题是,与Actors并行的最小工作单元是什么(假设它可以并行化)？如果存在潜在的延迟或者存在大量繁重的计算,它是否值得？

我正在寻找一个可以轻松应用于日常工作的一般经验法则.

编辑:答案至今让我意识到,我很感兴趣,也许是真正的逆我原来问的问题.所以:

假设用actor构造我的程序非常合适,因此不会产生额外的开发开销(或者甚至比非actor的实现产生更少的开发开销),但是它执行的工作单元非常小 - 是否存在使用演员在性能方面会有什么损害,应该避免哪些？

当我使用我构建一个列表时,foldLeft经常会因为必须明确键入注入的参数而烦恼,并希望我可以使用"Nil" - 这是一个人为的例子:

scala> List(1,2,3).foldLeft(List[Int]())((x,y) =>  y :: x)
res17: List[Int] = List(3, 2, 1)

scala> List(1,2,3).foldLeft(Nil)((x, y) => y :: x)
<console>:10: error: type mismatch;
 found   : List[Int]
 required: scala.collection.immutable.Nil.type
              List(1,2,3).foldLeft(Nil)((x,y) =>  y :: x)

这一点并不是很糟糕,List[Int]但只要你开始使用自己的类列表,几乎可以肯定会有更长的名称,甚至是元组或其他容器的列表,所以你需要指定多个类名,它变得可怕:

list.foldLeft(List.empty[(SomethingClass, SomethingElseClass)]) { (x,y) => y :: x }

我猜它不起作用的原因是,虽然像5 :: Nil编译器这样的东西可以推断出空列表的类型List[Int],但是当Nil它作为参数传递给foldLeft它时没有足够的信息这样做,当它被使用时,它的类型被设置.但是 - 它真的不可能吗？难道它不能从作为第二个参数传递的函数的返回类型推断出类型吗？

如果没有,是否有一些我不知道的整洁成语？

each在ruby中调用hash时,你可以像这样得到键和值很好地分开:

{ :a => 1, :b => 2, :c => 3 }.each do |key, value| 
  puts "key is #{key} and value is #{value}"
end

=========================

key is :a and value is 1
key is :b and value is 2
key is :c and value is 3
=> {:a=>1, :b=>2, :c=>3}

但是,这在使用时似乎不起作用inject.

{ :a => 1, :b => 2, :c => 3 }.inject(0) do |result, key, value| 
  puts "key is #{key} and value is #{value}"
  result + value …

我正在学习新项目的scala,尽可能地追求不变性和功能性风格.

我正在创建的对象之一在其构造函数中接受了大量输入,然后重复应用大量计算来生成相关输出,这些输出作为字段存储在对象上.

虽然执行了计算并且它们的结果在ListBuffer内部添加到了可变的内容,但是关于该对象的所有其他内容都是不可变的 - 一旦创建,您就无法更改任何输入值并再次运行计算显然会产生相同的结果.

但是,在构造函数中进行如此多的计算似乎并不合适.我能看到的唯一方法是让计算值为vars并提供一个run执行计算的方法 - 但是这个方法可以被多次调用,这是没有意义的.

在scala构造函数中做很多事情真的很好吗？例如,没有对DB的调用,只是内部计算.或者有一些模式吗？

这是非常简单形式的基本思想:

class Foo(val x:Int, val y:Int, calculations:List[Calculation]) {
  val xHistory = new collection.mutable.ListBuffer[Int]()
  val yHistory = new collection.mutable.ListBuffer[Int]()

  calculations.map { calc => calc.perform(this) }.foreach { result => 
    xHistory += result.x 
    yHistory += result.y
  }
}

基本上我希望输入包装在一个方便的Foo对象实例中,这样我就可以将它传递给各种计算策略(每个计算策略可能需要不同的输入组合).

是否可以使用聚合框架按数组的特定元素进行分组？

这样的文件就像这样:

{
  name: 'Russell',
  favourite_foods: [
    { name: 'Pizza', type: 'Four Cheeses' },
    { name: 'Burger', type: 'Veggie'}
  ],
  height: 6
}

我可以得到一份独特的最受欢迎的食物清单(即0号食物)以及最受欢迎食物的最高人物的高度？

像这样的东西(尽管它不起作用,因为数组索引访问点表示法似乎在聚合框架中不起作用):

db.people.aggregate([
  { $group : { _id: "$favourite_foods.0.name", max_height: { $max : "$height" } } }
])

如果问题很愚蠢的话,我对Haskell完全不熟悉.

我想要做的递归是建立一个列表,而在同一时间建立的累计值基础上的递归调用.这是我正在为Coursera课程做的一个问题,所以我不会发布确切的问题,但类似的东西.

例如说我想采取INTS的列表和双每一个(忽略,我可以只使用例子的目的map),但我也想计数数"5"有多少次出现在列表中.

所以要加倍我可以做到这一点:

foo []     = []
foo (x:xs) = x * 2 : foo xs

到目前为止这么容易.但是我怎样才能保持五倍的计数x呢？我得到的最好的解决方案是使用这样的显式累加器,我不喜欢它,因为它反转列表,所以你需要在结束时反向:

foo total acc []     = (total, reverse acc)
foo total acc (x:xs) = foo (if x == 5 then total + 1 else total) (x*2 : acc) xs

但我觉得这应该能够被Statemonad 处理得更好,我之前没有用过,但是当我尝试构建一个适合我看到的模式的函数时,我会因为递归调用而陷入困境foo.有没有更好的方法来做到这一点？

编辑:我需要这个工作很长的列表,所以任何递归调用也需要尾递归.(由于Haskell的'tail recursion modulo cons',我在这里的例子设法是尾递归的).

偶尔写Ruby的时候,我发现自己想一个pipe方法,类似于tap但返回的结果与调用块self作为参数,就像这样:

class Object
  def pipe(&block)
    block.call(self)
  end
end

some_operation.pipe { |x| some_other_operation(x) }

..但到目前为止,我还没有设法找出它的名称,如果存在的话.它存在吗？

如果没有,我知道我可以通过猴子补丁来添加它,但是,你知道,这很糟糕.除非有一个辉煌的,保证永不冲突(和描述性和简短)的名称,我可以用它...