lazy-evaluation

If I define λ> data Bar = Bar Int deriving Show λ> data Foo = Foo Bar deriving Show and λ> let foo = trace "foo" Foo (trace "bar" Bar 100) λ> let two = trace "two" 2 λ> let g (Foo x) y = y then I think I understand why I get λ> g foo two foo two 2 But if I then repeat this, I get λ> g foo two two 2 and I don't understand why foo appears not to have been evaluated for the second invocation of g , especially since it is clearly not (yet) somehow already available, as I can verify with λ> foo Foo bar (Bar 100) though — again, to my confusion — repeating the previous gives λ> foo Foo (Bar 100) Why

Is the lazy attribute in Swift equivalent to overriding the getter with a lazy loading pattern in Objective C? Oscar Swanros From the docs: A lazy stored property is a property whose initial value is not calculated until the first time it is used. You indicate a lazy stored property by writing the lazy attribute before its declaration. So, mostly, yes. You must always declare a lazy property as a variable (with the var keyword), because its initial value may not be retrieved until after instance initialization completes. Constant properties must always have a value before initialization

Is it possible to do this sort of thing in Scala? def quicksort[A](xs: Stream[A])(implicit o: Ordering[A]): Stream[A] = { import o._ if (xs.isEmpty) xs else { val (smaller, bigger) = xs.tail.partition(_ < xs.head) quicksort(smaller) #::: xs.head #:: quicksort(bigger) } } It can be done with views as well, though it's bound to be much slower: def quicksort[A](xs: List[A])(implicit o: Ordering[A]) = { import o._ def qs(xs: SeqView[A, List[A]]): SeqView[A, Seq[_]] = if (xs.isEmpty) xs else { val (smaller, bigger) = xs.tail.partition(_ < xs.head) qs(smaller) ++ (xs.head +: qs(bigger)) } qs(xs.view

I encountered the following code in JAXMag's Scala special issue: package com.weiglewilczek.gameoflife case class Cell(x: Int, y: Int) { override def toString = position private lazy val position = "(%s, %s)".format(x, y) } Does the use of lazy val in the above code provide considerably more performance than the following code? package com.weiglewilczek.gameoflife case class Cell(x: Int, y: Int) { override def toString = "(%s, %s)".format(x, y) } Or is it just a case of unnecessary optimization? One thing to note about lazy vals is that, while they are only calculated once, every access to

I would like to write a function akin to List.concat/1 that takes an enumerable of lists and emits the concatenated lists as a continuous stream. It would work like this: iex> 1..3 |> Stream.map(&([&1])) |> Enum.to_list [[1], [2], [3]] iex> 1..3 |> Stream.map(&([&1])) |> MyStream.concat |> Enum.to_list [1, 2, 3] What I have come up with so far is this: defmodule MyStream do def concat(lists) do Enumerable.reduce(lists, [], fn(x, acc) -> acc ++ x end) end end This produces the correct result but obviously isn't lazy. I have unsuccessfully tried using Stream.Lazy but really fail to understand

I'm using Python 3. I know about the @classmethod decorator. Also, I know that classmethods can be called from instances. class HappyClass(object): @classmethod def say_hello(): print('hello') HappyClass.say_hello() # hello HappyClass().say_hello() # hello However, I don't seem to be able to create class methods dynamically AND let them be called from instances. Let's say I want something like class SadClass(object): def __init__(self, *args, **kwargs): # create a class method say_dynamic SadClass.say_dynamic() # prints "dynamic!" SadClass().say_dynamic() # prints "dynamic!" I've played with