Ruby’s yield keyword is something very different from the Python keyword with the same name, so don’t be confused by it. Ruby’s yield keyword is syntactic sugar for calling a block associated with a method. The closest equivalent is Ruby’s Enumerator class. For example, the equivalent of the Python: def eternal_sequence(): i = 0 while … Read more
You’re right, from a modern POV this doesn’t really make sense. What is true is that lazy-by-default would make reasoning about side-effectful code a nightmare, so lazyness does require purity – but not the other way around. What does require lazyness though is the way Haskell in versions 1.0–1.2, following its predecessor Miranda, emulated IO … Read more
This appears to have been improved. The following works in Django 1.3: return json_response({ ‘success’: False, ‘errors’: dict(form.errors.items()), }) No need for __unicode__ or lazy translation any more. This also gives a full array of errors for each field.
You can implement own delegate like this: class InitOnceProperty<T> : ReadWriteProperty<Any, T> { private object EMPTY private var value: Any? = EMPTY override fun getValue(thisRef: Any, property: KProperty<*>): T { if (value == EMPTY) { throw IllegalStateException(“Value isn’t initialized”) } else { return value as T } } override fun setValue(thisRef: Any, property: KProperty<*>, value: … Read more
It turned out that this error only occurred when trying to inspect the Value property of the Lazy<> in the Visual Studio debugger. Doing so appeared to create a deadlock because the accessing of Value then seemed to hang the thread for a long time until the InvalidOperationException finally occurred. I could never intercept the … Read more
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 performance reasons. For example, for ”’add … Read more
From the blog post @Lambdageek linked, the GHC Commentary and the GHC User’s Guide I piece together the following: GHC tries to prevent reevaluating thunks, but because true locking between threads is expensive, and thunks are usually pure and so harmless to reevaluate, it normally does so in a sloppy manner, with a small chance … Read more
Lazy evaluation makes macros redundant This is pure nonsense (not your fault; I’ve heard it before). It’s true that you can use macros to change the order, context, etc. of expression evaluation, but that’s the most basic use of macros, and it’s really not convenient to simulate a lazy language using ad-hoc macros instead of … Read more
lazy changes the way the array is processed. When lazy is not used, filter processes the entire array and stores the results into a new array. When lazy is used, the values in the sequence or collection are produced on demand from the downstream functions. The values are not stored in an array; they are … Read more
You escape a curly brace with a curly brace, i.e. {{ produces {, and }} produces }. The {0} in the middle is interpreted as usual – i.e. a reference to parameter at index zero. {{ {0} }} ^^ ^^^ ^^ | | | | | +— Closing curly brace | +—— Parameter reference +———- … Read more