标签: lazy-evaluation

我试图一次读一行大文件.我在Quora上发现了一个关于这个问题的问题,但是我错过了一些联系,以使整个事情融合在一起.

 var Lazy=require("lazy");
 new Lazy(process.stdin)
     .lines
     .forEach(
          function(line) { 
              console.log(line.toString()); 
          }
 );
 process.stdin.resume();

我想弄清楚的是我如何从文件而不是STDIN一次读取一行,如本示例所示.

我试过了:

 fs.open('./VeryBigFile.csv', 'r', '0666', Process);

 function Process(err, fd) {
    if (err) throw err;
    // DO lazy read 
 }

但它不起作用.我知道,在一个紧要关头,我可以回到使用像PHP这样的东西,但我想弄清楚这一点.

我认为其他答案不会起作用,因为文件比我正在运行它的服务器大得多.

我发现这篇文章是关于Lazy:C#4.0中的懒惰 - 懒惰

使用Lazy对象获得最佳性能的最佳实践是什么？有人能指出我在实际应用中的实际用途吗？换句话说,我什么时候应该使用它？

当我尝试使用真实项目来驱动Haskell时,我遇到了以下定义.我不明白每个论点前面的感叹号是什么意思,我的书似乎没有提到它.

data MidiMessage = MidiMessage !Int !MidiMessage

我注意到Scala提供了lazy vals.但我不知道他们做了什么.

scala> val x = 15
x: Int = 15

scala> lazy val y = 13
y: Int = <lazy>

scala> x
res0: Int = 15

scala> y
res1: Int = 13

该REPL表明y是一个lazy val,但它是如何从一个正常的不同val？

Scala的一个便利功能是lazy val,a的评估val被延迟到必要时(首次访问时).

当然,lazy val必须有一些开销 - 在某处Scala必须跟踪该值是否已经被评估并且评估必须同步,因为多个线程可能会尝试同时第一次访问该值.

a的成本到底是什么？lazy val是否有一个隐藏的布尔标志与a关联,lazy val如果它已经被评估,是什么同步,是否有更多的成本？

另外,假设我这样做:

class Something {
    lazy val (x, y) = { ... }
}

这是否与两个单独的lazy vals 相同x,y或者我只获得一次开销,对于该对(x, y)？

是否有更简洁的方法将dplyr tbl的一列作为向量,从具有数据库后端的tbl(即数据帧/表不能直接是子集)？

require(dplyr)
db <- src_sqlite(tempfile(), create = TRUE)
iris2 <- copy_to(db, iris)
iris2$Species
# NULL

这太容易了,所以

collect(select(iris2, Species))[, 1]
# [1] "setosa"     "setosa"     "setosa"     "setosa"  etc.

但它似乎有点笨拙.

当我在调查Javascript代码中的词法闭包问题时,我在Python中遇到了这个问题:

flist = []

for i in xrange(3):
    def func(x): return x * i
    flist.append(func)

for f in flist:
    print f(2)

请注意,此示例谨慎避免lambda.它打印"4 4 4",这是令人惊讶的.我期待"0 2 4".

这个等效的Perl代码是正确的:

my @flist = ();

foreach my $i (0 .. 2)
{
    push(@flist, sub {$i * $_[0]});
}

foreach my $f (@flist)
{
    print $f->(2), "\n";
}

打印"0 2 4".

你能解释一下这个区别吗？

更新:

这个问题是不是与i是全球性的.这显示相同的行为:

flist = []

def outer():
    for i in xrange(3):
        def inner(x): return x * i …

在带有lambda b93的JDK 8中,b93中有一个类java.util.stream.Streams.zip可用于压缩流(这在教程Exploring Java8 Lambdas中说明.Dhananjay Nene的第1部分).这个功能:

创建一个惰性和顺序组合Stream,其元素是组合两个流的元素的结果.

然而在b98中,这已经消失了.事实上,在b98Streams中的java.util.stream中甚至无法访问该类.

是否已移动此功能,如果是这样,我如何使用b98简洁地压缩流？

我想到的应用程序是在Shen的这个java实现中,我在其中替换了zip中的zip功能

• static <T> boolean every(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)
• static <T> T find(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)

具有相当冗长代码的函数(不使用b98中的功能).

此问题中 myAny函数的代码使用foldr.当谓词满足时,它会停止处理无限列表.

我用foldl重写了它:

myAny :: (a -> Bool) -> [a] -> Bool
myAny p list = foldl step False list
   where
      step acc item = p item || acc

(请注意,步骤函数的参数已正确反转.)

但是,它不再停止处理无限列表.

我试图在Apocalisp的答案中跟踪函数的执行情况:

myAny even [1..]
foldl step False [1..]
step (foldl step False [2..]) 1
even 1 || (foldl step False [2..])
False  || (foldl step False [2..])
foldl step False [2..]
step (foldl step False [3..]) 2
even 2 || (foldl step False [3..])
True   || (foldl …

我一直想知道懒惰评估为何有用.我还没有任何人以有道理的方式向我解释; 最重要的是它最终沸腾到"相信我".

注意:我不是指记忆.