Callcc problem in Generator

[Greg Fitzgerald]

Hey all,

I was playing with the Generator class the other day and decided I
didn't like that you can't break out while iterating through the
generator without first having already taken the time to iterate to
the element after the one you were at when you decided to break out.

The following code shows what I mean. It runs through
test_generator() twice, the first with the current implementation of
Generator, and the second with a new one I whipped up. It shows that
the current implementation takes longer to execute when breaking out
early. Also, outside of performance, I don't like that if I were
reading a stream of data and decided to break out, it would read one
too many lines--kind of an ugly side-effect.

Unfortunately, there's a significant bug in my version that I been
trying to crack all night and I can't figure it out for the life of
me. I want to be able to start iterating, then midway through, call
rewind(), and then start iterating through again. When I do that, it
leaves the stack in an odd place, and when I call each(), it will make
it all the way to the end then get caught in an infinite loop inside
next?().

So I guess my question is, if you create a continuation with callcc()
and then decide never to call that continuation, is there some way to
unwind the stack?

Thanks,
Greg



require 'generator'

def test_generator()
timeStart = Time.now
puts "start constructing at #{Time.now - timeStart}"
gen = Generator.new do |g|
for num in [1,2,3,4,5]
sleep(3)
g.yield(num)
end
end

puts "finished constructing at #{Time.now - timeStart}"

puts "getting first element at #{Time.now - timeStart}"
for num in gen
puts num
break if num == 3
puts "getting next element at #{Time.now - timeStart}"
end
puts "done at #{Time.now - timeStart}"

puts "\n\n"
end

puts "Ruby's Generator"
test_generator()

class EndOfGenerator < Exception
end

class Generator
def initialize(&closure)
@closure = closure
return rewind()
end

def each()
rewind()

while self.next?()
yield self.next()
end
return self
end

def rewind()
@closureEntryPoint = nil
@currentElement = nil
@nextElement = nil
@position = -1
#self.next?()
return self
end

def pos()
return @position
end

def current()
if @currentElement == nil
begin
self.next()
@nextElement = @currentElement
rescue EndOfGenerator
end
end

return @currentElement
end

def next?()
return true if @nextElement
begin
@nextElement = self.next()
return true
rescue EndOfGenerator
return false
end
end

def end?()
return !self.next?()
end

def next()
if @nextElement
@currentElement = @nextElement
else
@currentElement = callcc do |cc|
@generatorEntryPoint = cc
if @closureEntryPoint == nil
@closure.call(self)
raise EndOfGenerator.new()
else
@closureEntryPoint.call()
end
end
@position += 1
end
@nextElement = nil
return @currentElement
end

def yield(obj)
return callcc do |cc|
@closureEntryPoint = cc
@generatorEntryPoint.call(obj)
end
end
end

puts "Corrected generator"
test_generator()