lazy-evaluation

I have a problem on Scala. I serialize an instance of class with @transient lazy val field. And then I deserialize it, the field is assigned null . I expect the lazy evaluation after deserialization. What should I do? Following is a sample code. object Test { def main(args: Array[String]){ //---------------- // ClassA - with @transient //---------------- val objA1 = ClassA("world"); println(objA1); // This works as expected as follows: // "Good morning." // "Hello, world" saveObject("testA.dat", objA1); val objA2 = loadObject("testA.dat").asInstanceOf[ClassA]; println(objA2); // I expect this

"R passes promises , not values. The promise is forced when it is first evaluated, not when it is passed.", see this answer by G. Grothendieck. Also see this question referring to Hadley's book. In simple examples such as > funs <- lapply(1:10, function(i) function() print(i)) > funs[[1]]() [1] 10 > funs[[2]]() [1] 10 it is possible to take such unintuitive behaviour into account. However, I find myself frequently falling into this trap during daily development. I follow a rather functional programming style, which means that I often have a function A returning a function B, where B is in some

I have a constant declaration in Haskell -- can I force this to be evaluated ahead of time? I'm seeing some code that looks roughly like, myList = [(a, b), (c, d)] ... map (f . fst) myList take time in the fst call when I profile it (it does have 168M calls). The binary representation of myList is quite small, and could be, for example, copied into global memory [if this were a C program]. I'm compiling with -O3 -optc-O3 of course. Thanks very much! Generating Lift instances for a custom type Any expression given to the lift call in sclv's answer must be an instance of Lift. There's a library

Is it possible to implement (*) with least-strict semantics in Haskell (standardized Haskell preferred, but extensions are OK. Using compiler internals is cheating)? For example, such a definition should result in the following being true: 0 * ⊥ = 0 ⊥ * 0 = 0 and only: ⊥ * ⊥ = ⊥ I can build pattern matches that satisfy one of the above cases, but not both, because the zero check forces the value. Philip JF Yes, but only using constrained impurity. laziestMult :: Num a => a -> a -> a laziestMult a b = (a * b) `unamb` (b * a) here unamb is Conal Elliott's "pure" variant of amb . Operationally,

Does anyone know of a truly declarative language? The behaviour I'm looking for is kind of what Excel does, where I can define variables and formulas, and have the formula's result change when the input changes (without having set the answer again myself) The behaviour I'm looking for is best shown with this pseudo code: X = 10 // define and assign two variables Y = 20; Z = X + Y // declare a formula that uses these two variables X = 50 // change one of the input variables ?Z // asking for Z should now give 70 (50 + 20) I've tried this in a lot of languages like F#, python, matlab etc, but

What do the thunks for the following value/expression/function look like in the Haskell heap? val = 5 -- is `val` a pointer to a box containing 5? add x y = x + y result = add 2 val main = print $ result Would be nice to have a picture of how these are represented in Haskell, given its lazy evaluation mode. Official answer It's none of your business. Strictly implementation detail of your compiler. Short answer Yes. Longer answer To the Haskell program itself, the answer is always yes, but the compiler can and will do things differently if it finds out that it can get away with it, for

I've been learning scala and I gotta say that it's a really cool language. I especially like its pattern matching capabilities and function literals but I come from a javascript, ruby background and one of my favorite patterns in those languages is the lazy function and method definition pattern. An example in javascript is var foo = function() { var t = new Date(); foo = function() { return t; }; return foo(); }; The same code with minor tweaks works in ruby where you just use the singleton object to redefine the method after the computation is performed. This kind of thing comes in really