Well, there’s lazy, and then there’s lazy. mapM is indeed lazy in that it doesn’t do more work than it has to. However, look at the type signature: mapM :: (Monad m) => (a -> m b) -> [a] -> m [b] Think about what this means: You give it a function a -> m … Read more
Does this get anywhere near your requirements? The behaviour falls somewhere between ExecutionAndPublication and PublicationOnly. While the initializer is in-flight all calls to Value will be handed the same task (which is cached temporarily but could subsequently succeed or fail); if the initializer succeeds then that completed task is cached permanently; if the initializer fails … Read more
gettext() vs. gettext_lazy() In definitions like forms or models you should use gettext_lazy because the code of this definitions is only executed once (mostly on django’s startup); gettext_lazy translates the strings in a lazy fashion, which means, eg. every time you access the name of an attribute on a model the string will be newly … Read more
Haskell is a lazy language. It doesn’t evaluate results until they are “needed”. Now, just printing a value causes all of it to be “needed”. In other words, if you type an expression in GHCi, it will try to print out the result, which causes it all to be evaluated. Usually that’s what you want. … Read more
As the book you linked to says: If you are trying to execute a closure on an iterator for its side effects, use for instead. That way it works, and it’s much clearer to anyone reading the code. You should use map when you want to transform a vector to a different one.
the lazy thread-safe singleton instantion is kinda not easy to understand to every coder No, it’s actually very, very easy: public class Singleton{ private final static Singleton instance = new Singleton(); private Singleton(){ … } public static Singleton getInstance(){ return instance; } } Better yet, make it an enum: public enum Singleton{ INSTANCE; private Singleton(){ … Read more
List comprehensions (in fact, Monad comprehensions) can be desugared into do notation. do i <- [1..4] j <- [i+1..4] return (i,j) Which can be desugared as usual: [1..4] >>= \i -> [i+1..4] >>= \j -> return (i,j) It is well known that a >>= \x -> return b is the same as fmap (\x -> … Read more
I’ll give a bit of an explanation of how it works internally. First, you must realise that Haskell uses a thing called a thunk for its values. A thunk is basically a value that has not yet been computed yet — think of it as a function of 0 arguments. Whenever Haskell wants to, it … Read more
Let’s do this. • I know that lazy sequences only evaluate the items in the sequence that are asked for, how does it do this? Lazy sequences (henceforth LS, because I am a LP, or Lazy Person) are composed of parts. The head, or the part(s, as really 32 elements are evaluated at a time, … Read more