小编Mic*_*ent的帖子

我有来自GWT in Action的这段代码:

public void processOperator(final AbstractOperator op) {
        System.out.println("Wordt deze ooit aangeroepen?");
        if (op instanceof BinaryOperator) {
            if ((data.getLastOperator() == null) || (data.isLastOpEquals())) {
                data.setBuffer(Double.parseDouble(data.getDisplay()));
                data.setInitDisplay(true);
            } else {
                data.getLastOperator().operate(data);
            }
            data.setLastOperator(op);
        } else if (op instanceof UnaryOperator) {
            op.operate(data);
        }

        data.setLastOpEquals(false);
}

我想通过使用方法分派来消除'instanceof'部分:

public void processOperator(final BinaryOperator op) {
    if ((data.getLastOperator() == null) || (data.isLastOpEquals())) {
        data.setBuffer(Double.parseDouble(data.getDisplay()));
        data.setInitDisplay(true);
    } else {
        data.getLastOperator().operate(data);
    }
    data.setLastOperator(op); 
    data.setLastOpEquals(false);
}

public void processOperator(final UnaryOperator op) {
    op.operate(data);
    data.setLastOpEquals(false);
}

但是现在我在ButtonOperator类的代码中遇到了麻烦.以下代码将AbstractOperator作为构造函数中的类型.类型UnaryOperator和BinaryOperator的代码看起来完全相同,因此为它们制作包含完全相同代码的特殊构造函数感觉有点麻烦.什么是更好的方法？

public ButtonOperator(final …

我们有一张m1包含数百万条记录的表格.我们希望生成一个表格,m2其中包含每个记录的计算结果m1.我们目前运行如下:

(jdbc/with-db-transaction [tx connection]
  (jdbc/query tx
    [(jdbc/prepare-statement (:connection tx)
                              "select * from m1"
                              {:fetch-size 1000})]
     {:result-set-fn (process! [tx result-set] ...)})) 

这里process!是

(defn process! [tx result-set]
  (jdbc/with-db-transaction [tx tx]
    (jdbc/insert-multi! tx :m2 [:m2_column]
      (mapv (fn [r] [(calculate r)]) 
        result-set))))

该select查询使用游标并懒洋洋地消耗掉.请参阅:clojure.java.jdbc延迟查询.这就是它被包装在外部事务中的原因.

问题:

• Postgres是否存在数百万条记录的(嵌套)交易？该clojure.java.jdbc文档说嵌套事务被外一个吸收,所以我们实际上只有一个事务.它是否正确？
• 如果我们想要为插入创建单独的事务,那么使用与数据库的不同连接的解决方案是什么？我们已经使用了连接池,所以可能已经是这种情况了？

如何在有效的Postgres SQL查询中编写以下内容：

with foo as (select * from ...)
insert into bar select * from foo
insert into baz select * from foo

考虑以下(LinqPad)示例.X类中的ToString标记为虚拟.为什么这里的输出不等于"嗨,我是Y,嗨,我是X",而是打印出类型名称？当然标记ToString virtual是错误的,因为它在Object中定义为虚拟,我只是想了解这里发生了什么.

void Main()
{
    Y y = new Y();
    Console.WriteLine(y);
}

// Define other methods and classes here

class X
{
  public virtual String ToString() 
  {
    return "Hi, I'm X";
  }
}

class Y : X
{
  public override String ToString() 
  {
    return "Hi, I'm Y, " + base.ToString();
  }
}

是否可以使用foldl而不是foldr来实现过滤器？如果是这样,请轻轻解释您的实施.

我创建了一个作为Mac App启动的JavaFX应用程序.我希望它能够启动,以便窗口始终位于其他应用程序之上.我怎样才能做到这一点？

如何使用批处理文件更改 Windows 中文件的“修改”时间戳？

在单元测试中，我想模拟Exception发生的情况。

由于doTry/doCatch-block ，我希望在“mock:count”端点收到一条消息。为什么这没有发生，为什么Exception由一般onException-block处理？

import org.apache.camel.LoggingLevel;
import org.apache.camel.builder.AdviceWithRouteBuilder;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.mock.MockEndpoint;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.apache.cxf.binding.soap.SoapFault;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;

public class TestClass extends CamelTestSupport {
   @Override
   protected RouteBuilder createRouteBuilder() throws Exception {
      return new RouteBuilder() {
         @Override
         public void configure() throws Exception {
            onException(Exception.class)
                  .log(LoggingLevel.INFO, "outer catch")
                  .handled(true);

            from("direct:start")
                  .doTry()
                     .to("mock:exception")

                  .doCatch(Exception.class)
                     .log(LoggingLevel.INFO, "inner catch")
                     .to("mock:count")
                  .end();
         }
      };
   }

   @Test
   public void testBlaat() throws Exception {
      final …

如果我有一个类似的程序

main = print ( (+) <$> Just 1 <*> Just 2 )

将编译器决定减少我的程序,它不依赖于的部分IO像

( (+) <$> Just 1 <*> Just 2 ) => (Just 3)？

或者程序是否仍然创建一个新函数(+) <$> Just 1,然后Just 2在运行时应用它？

给定于GHC.Base:

instance Applicative ((->) a) where
    pure = const
    (<*>) f g x = f x (g x)
    liftA2 q f g x = q (f x) (g x)

怎么能有(<*>)三个论点的定义？我以为只花了两个.我该如何解析这个？