lazy-evaluation

Running the following program will print "space overflow: current size 8388608 bytes." I have read this and this , but still don't know how to resolve my problem. I am using foldr, shouldn't it be guaranteed to be "tail recursive"? I feel great about Haskell so far until I know I should prevent "space overflow" when using the powerful recursion. :) module Main where import Data.List value a b = let l = length $ takeWhile (isPrime) $ map (\n->n^2 + a * n + b) [0..] in (l, a ,b) euler27 = let tuple_list = [value a b | a <-[-999..999] , b <- [-999..999]] in foldr (\(n,a,b) (max,v) -> if n > max

I have a class with a few properties that are dependent, but that I'd really like to calculate only once. I've just about concluded that using lazy evaluation on a dependent class property in MATLAB is either impossible or a bad idea. The original plan was to have a private logical flag for each (public) property that needs updating and to have the constructor set it to true. Then when the property accessor was called, it would check that flag and calculate the value and store it (in another private property) only if required. If the flag were false, it would simply return a copy of the cached

I'm working on a homework assignment where we are asked to implement an evaluation strategy called "call by name" in a certain language that we developed (using Scheme). We were given an example in Scala , but I don't understand how "call by name" works and how it is different to "call by need"? Call-by-need is a memoized version of call-by-name (see wikipedia ). In call-by-name, the argument is evaluated every time it is used , whereas in call-by-need, it is evaluated the first time it is used, and the value recorded so that subsequently it need not be re-evaluated. Call by name is a a

I've been using Data.Binary to serialize data to files. In my application I incrementally add items to these files. The two most popular serialization packages, binary and cereal, both serialize lists as a count followed by the list items. Because of this, I can't append to my serialized files. I currently read in the whole file, deserialize the list, append to the list, re-serialize the list, and write it back out to the file. However, my data set is getting large and I'm starting to run out of memory. I could probably go around unboxing my data structures to gain some space, but that

I can't wrap my head around the differences between sequence and LazyList . They're both lazy and potentially infinite. While seq<'T> is IEnumerable<'T> from .NET framework, LazyList is included in F# PowerPack . In practice, I encounter sequences much more often than LazyList s. What are their differences in terms of performance, usage, readability, etc? What are reasons for such a bad reputation of LazyList compared to that of seq ? Daniel LazyList computes each element only once regardless of how many times the list is traversed. In this way, it's closer to a sequence returned from Seq

One of my struggles with lazy evaluation in Haskell is the difficulty of reasoning about memory usage. I think the ability to duplicate a thunk would make this much easier for me. Here's an example. Let's create a really big list: let xs = [1..10000000] Now, let's create a bad function: bad = do print $ foldl1' (+) xs print $ length xs With no optimizations, this eats up a few dozen MB of ram. The garbage collector can't deallocate xs during the fold because it will be needed for calculating the length later. Is it possible to reimplement this function something like this: good = do (xs1,xs2)

public class myClass { public myClass(String InstanceName) { Name = InstanceName; } public String Name { get; set; } } // Now using myClass lazily I have: Lazy<myClass> myLazy; Console.WriteLine(myLazy.Value.Name); My question is how to pass InstanceName to myClass constructor when we are using a lazy instance ? Try this: Lazy<myClass> myLazy = new Lazy<myClass>(() => new myClass(InstanceName)); Remember that the expression is evaluated lazily, so if you change the value of the variable InstanceName before the constructor is called it might not do what you expect. Lazy has two ways to