lazy-evaluation

In Haskell, lifted type products mean that there's a semantic difference between (a,b,c) and (a, (b, c)). If all pattern matches of all products was always irrefutable, then there would be no difference, and (a, b, c) could be syntactic sugar for (a, (b, c)). Why did Haskell choose to lift type products? One reason is that implementing seq for an unlifted product requires parallel/interleaved computation, since seq (a, b) True would be supposed to be True if and only if at least one of a and b is non-bottom. You might not find this reason terribly convincing, depending on how you feel about

The following are both meant to create a Stream of integers: val s: Stream[Int] = 1 #:: s.map(_ + 1) def makeStream = { val s: Stream[Int] = 1 #:: s.map(_ + 1) s } The first is fine; however the makeStream method won't compile: error: forward reference extends over definition of value s val s: Stream[Int] = 1 #:: s.map(_ + 1) ^ It only compiles if we make s a lazy val . Why does it need to be a lazy val in a method, but not outside? Inside a class, a val definition decompiles into an "getter" method that references a hidden class field. These "getter" methods can be self-referential (or rather

Is there a common term / catch-phrase for the opposite of lazy loading? The oposite term for lazy loading is eager loading. Eager loading is essentially computing the tasks when you ask for it. Lazy Loading is when you only do the computation when it is required. I've seen the terms "Eager Loading" and "Aggressive Initialization" both used. I'd say that the opposite of lazy is proactive loading , i.e. loading something in advance, before it's really needed. However it's hard to pick the opposites when you have 3 entities {lazy, eager, proactive} 来源： https://stackoverflow.com/questions/5427949

I have a proxy for a lazy entity which has been created in the session by loading a child entity. A subsequent fetch on the parent entity only returns the NH proxy. I need the actual instance to check the type (the entity has joined subclasses). I must be missing something, but I can't find a way to do this. Session.Refresh(proxy) does not appear to help, nor does any flavour of HQL that I've tried. Can anyone help? Erik Öjebo To force a proxy to be fetched from the database, you can use the NHibernateUtil.Initialize(proxy) method, or access a method/property of the proxy. var foo = session

I'm writing a program that reads from a list of files. The each file either contains a link to the next file or marks that it's the end of the chain. Being new to Haskell, it seemed like the idiomatic way to handle this is is a lazy list of possible files to this end, I have getFirstFile :: String -> DataFile getNextFile :: Maybe DataFile -> Maybe DataFile loadFiles :: String -> [Maybe DataFile] loadFiles = iterate getNextFile . Just . getFirstFile getFiles :: String -> [DataFile] getFiles = map fromJust . takeWhile isJust . loadFiles So far, so good. The only problem is that, since

In Python, I can do something like this: lazy = ((i,j) for i in range(0,10000) for j in range(0,10000)) sum((1 for i in lazy)) It will take a while, but the memory use is constant. The same construct in scala: (for(i<-0 to 10000; j<-i+1 to 10000) yield (i,j)).count((a:(Int,Int)) => true) After a while, I get a java.lang.OutOfMemoryError , even though it should be evaluated lazily. Nothing's inherently lazy about Scala's for-comprehension; it's syntactic sugar* which won't change the fact that the combination of your two ranges will be eager. If you work with lazy view s of your ranges, the

Still quite new to Haskell.. I want to read the contents of a file, do something with it possibly involving IO (using putStrLn for now) and then write new contents to the same file. I came up with: doit :: String -> IO () doit file = do contents <- withFile tagfile ReadMode $ \h -> hGetContents h putStrLn contents withFile tagfile WriteMode $ \h -> hPutStrLn h "new content" However this doesn't work due to laziness. The file contents are not printed. I found this post which explains it well. The solution proposed there is to include putStrLn within the withFile : doit :: String -> IO () doit