Perl's Coro provides coroutines, not continuations.

Interestingly enough, for one interesting use of continuations -- inverting the control of web applications ala Seaside -- it turns out that coroutines are Good Enough (tm).

ahha - yes. Guido likes filter when used with builtins, but thinks a list comp is clearer than filter with a lambda.

Are coroutines isomorphic to continuations?

1 - he copies the generator by replaying it from the beginng, it's not very efficient. 2 - lambdas in python are restraint to only expression

Furthermore when trying to implement monad in Python i noticed some more issues. Imagine you want a function :

def foo(a): return do x >= (lamnda x : N(a))

'a' occrus in a lambda in an expression, that's bad !

I tried to use the same technique as in Ruby but cecause of the complexity of the Python bytecode i gaved up.

If you want you can use the code i've done to simulate do-notation. It works but code need to be in strings which are parsed, transformed and interpreded. it's not as beatiful as in Ruby.

 # THE DO NOTATION

import re import compiler

# PARSE ASSIGNMENT "x <- m" doasgn = re.compile(r"^\s(\w+)\s> (" + dolist(l[1:]) + ")")

# TRANSORM A DO BLOCK INTO A BIND EXPRESSION do = lambda s : dolist(dostmt.findall(s)) # COMPILE A DO BLOCK INTO A CODE EXPRESSION cdo = lambda s : compiler.compile(do(s),'compiledo.py','eval')

# PYTHON HAS PROBLEMS TO SEE LOCAL VARIABLES WHEN EVALUATING : # def test(x) : # return eval(do(""" # List.mreturn(x) # """) # # print test(5).run() # # Will give the good result but : # # def test(x) : # return eval(do(""" # y <- ..... # List.mreturn(x) # """) # # print test(5).run() # # Will give the error : NameError: global name 'x' is not defined # To avoid that, we build a closure from the list of local variables # with (lambda x : ...)(locals()["x"]) # So x is in the context of the expression with the good value in locals

def closure(v,m): l = v for x in m.keys() : l = "((lambda " + x + " : " + l + ")(m[\"" + x + "\"]))" return "(lambda m : " + l + ")"

# JUST TO EVALUATE THE BLOCK def rundo(g,l,s): return eval(closure(do(s),l),g,l)(l)

# MONADES #

class Monad: value=None def init(self,val): self.value=val

 @staticmethod
 def mreturn(val):
     raise NotImplementedError

 @classmethod
 def sequence(self,l):
    if len(l) == 0:
       return self.mreturn([])
    else :
       return rundo(globals(),locals(),"""
          x <- l[0]
          q <- self.sequence(l[1:])
          self.mreturn([x] + q)
         """)

 @classmethod
 def foldM(self,f,i,l):
   if len(l) == 0 :
     return self.mreturn(i)
   else :
     return rundo(globals(),locals(),"""
        x <- f(i,l[0])
        self.foldM(f,x,l[1:])
       """)

 def bind(self, func):
     raise NotImplementedError

 def __ge__(self, bindee):
     return self.bind(bindee)

 def __rshift__(self, bindee_without_arg):
    return self.bind(lambda _ : bindee_without_arg)

# MONADE LISTE #

def concat(x) : res = [] for y in x : res.extend(y) return res

class Liste(Monad): @staticmethod def mreturn(val) : return Liste([val])

 @staticmethod
 def mreturnL(val) :
     return Liste(val) 

 def bind(self,func):
     def fval(x):
        return func(x).value

     return Liste(concat(map(fval,self.value)))

 @staticmethod
 def zero():
     return Liste([])

def guard(b): if b : return Liste.mreturn(()) else : return Liste.zero()

# EXEMPLES

test = eval(do(""" x <- Liste(["1" , "2" ]) y <- Liste(["3" , "4" ]) Liste.mreturn (x + " and " + y) """))

print test.value

Another point. Continuation and may yield be différent on one other point i think. When you want to use delimited continuation, i wonder if it's possible to implement shift/reset with yield. Maybe yes.

Good post anyway :)

if you can make up enough meaningfull names, it's better ;)

Nope, reduce got moved to the standard library instead of the builtin functions because list comprehensions are now the built-in way to perform reduces. map() is still in the builtins and there's never been a grep() function, I'm not sure what you're talking about there.

> CPAN is a big advantage for the Perl community

PyPI is still no CPAN, but it's coming along.

errmmm... no you don't.

def foobar(): return """this is a long string that is triple-quoted therefore it is a multiline string"""