lazy-evaluation

Oracle defines several structures that make use of what looks like lazy evaluation but what's actually short-circuiting. For example: x := case when 1 = 2 then count_all_prime_numbers_below(100000000) else 2*2 end; The function count_all(...) will never be called. However, what I'm more interested in is the syntax that looks like regular function call: x := coalesce(null, 42, hundreth_digit_of_pi()); Hundreth_digit_of_pi() will not be called since coalesce is not a regular function, but a syntax sugar that looks like one - for regular ones parameters get evaluated when the function is called.

Do you know how to perform a lazy evaluation of string, like in this D snippet: void log(lazy string msg) { static if (fooBarCondition) writefln(…) /* something with msg */ } Actually, the problem might not need laziness at all since the static if. Maybe it’s possible to discard char const* strings when not used? Like, in C++: void log(char const *msg) { #ifdef DEBUG cout << … << endl; /* something with msg */ #else /* nothing at all */ #endif } Any idea? Thank you. #ifdef DEBUG #define log(msg) do { cout << … << endl; } while(0) #else #define log(msg) do { } while(0) #endif There are two ways

I wondered: What happens when you embed an expression that forces realization of a lazy sequence inside of an outer lazy sequence that's not realized? Answer: It seems to depend on how you create the outer lazy sequence. If the outer sequence comes from map , the inner sequence is realized, and if the outer sequence comes for iterate , it's not. Well, I'm pretty sure that that is not the right way to describe what happens below--I'm pretty sure that I'm not understanding something. Can someone explain? (There is one quirk, which is that while map returns a LazySeq , iterate returns a Cons

I'm still trying to understand lazy evaluation in R. Here's something that confuses me: f=function(x) as.character(substitute(x)) g=function(...) f(...) h=function(z) f(z) f(y) # [1] "y" g(y) # [1] "y" h(y) # [1] "z" Why do g and h not behave the same way? The Lazy Evaluation aspect of R is that it does not evaluate an object until it is needed. However, what you are seeing has little to do with lazy evaluation. Rather it is related to the ellipsis argument: When calling g(y) , f is substituting the value of x with the ellipsis. But substitute(...) essentially substitutes in the value sent to

I writed a Haskell module to list all the contents of a directory by breadth-first order. The below is the source code. module DirElements (dirElem) where import System.Directory (getDirectoryContents, doesDirectoryExist) import System.FilePath ((</>)) dirElem :: FilePath -> IO [[FilePath]] dirElem dirPath = iterateM (not.null) (concatMapM getDirectoryContents') [dirPath] >>= return.tail getDirectoryContents' :: FilePath -> IO [FilePath] getDirectoryContents' dirPath = do isDir <- do doesDirectoryExist dirPath if isDir then dirContent else return [] where dirContent = do contents <-

I'm writing a Clojure implementation of this coding challenge , attempting to find the average length of sequence records in Fasta format: >1 GATCGA GTC >2 GCA >3 AAAAA For more background see this related StackOverflow post about an Erlang solution. My beginner Clojure attempt uses lazy-seq to attempt to read in the file one record at a time so it will scale to large files. However it is fairly memory hungry and slow, so I suspect that it's not implemented optimally. Here is a solution using the BioJava library to abstract out the parsing of the records: (import '(org.biojava.bio.seq.io