Comments on Valued Lessons: Monads in Python (with nice syntax!)

I've done something. It works in the simple exampl...

2008-06-24T07:04:08.581-07:00

I've done something. It works in the simple examples i've tried but i'm very new to python so it might be only these examples. I encode a do-bloc as a string of the form

"""
x <- a_expresion
another_expression
y <- again_one
...
last_expression
"""

And build the expression with bind from it and then evaluate it.

I had a strange problem: if i use a do-block in a fonctoin which takes an argument, it can only be seen in the first statement of the do block :

def test(x):
return eval("mreturn(x)")

will work, but :

def test(x):
return eval("mreturn(1).bind(lambda y : mreturn(x)")

will fail saying "NameError: global name 'x' is not defined"

I has to build a closure to the expression from the list of local names.
Here is my code :

#
# MONAD LIST
#

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

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

@staticmethod
def mreturn(self,val):
raise NotImplementedError

def bind(self, func):
raise NotImplementedError

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

# THE >> Haskell operator
def __rshift__(self, bindee_without_arg):
return self.bind(lambda _ : bindee_without_arg)

class Liste(Monad):
@staticmethod
def mreturn(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 run(self):
return self.value

#
# THE DO NOTATION
#

import re
import compiler

# PARSE ASSIGNMENT "x <- m"
doasgn = re.compile(r"^\s*(\w)+\s*<-\s*(.*)")
# PARSE NON EMPTY LINES
dostmt = re.compile(r"\S.*\S?")

# BUILD THE BIND EXPRESSION FROM OF LIST OF DO-STATEMENTs
def dolist(l):
if len(l) == 1 :
return l[0]
else :
mre = doasgn.match(l[0])
if mre :
g = mre.groups()
return ("(" + g[1] + ").bind(lambda " + g[0] + " : " + dolist(l[1:]) + ")")
else :
return ("(" + l[0] + ") >> (" + 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)

# A TEST :
# Liste([a,.....]) will lift the list [a,....] into the monad
def toto(x,y,z,d):
l = test.rundo(globals(),locals(),"""
a <- Liste([x , x + 1 ])
b <- Liste([y , y + 1 ])
c <- Liste([z , z + 1 ])
Liste.mreturn(x + y + z + a + b + c + d)
""")
return l.run()

print toto(1,10,100,1000)
# WILL GIVE : [1222, 1223, 1223, 1224, 1223, 1224, 1224, 1225]

I played a bit with your code and unfortunately yi...

2008-06-23T14:57:03.059-07:00

I played a bit with your code and unfortunately yields are not good for all cases, for example it doesn't work with the List Monad.

When you bind the monad 'm' with the function 'f'. 'f' can be called several times, this tipically the case with the List Monad.

But with yields, the code:
x = yield a
y = yield b
c
Which should be equivalant to :
a >>= (lambda x : b >>= (lambda y : c))

So let's call 'f' = (lambda x : b >>= (lambda y : c)) . With the List monad, 'f' has to be called as many times as elements in a, which means 'x' has to take as many values as elements in 'a'. But the second time we use "send" to give a value to 'x' through the yield, it won't be another value to 'x' but the value to 'y'.

So your code works well for monads where the binding fonction is called once and exactly once, otherwise you won't call the right yield.

A solution would be to fork the generator as many time as values to give to 'x' but i couldn't get the library to work.

Aanand uses a very nice approach in Ruby, it transform the abstract syntax tree at run time to replace the do-notations assginments by plain calls to bind. I tried to port it to python but ast is python looks to complex !! And i don't even now if it's possible to access the AST of an object what is needed to deal with alpha-conversion and avoid name capture.

What would be great would be a python preprocessor, but i didn't find any.

Thank your for this great stuff!I'm writing a mona...

2008-06-17T15:01:46.458-07:00

Thank your for this great stuff!

I'm writing a monad tutorial with examples in various languages. I would like to use your code to have the do-notation in the examples in python. Would you allow it ? And if yes, under which licence ?

hi, i just found this after implementing monads in...

2008-05-04T05:20:39.432-07:00

hi, i just found this after implementing monads in python myself. i'd be interested in hearing what you think of my code. i took a completely different approach and i am not even sure i am "really" implementing monads - i don't try to use lambdas to bind the values, for example. on the other hand, it's a *lot* simpler :o)

i don't completely understand what you've done, but when i have a spare moment i am going to go step-by-step through the details (i am returning to python after not using much for several years and generators are pretty much new to me).

cheers,
andrew

ps http://acooke.org/cute/MonadsinPy0.html

brian: Abstract Base Classes. Google. Go now, yo...

2008-03-19T06:32:33.309-07:00

brian: Abstract Base Classes. Google. Go now, you can make it.

You can not raise a NotImplementedError in code th...

2008-02-15T18:37:02.673-08:00

You can not raise a NotImplementedError in code that is meant to demonstrate a proof-of-principle to be read on a blogpost.

Hi peter,Neat! I'm still going through the monad ...

2008-01-16T11:45:21.555-08:00

Hi peter,

Neat! I'm still going through the monad code, but I was interested in the use of Maybe and Failure. How easy is it to add these to unsafe code? And what sort of debugging output is attached to them? I guess I'm basically curious as to how functional programming does debugging.

BTW, it inspired me to use a Python exception handling framework to get most of the benefits of the Maybe monad. The post is here.

Looking forward to the should to know more.

Thanks. I fixed it.

2008-01-08T11:43:38.291-08:00

Thanks. I fixed it.

In Monad.make_decorator, you're using the comparis...

2008-01-08T10:55:50.720-08:00

In Monad.make_decorator, you're using the comparison (==) operator when I think you mean to use the assignment operator (=). "decorated.__name__ == undecorated.__name__" and "decorator.__name__ == func.__name__" should both be assignment.

I've added fully runnable source to the bottom of ...

2008-01-08T09:00:44.131-08:00

I've added fully runnable source to the bottom of the article.

Can't you show full runnable source file? It will ...

2008-01-08T05:48:42.148-08:00

Can't you show full runnable source file? It will be a great help to know about the subject.
Thanks in advance.

I'm dying to know the should... all this functiona...

2008-01-08T04:09:49.515-08:00

I'm dying to know the should... all this functional stuff is quite confusing... I get the idea that I need to learn it, just need to make the jump (and it seems like a big one).

Holy moly! This is a really nice way of doing it.I...

2008-01-07T20:35:00.922-08:00

Holy moly!

This is a really nice way of doing it.

I've been interested in using Monads in my Python code for some time (for parsing) and I think that I'm definitely going to use your approach.