小编Ale*_*nov的帖子

其他答案建议使用"-Xlog-implicits"选项来调试"分散隐式扩展"错误.但是,它也会在与这些错误无关的地方记录大量含义.有没有办法限制它只能解释产生编译错误的地方？

将日志文件自动附加到支持电子邮件会很有用.我可以以编程方式设置路径(如以编程方式设置Logback Appender路径),但我更愿意让用户以熟悉的方式配置日志记录logback.xml.那么,我可以找到logback用于记录的文件吗？

作为一个不熟悉Python的人,我经常听到很多赞美SQLAlchemy.所以我想明白:

1. 与"类型安全的SQL构建器"(如jOOQ或QueryDSL)相比,它提供了什么？

2. Java(或Scala)世界中是否有更接近的等价物？我见过Apache Empire-DB在这方面提到过......

相当多Map的函数在一个键值元组上作为参数.例如def foreach(f: ((A, B)) ? Unit): Unit.所以我找了一个简短的方法来写一个参数foreach:

> val map = Map(1 -> 2, 3 -> 4)

map: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 3 -> 4)

> map.foreach((k, v) => println(k))

error: wrong number of parameters; expected = 1
       map.foreach((k, v) => println(k))
                          ^

> map.foreach({(k, v) => println(k)})

error: wrong number of parameters; expected = 1
       map.foreach({(k, v) => println(k)})
                           ^

> map.foreach(case (k, v) => println(k))

error: illegal start of simple expression …

目前,要从当地时区1970年开始获得毫秒,我做到了

long localMillis = dateTime.withZone(timeZone).toLocalDateTime()
    .toDateTime(DateTimeZone.UTC).getMillis();

这有效,但有更简单的方法吗？

是否有任何预处理器符号允许类似的东西

#if CLR_AT_LEAST_3.5
// use ReaderWriterLockSlim
#else
// use ReaderWriterLock
#endif

或其他一些方法来做到这一点？

通过模糊匹配,我不是指Levenshtein距离或类似的相似字符串,而是它在TextMate/Ido/Icicles中的使用方式:给定一个字符串列表,找到包含搜索字符串中所有字符的字符串,但可能还有其他字符串之间的人物,更喜欢最合适.

让我们以Wes Dyer的函数memoization方法为出发点:

public static Func<A, R> Memoize<A, R>(this Func<A, R> f)
{
  var map = new Dictionary<A, R>();
  return a =>
    {
      R value;
      if (map.TryGetValue(a, out value))
        return value;
      value = f(a);
      map.Add(a, value);
      return value;
    };
}

问题是,当从多个线程使用它时,我们可能会遇到麻烦:

Func<int, int> f = ...
var f1 = f.Memoize();
...
in thread 1:
var y1 = f1(1);
in thread 2:
var y2 = f1(1);
// We may be recalculating f(1) here!

我们试着避免这种情况.锁定map:

public static Func<A, R> …

假设我有一个Java类

abstract class Base {
    abstract void init();
    ...
}

而且我知道每个派生类都必须init()在它构造之后调用.当然,我可以简单地在派生类的构造函数中调用它:

class Derived1 extends Base {
    Derived1() {
        ...
        init();
    }
}

class Derived2 extends Base {
    Derived2() {
        ...
        init();
    }
}

但这会破坏"不要重复自己"的原则而且会很糟糕(而且会有很多子类Base).当然,init()调用不能进入Base()构造函数,因为它会被执行得太早.

任何想法如何绕过这个问题？我也很高兴看到Scala解决方案.

更新:这是工厂方法方法的通用版本:

interface Maker<T extends Base> {
    T make();
}

class Base {
    ...
    static <T extends Base> T makeAndInit(Maker<T> maker) {
        T result = maker.make();
        result.init();
        return result;
    }
}

更新2:这个问题基本上是"你如何使用模板方法为构造函数"？答案似乎是,"你可以,但这是一个坏主意".所以我可以做一个模板工厂(模板方法+抽象工厂).

Observable从传统的Java事件模式创建Rx-Java的最佳方法是什么？也就是说,给定

class FooEvent { ... }

interface FooListener {
  void fooHappened(FooEvent arg);
}

class Bar {
  public void addFooListener(FooListener l);
  public void removeFooListener(FooListener l);
}

我想实施

Observable<FooEvent> fooEvents(Bar bar);

我想出的实现是:

Observable<FooEvent> fooEvents(Bar bar) {
  return Observable.create(new OnSubscribeFunc<FooEvent>() {
    public Subscription onSubscribe(Observer<? super FooEvent> obs) {
      FooListener l = new FooListener() {
        public void fooHappened(FooEvent arg) {
          obs.onNext(arg);
        }
      };

      bar.addFooListener(l);

      return new Subscription() {
        public void unsubscribe() {
          bar.removeFooListener(l);
        }
      };
    }
  }); 
}

但是,我真的不喜欢它:

1. 它非常冗长;

2. 需要一个监听器Observer(理想情况下,如果没有观察者,则应该没有监听器,否则一个监听器).这可以通过将观察者计数保持为一个字段, …