lazy-evaluation

The model of my project is database first, and uses remote access to database on another server. I need to use raw SQL query because my query is very complex and I feel more comfortable in SQl not LINQ. This is how I do: string query = "select * from Inquiry_TBL where ..."; using (educationEntities db = new educationEntities()) { var list = db.Database.SqlQuery<Inquiry_TBL>(query); ViewData["total"] = list.Count(); } The problem is sometimes I get the query result within a second, sometimes it just keep loading for a long time and gives me an error that 'Calling 'Read' when the data reader is

So I was working on a way to lazily generate primes, and I came up with these three definitions, which all work in an equivalent way - just checking whether each new integer has a factor among all the preceding primes: primes1 :: [Integer] primes1 = mkPrimes id [2..] where mkPrimes f (x:xs) = if f (const True) x then let g h y = y `mod` x > 0 && h y in x : mkPrimes (f . g) xs else mkPrimes f xs primes2 :: [Integer] primes2 = mkPrimes id (const True) [2..] where mkPrimes f f_ (x:xs) = if f_ x then let g h y = y `mod` x > 0 && h y in x : mkPrimes (f . g) ( f $ g $ const True) xs else mkPrimes f

How can lazy evaluation be achieved in Python? A couple of simple examples: >>> def foo(x): ... print(x) ... return x ... >>> random.choice((foo('spam'), foo('eggs'))) spam eggs 'eggs' Above, we didn't really need to evaluate all the items of this tuple, in order to choose one. And below, the default foo() didn't really need to be computed unless the lookup key was actually missing from the dict: >>> d = {1: "one"} >>> d.get(2, foo("default")) default 'default' >>> d.get(1, foo("default")) default 'one' I'm looking for a Pythonic way to refactor examples like the above to evaluate lazily. The

Because Prolog uses chronological backtracking(from the Prolog Wikipedia page) even after an answer is found(in this example where there can only be one solution), would this justify Prolog as using eager evaluation? mother_child(trude, sally). father_child(tom, sally). father_child(tom, erica). father_child(mike, tom). sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y). parent_child(X, Y) :- father_child(X, Y). parent_child(X, Y) :- mother_child(X, Y). With the following output: ?- sibling(sally, erica). true ; false. To summarize the discussion with @WillNess below, yes, Prolog is

Scala does not permit to create laze vars, only lazy vals. It make sense. But I've bumped on use case, where I'd like to have similar capability. I need a lazy variable holder. It may be assigned a value that should be calculated by time-consuming algorithm. But it may be later reassigned to another value and I'd like not to call first value calculation at all. Example assuming there is some magic var definition lazy var value : Int = _ val calc1 : () => Int = ... // some calculation val calc2 : () => Int = ... // other calculation value = calc1 value = calc2 val result : Int = value + 1 This