Gimbo, as many of you know, is learning Haskell, and just discovered the power and conciseness of lazy evaluation with a one-line definition of the entire Fibonacci sequence.
You can do a vaguely similar thing in Python. First we have a lazy list class:
class LazyList:
def __init__(self):
self._list = []
def __getitem__(self, key):
length = len(self._list)
if key.__class__ == int:
max = key
elif key.__class__ == slice:
max = key.stop
if max >= length:
for i in xrange(length-1,max):
self._list.append(self._gen.next())
return self._list[key]
To create the actual Fibonacci sequence, we define a subclass:
class FibList(LazyList):
def __init__(self):
def fibgen():
lastfib = 0
nextfib = 1
yield lastfib
yield nextfib
while True:
(lastfib, nextfib) = (nextfib, lastfib+nextfib)
yield nextfib
LazyList.__init__(self)
self._gen = fibgen()
Then a “list” (not really a list, but looks like one) of the Fibonacci numbers is
somefibs = FibList()
and we can look up the nth Fibonacci number, and take slices of it:
>>> somefibs[0]
0
>>> somefibs[3]
2
>>> somefibs[0:3]
[0, 1, 1]
>>> somefibs[2:20:4]
[1, 8, 55, 377, 2584]
But of course this isn’t a one-liner. Plus we’ve fallen victim to a variant of Greenspun’s Tenth Rule, substituting “Common Lisp” with “Haskell 98” :)