from pixie.vm.object import Object, Type, runtime_error

from pixie.vm.code import extend, as_var

from pixie.vm.primitives import true, false, nil

import pixie.vm.stdlib as proto

import pixie.vm.rt as rt

class EmptyIterator(Object):

_type = Type(u"pixie.vm.Iterator")

def type(self):

return EmptyIterator._type

def __init__(self):

pass

def move_next(self):

runtime_error(u"Empty Iterator")

def at_end(self):

return True

empty_iterator = EmptyIterator()

@extend(proto._at_end_QMARK_, EmptyIterator)

def _at_end(_):

return true

class NativeIterator(Object):

_type = Type(u"pixie.vm.NativeIterator")

def type(self):

return NativeIterator._type

def __init__(self):

pass

@extend(proto._at_end_QMARK_, NativeIterator)

def _at_end(self):

return rt.wrap(self.at_end())

@extend(proto._move_next_BANG_, NativeIterator)

def _move_next(self):

return self.move_next()

@extend(proto._current, NativeIterator)

def _current(self):

return self.current()

class MapIterator(NativeIterator):

def __init__(self, fn, iter):

self._w_fn = fn

self._w_iter = iter

if not iter.at_end():

self._w_current = self._w_fn.invoke([self._w_iter.current()])

def move_next(self):

self._w_iter.move_next()

if not self._w_iter.at_end():

self._w_current = self._w_fn.invoke([self._w_iter.current()])

else:

self._w_current = nil

def current(self):

return self._w_current

def at_end(self):

return self._w_iter.at_end()