我们的收藏有大约 1 亿份文件。我们使用 nodejs 和 expressjs 创建了一个简单的应用程序，在 mongo 查询中带有一个限制子句。对目前的用户来说已经足够了。与此同时，我们正在尝试实现延迟加载，以便初始页面加载返回很少的文档，而当用户滚动时，我们希望加载更多文档。苦苦挣扎从哪里开始以及如何实现它。感谢您的建议。我的 index.js 文件看起来像这样
router.get('/users', function(req, res) {
var db = req.db;
var users = db.get('users');
users.find(query, {limit: 10000}, function(e, docs){
res.render('users', {
title: 'Users',
'users': docs
});
});
});
我想取消限制并使用跳过来实现这一点。请发表您的建议
我的理解(可能是不正确的或不完整的)是懒惰的评估可以提供尾递归的所有优点,并且做得更好.
如果是这样,是否意味着在惰性求值的上下文中不需要尾递归？
UPDATE
具体来说,让我们看一下以下示例:
(define (foo f a)
(if (number? a)
(* a a)
(lazy-map foo a)))
该函数可以很容易地转换为尾递归函数.但是,如果是这样,我们将失去懒惰评估的优势.
实际上,当输入是一个非常大的列表(或无限)时,这个非尾递归函数是否需要消耗很多堆栈？我不这么认为.那么,是否有充分的理由使用尾递归而不是懒惰的评估？
scheme haskell functional-programming clojure lazy-evaluation
假设我有一个所有素数的列表,定义为
primes :: (Enum ?, Integral ?) => [?]
primes = sieve [2..]
where sieve :: (Integral ?) => [?] -> [?]
sieve [] = undefined
sieve (x:xs) = x : (sieve $ filter ((/= 0) . (flip mod x)) xs)
我想primes通过多种不同的功能提供信息,例如:
sumOfPrimesLessThan :: (Integral ?) => ? -> ?
sumOfPrimesLessThan n = sum $ takeWhile (< n) primes
要么
productOfPrimesLessThan :: (Integral ?) => ? -> ?
productOfPrimesLessThan n = foldl (*) 1 $ takeWhile (< n) …当repl变量设置为false时,为什么以下函数返回不正确长度的序列？
open MathNet.Numerics.Distributions
open MathNet.Numerics.LinearAlgebra
let sample (data : seq<float>) (size : int) (repl : bool) =
let n = data |> Seq.length
// without replacement
let rec generateIndex idx =
let m = size - Seq.length(idx)
match m > 0 with
| true ->
let newIdx = DiscreteUniform.Samples(0, n-1) |> Seq.take m
let idx = (Seq.append idx newIdx) |> Seq.distinct
generateIndex idx
| false ->
idx
let sample =
match repl with
| true ->
DiscreteUniform.Samples(0, n-1)
|> Seq.take …这听起来像是一个新手错误，但我做了很多。在将惰性求值块或值传递给函数时，如果我忘记以某种方式使该函数的相应参数变为惰性（按名称传递/调用），乍一看会引起一些混乱，因为它强制求值。
lazy val a = {println("a");1}
def myfunc(b:Int){println("hello")}
myfunc(a);
输出：
a
Hello
所以我的问题是，这个问题是否有任何编译器帮助？（标志等）或者这是我应该处理的事情？
特定
auto cstr = "quick brown fox";
我们有一组适配器只是为了分割单词然后尝试将它们显示为格式化范围.
auto adaptors = ranges::view::split(' ') | ranges::view::all;
如果source是string_view,那就是okey.
auto sv = std::string_view{cstr};
ranges::copy(sv | adaptors, ranges::ostream_iterator(std::cout,";") );
输出:[wandbox]
[q,u,i,c,k];[b,r,o,w,n];[f,o,x];
然后尝试使用view :: c_str
auto cstr_rng = ranges::view::c_str(cstr);
// Won't compile
// ranges::copy(cstr_rng | adaptors, ranges::ostream_iterator(std::cout,";") );
错误:[CE]
/opt/compiler-explorer/libs/rangesv3/trunk/include/range/v3/view/split.hpp: In instantiation of 'ranges::v3::split_view<Rng, Fun>::cursor<IsConst>::cursor(ranges::v3::split_view<Rng, Fun>::cursor<IsConst>::fun_ref_t, ranges::v3::iterator_t<Rng>, ranges::v3::sentinel_t<Rng>) [with bool IsConst = true; Rng = ranges::v3::delimit_view<ranges::v3::iterator_range<const char*, ranges::v3::unreachable>, char>; Fun = ranges::v3::view::split_fn::element_pred<ranges::v3::delimit_view<ranges::v3::iterator_range<const char*, ranges::v3::unreachable>, char>&>; ranges::v3::split_view<Rng, Fun>::cursor<IsConst>::fun_ref_t = ranges::v3::view::split_fn::element_pred<ranges::v3::delimit_view<ranges::v3::iterator_range<const char*, ranges::v3::unreachable>, char>&>; ranges::v3::iterator_t<Rng> …在尝试扩展Lazy.jl 中的一个示例时，我遇到了评估不是惰性的问题。
在README使用这个例子：
> esquares = @>> Lazy.range() map(x->x^2) filter(iseven);
> esquares[99]
39204
我试图通过允许将过滤器指定为参数来使其动态化，但它最终评估了一个无限列表：
> squares(filt) = @lazy @>> Lazy.range() map(x->x^2) filter(filt);
> squares(iseven)
(4 16 36 64 100 144 196 256 324 400 484 576 676 ... # this keeps printing until interrupting...)
我也试过：
> @lazy squares(iseven)
(4 16 36 64 100 144 196 256 324 400 484 576 676 ... # this also immediately returns the infinite list
听说 Haskell 评估晚了。但是，无论我尝试做什么，它似乎都以与任何其他编程语言相同的方式对其进行评估；
考虑以下代码：
test :: Bool -> IO()
test n = do
let y = 5
print n
main = do
let y = 8
test (y == 8)
此代码输出：
True
考虑如下函数：
unsigned int fact(unsigned int i) {
if (i <= 1) { return 1; }
return i * fact(i-1);
}
如果我要实例化一个新变量unsigned int f，那么f = 0 * fact(5)为什么它不会“短路”？
unsigned int fact(unsigned int i) {
std::cout << "a";
if (i <= 1) { return 1; }
return i * fact(i-1);
}
int main() {
unsigned int f = 0 * fact(5);
}
这里的输出是aaaaa。如果f只能为零，为什么它会调用该函数，假设它知道返回类型？它不评估从左到右，看到0 * (unsigned int)并知道右值将是0？
我正在寻找一种方法来使用文本文件生成尽可能多的文本，只需根据需要重复几次即可。
在像 Haskell 这样的纯函数式语言中，解决方案似乎微不足道：这里我已经发布了用于审查的代码，它很短，尽管我很确定它可以改进。
但是在 C++ 中，我几乎不知道从哪里开始，除了我很确定 Boost Hana 提供了许多我设计解决方案所需的工具。
这是一个示例输入文件，
line 1
line 2
line 3
并且，如果我要求 7 行，这就是我想放入一个变量中的内容（例如在一个std::string带有嵌入式'\n's的单个中），
line 1
line 2
line 3
line 1
line 2
line 3
line 1
我猜这个函数可以有这样的声明：
std::string function(std::string s, int n);