Comments on: Some thoughts on Python

By: Brock

Brock — Mon, 06 Oct 2008 17:02:47 +0000

Coroutines are "one-shot" continuations. That is, with full continuations you can re-activate the same bundle of state multiple times. With coroutines you can stop-and-bundle some state, but you can only resume it once.

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).

By: Websites tagged "pygame" on Postsaver

Websites tagged "pygame" on Postsaver — Fri, 03 Oct 2008 08:32:07 +0000

[...] - "Osfameron": Some thoughts on Python saved by osoy232008-09-19 - Implementation Language saved by gaastra342008-09-19 - Making a [...]

By: dolio

dolio — Fri, 26 Sep 2008 00:08:56 +0000

Bill Mill: I'm relatively sure that continuations are more powerful than coroutines, although I don't have any specific examples.

By: Bill Mill

Bill Mill — Thu, 25 Sep 2008 15:43:51 +0000

> Is that called "filter" in Python?

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

By: Bill Mill

Bill Mill — Thu, 25 Sep 2008 15:38:56 +0000

@dolio python 2.5 gained generators that can be sent values; this makes them isomorphic to coroutines.

Are coroutines isomorphic to continuations?

By: GTof

GTof — Thu, 25 Sep 2008 10:37:03 +0000

About Python, Ruby and the monads, i think it's the opposite. Monads on Ruby are very simple thanks to http://github.com/aanand/ruby-do-notation/tree/master and the blocks of Ruby. The impementation in http://www.valuedlessons.com/2008/01/monads-in-python-with-nice-syntax.html have two problem :

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 :)

By: Pawel Murias

Pawel Murias — Thu, 25 Sep 2008 08:02:48 +0000

lambda's in python don't really mix with the indentation oriented syntax, the none-deprecated equivalent is
def some_name():
pass
foo(some_name)

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

By: Bill Mill

Bill Mill — Thu, 25 Sep 2008 03:36:05 +0000

> Guido wanted to remove (I think) reduce, grep, map from the core language, and there was much gnashing of teeth.

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.

By: Bill Mill

Bill Mill — Thu, 25 Sep 2008 03:30:02 +0000

> Things that you miss out on include multiline strings

errmmm... no you don't.

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

By: dolio

dolio — Thu, 25 Sep 2008 00:54:47 +0000

Are you sure Python has continuations? I was under the impression that it had generators (which your stuff about the 'yield' keyword seems to indicate you're talking about), but those are not full first-class continuations (and Coro sounds like coroutines, which are also not continuations).

It's possible that things have changed without my hearing about it, though (I don't watch Python very closely).

Ruby, for instance, has continuations (see Kernel#callcc or something of that sort).