小编ron*_*ron的帖子

在以下情况

trait T {

 @tailrec
 def consume[A](as: Stream[A]): Unit = {
    if (as.isEmpty) ()
    else consume(as.tail)
  }
 }

object O extends T

主叫O.consume(Range(1, N).toStream)用N足够大的,程序将运行的存储器,或者至少将消耗O(N),而不是所需要的O(1).

上下文

这是一个主要关于Lucene(或可能是Solr)内部的问题.主题是分面搜索,其中搜索可以沿着对象的多个独立维度(方面)发生(例如,汽车的大小,速度,价格).

当使用关系数据库实现时,对于大量方面,多字段索引没有用,因为可以按任何顺序搜索构面,因此使用特定有序多索引的机会很小,并且创建所有可能的索引排序是不堪.

Solr被广告以应对分面搜索任务,如果我认为正确必须与Lucene(据称)在多字段查询(其中文档的字段与对象的构面相关)上表现良好.

题

Lucene 的反向索引可以存储在关系数据库中,并且使用单字段索引也可以通过RDBMS轻松地实现匹配文档的交叉.

因此,Lucene应该有一些先进的多字段查询技术,而不仅仅是根据反向索引获取匹配文档的交集.

所以问题是,这种技巧/技巧是什么？更广泛地说:为什么Lucene/Solr在理论上可以实现比RDBMS更好的分面搜索性能(如果是这样)？

注意:我的第一个猜测是Lucene会使用一些空间分区方法来将从文档字段构建的向量空间划分为维度,但据我所知,Lucene并非纯粹基于向量空间.

是否可以(通过插件或其他方式)为Eclipse构建项目的全文索引,以便搜索String不会线性搜索项目中的所有文件？

(或者是否自动构建这样的索引以加速未来的搜索？)

正如我所读到的,Scala immutable 由于各种原因val不会被转换为Java final.这是否意味着val必须保护从其他线程访问来保护同步以保证可见性？

上下文

如果我们有

data Foo = Foo { x :: Maybe Int, y :: Maybe Text }

我们已经可以在Applicative上下文(这里是IO)中将它构建为applicative-style

myfoo :: IO Foo
myfoo = Foo <$> getEnvInt "someX" <*> getEnvText "someY"

问题

如果一个人喜欢明确地写出记录字段名称,那该怎么办？如:

myfoo = Foo { x = getEnvInt "someX", y = getEnvText "someY" }

这不会发生变形.一个解决方案是

{-# LANGUAGE RecordWildCards #-}
myfoo = do
    x <- getEnvInt "someX"
    y <- getEnvText "someY"
    return $ Foo {..}

哪个不错.但我想知道(此时只为了它自己)以下是否可行:

data FooC f = FooC { x :: f Int, y :: f Text …

由于大多数人不得不在他们的办公室从Office 2003更改到2007年,所以如果客观上有理由放弃以前办公室的良好旧界面,那我就很烦恼.

当人们询问变化的理由时,获得一些支持事实也是很好的.例如,我会对以下内容感兴趣:

• 是否有研究表明没有任何Office先前知识的新用户可以更有效地适应或使用新界面？
• 从设计者的角度来看,新UI的优点是什么(哪种功能比以前更容易获取;哪些重要信息更明显？等等)

使用私有方法通过将一些决策点重构为单独的方法来减少CC会降低实际方法的CC并简化读取,但不会减少在测试中获得完整分支覆盖的工作量.

这是否合理？你有什么实地经验？

在以下代码中

val x = 5
val y = 4 match {
  case x => true
  case _ => false
}

价值y是真的.Scala解释x为模式匹配中的自由变量,而不是将其绑定到范围中具有相同名称的变量.

如何解决这个问题呢？

以下是手动过程

case class A(x: Int) { def f(y: Int) = x * y }
val af: (A => Int => Int) = _.f

val a = A(4)
val r = af(a)(2)

是否有一种方便的方式来获得功能af？有点像A magic f,可能没有使用反射.能够导入课程的所有公共方法import A#magic._是一种奖励.

在Scala中,我可以:

trait Api {
    def someApiCall: Either[Failure, GoodResult];
}

要么

object SomeObject {
    type SomeResult = Either[Failure, GoodResult]
}

trait Api {
    def someApiCall: SomeObject.SomeResult;
}

前者对结果类型更明确,因此更容易阅读,但涉及在不同的实现中反复重新输入.这在后者中得到了解决,但是读者不能对第一眼的结果做出很多结论.

如果返回类型Option不是Either,我自然会坚持使用前一版本.对于具有许多类型参数的更复杂类型,第二类更有益.Either是中场的某个地方.

我的直觉是,从长远来看,后者更易于维护.你怎么看？对此有实践吗？