lazy-evaluation

How can I watch variable values inside of javascript eval() method? And is it possible to "step into" and "step over" in eval method? For example, with a code like this: eval("if (true) { var a = 10; a += 20; alert(a); }"); I am more interested in debugging in IE9, but I would like to hear general principle as well. you can't inside the eval method. the code you give it is no code but a string. after the eval() then it becomes code and you can inspect it. This also depends on what tools you use to debug your script. In Chrome if you click Pause on exception, and execute your eval. it will

I'm trying to sort an array with a map() over an iterator. struct A { b: Vec<B>, } #[derive(PartialEq, Eq, PartialOrd, Ord)] struct B { c: Vec<i32>, } fn main() { let mut a = A { b: Vec::new() }; let b = B { c: vec![5, 2, 3] }; a.b.push(b); a.b.iter_mut().map(|b| b.c.sort()); } Gives the warning: warning: unused `std::iter::Map` that must be used --> src/main.rs:16:5 | 16 | a.b.iter_mut().map(|b| b.c.sort()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[warn(unused_must_use)] on by default = note: iterators are lazy and do nothing unless consumed Which is true, sort() isn't actually

As you might know random.sample(population,sample_size) quickly returns a random sample, but what if you don't know in advance the size of the sample? You end up in sampling the entire population, or shuffling it, which is the same. But this can be wasteful (if the majority of sample sizes come up to be small compared to population size) or even unfeasible (if population size is huge, running out of memory). Also, what if your code needs to jump from here to there before picking the next element of the sample? P.S. I bumped into the need of optimizing random sample while working on simulated

If class is not a final one, it may be extended. There are two possibilities for values: it may be overridden and should be lazy for it, it may not be overridden and should be final. If val is final - you may assume that all computations over it would work through class hierarchy. If val may be overriden you should declare it lazy for not becoming broken after extending. You may leave val plain and this gives no guaranties it would be extended in right way. What use cases imply using plain values? Example of class initialization failure without lazy values abstract class A { lazy val x1 :

In SQL databases (I use Python+Sqlite), how to make sure that, if we have 1 million rows, the query SELECT * FROM mytable WHERE myfunction(description) < 500 AND column2 < 1000 [-----------------------------] [--------------] high-CPU cost condition easy-to-test requiring 100 µs per test condition is optimized so that the 1st condition (CPU-expensive) is only tested if the easy-to-test second condition is already True? (since it's a logical AND , is it a lazy AND ?) Example: if the 1st condition is always tested, it would require 1 million x 100 µs = 100 seconds! if the 2nd condition is tested