lazy-evaluation

In Haskell, you can build infinite lists due to laziness: Prelude> let g = 4 : g Prelude> g !! 0 4 Prelude> take 10 g [4,4,4,4,4,4,4,4,4,4] Now, what exactly goes on when I try to construct a list like this? Prelude> let f = f !! 10 : f Prelude> f !! 0 Interrupted. Prelude> take 10 f [Interrupted. Prelude> The Interrupted. s are me hitting CTRL+C after waiting a few seconds. It seems to go into an infinite loop, but why is that the case? Explanation for non-Haskellers: The : operator is prepend : Prelude> 4 : [1, 2, 3] [4,1,2,3] This line: Prelude> let g = 4 : g says "let g be the list

I would like to know what is the python way of initializing a class member but only when accessing it, if accessed. I tried the code below and it is working but is there something simpler than that? class MyClass(object): _MY_DATA = None @staticmethod def _retrieve_my_data(): my_data = ... # costly database call return my_data @classmethod def get_my_data(cls): if cls._MY_DATA is None: cls._MY_DATA = MyClass._retrieve_my_data() return cls._MY_DATA You could use a @property on the metaclass instead: class MyMetaClass(type): @property def my_data(cls): if getattr(cls, '_MY_DATA', None) is None:

How can I lazy evaluate second arg in std::conditional? #include "stdafx.h" #include <type_traits> struct Null{}; struct _1{enum {one = true,two = false};}; struct _2{enum {two = true, one = false};}; template<class T> struct is_nulltype { enum {value = false}; }; template<> struct is_nulltype<Null> { enum {value = true}; }; template<class T> struct X : std::conditional<is_nulltype<T>::value,Null,typename std::conditional<T::one,_1,_2>::type>::type { }; int _tmain(int argc, _TCHAR* argv[]) { X<Null> x;//won't compile no Null::one but I don't need that member in Null at all return 0; } The

A lot of times, I have a big dataframe df to hold the basic data, and need to create many more columns to hold the derivative data calculated by basic data columns. I can do that in Pandas like: df['derivative_col1'] = df['basic_col1'] + df['basic_col2'] df['derivative_col2'] = df['basic_col1'] * df['basic_col2'] .... df['derivative_coln'] = func(list_of_basic_cols) etc. Pandas will calculate and allocate the memory for all derivative columns all at once. What I want now is to have a lazy evaluation mechanism to postpone the calculation and memory allocation of derivative columns to the actual

MVar, TVar, IORef, ... I can't speedup a thunk problem (I think). (My original problem is a threaded code, I do "forkIO" n-times calling "addMany"; but I think my problem is on "shW" function) Let next code: {-# LANGUAGE BangPatterns #-} import Control.Concurrent import Control.Monad import System.Environment(getArgs) import Data.Int import Data.IORef -- "i" times, add "n" for each IORef (in "a") addMany :: [IORef Int64] -> Int64 -> Int64 -> IO () addMany !a !n !i = forM_ [1..i] (\_ -> forM_ a (shW n)) -- MVar, TVar, IORef, ... read/write (x' = x + k) shR = readIORef shW !k !r =

I'm trying to understand clojure's lazy-seq operator, and the concept of lazy evaluation in general. I know the basic idea behind the concept: Evaluation of an expression is delayed until the value is needed. In general, this is achievable in two ways: at compile time using macros or special forms; at runtime using lambda functions With lazy evaluation techniques, it is possible to construct infinite data structures that are evaluated as consumed. These infinite sequences utilizes lambdas, closures and recursion. In clojure, these infinite data structures are generated using lazy-seq and cons

As part of a bigger problem of enumerating a set, I need to write an OCaml function 'choose' which takes a list and outputs as the list of all possible sequences of size k made up of elements of that list (without repeating sequences which can be obtained from each other by permutation). The order they are put in the end list is not relevant. For example, choose 2 [1;2;3;4] = [[1;2];[1;3];[1;4];[2;3];[2;4];[3;4]] Any ideas? I would like to have the whole thing to be lazy, outputting a lazy list, but if you have a strict solution, that'll be very useful too. Here is a strict and suboptimal

From Wikipedia: Lazy evaluation is: In programming language theory, lazy evaluation or call-by-need is an evaluation strategy which delays the evaluation of an expression until its value is needed Short-circuit evaluation is: Short-circuit evaluation, minimal evaluation, or McCarthy evaluation denotes the semantics of some Boolean operators in some programming languages in which the second argument is only executed or evaluated if the first argument does not suffice to determine the value of the expression So what's the difference between them for example when I have: if(false && true && true)