Copyable iterators ------------------ There are a few ways how you could implement this. However, it only makes sense for iterators, not for generators! Way 1: Copyable iterators have a copy-method:
L = [1,2,3,4] it1 = iter(L) it1.next() 1 it2 = it1.copy() it2.next() 2 it1.next() 2
Way 2: Copyable iterators will be copied when you call it's __iter__-method:
L = [1,2,3,4] it1 = iter(L) it1.next() 1 it2 = iter(it1) it2.next() 2 it1.next() 2
In way 1 you could check for copy ability per hasattr(it,"copy"). Named loops ----------- With named loops you could break or continue other than only the inner most loop. I'm not sure about a syntax, though. for x in X as loop_a: for y in Y as loop_b: if cond1(): break loop_a elif cond2(): continue loop_a elif cond3(): break # breaks loop_b elif cond4(): continue # continues loop_b Auto-curryfication for operators -------------------------------- I like haskells feature for curryfication of operators. I think this would be nice to have in python. You could write instead of 'operator.add' the much shorter '(+)'. Or even '(2+)' works.
map((2+),[1,2,3,4]) [3,4,5,6] filter((>=2),[1,2,3,4]) [2,3,4]
__add__-method for functions ---------------------------- In haskell you can write 'f . g . h', which would be the same like '(\a -> f(g(h(a))))' (in python: 'lambda a: f(g(a))'). In python it would also be nice to have such a functionality. It could be implemented with a __add__-method. Here is this functionality simulated with functors:
class FunctionBase(object): def __add__(self,other): return lambda *args,**kwargs: self(other(*args,**kwargs))
class F(FunctionBase): def __call__(self,s): return s+" foo"
class G(FunctionBase): def __call__(self,s): return s+" bar"
f = F() g = G() (f + g)("x") 'x bar foo' (g + f)("x") 'x foo bar'
What do you think? panzi