Comments on A Neighborhood of Infinity: Purely functional recursive types in Haskell and P...

sigfpe-- Aaaugh, scary but interesting post! How...

2009-11-29T19:06:39.190-08:00

sigfpe--

Aaaugh, scary but interesting post! However, the problem discussed there
* isn't with lambdas per se,
* it's with a closure (lambda or def) referring to loop variables in the enclosing function
* so doing the closure with def doesn't change that situation
* anyway it doesn't come up in your situation (referring to the enclosing function's parameters)

My sense even after that post is that Python's closures are about as pure or impure as Scheme's (unless you think of the tail-call memory leak as impurity).

Apply paranoias sparingly!

FutureNerd, Can't remember why I didn't use lambd...

2009-11-29T14:36:26.967-08:00

FutureNerd,

Can't remember why I didn't use lambdas. Probably the sort of paranoia expressed here: http://math.andrej.com/2009/04/09/pythons-lambda-is-broken/

""" (I'm leaving a comment, heh.) I thought a cou...

2009-11-29T13:48:43.699-08:00

"""
(I'm leaving a comment, heh.)

I thought a couple of your examples would have been clearer by first saying

"""
def plus(a,b):
____return a+b
"""

(Wanting Python to have a syntax for that is the kind of pressure that created C++!)

Funny omission...

...each constructor is replaced with the appropriate function. Here's an example:

Now consider a simple expression type in Haskell:

...as in, "Wanna see me do it again?" or, "Yes, in Python it's that simple!" I do get the idea, though.

Is there an efficiency, readability or code style reason why you use internal defs with just a return line, instead of lambdas? I.e., (why) do you prefer

"""
def cons(h,t):
____def _cons(a,b):
________return a(h,t(a,b))
____return _cons
"""

to

"""
def cons(h,t):
____return lambda a,b: a(h,t(a,b))
"""
?

I wonder whether there's a compiler somewhere that recognizes nested lambdas as conses or sequential arrays (I infer that Haskell doesn't?).

Interesting stuff, I got here from your "Programming with impossible functions."
"""

Minor typo: "Evaluating X, 2 and X+2 at X=2:" shou...

2009-11-29T01:53:17.186-08:00

Minor typo: "Evaluating X, 2 and X+2 at X=2:" should be "Evaluating X, 2 and X+2 at X=3".

Thanks for the post, I enjoyed it very much.

You say that "Wadler's paper also describes a dual...

2008-02-11T00:55:00.000-08:00

You say that "Wadler's paper also describes a dual version of this for codata such as streams. But as far as I understand it's not very interesting." I disagree; I think the dual is very interesting! Whereas the inductive version captures algebraic datatypes as purely functional recursive types, the coinductive version captures abstract datatypes. I exploit this in my paper Unfolding Abstract Datatypes. (I'd explain here, but the margin is too narrow.)

One quick point. If you want to test for an empty ...

2008-02-06T18:14:00.000-08:00

One quick point. If you want to test for an empty list, it is better to do:

if not l:

instead of

if l==[]:

單中杰,In your paper I read> This representation is a...

2008-02-04T16:31:32.439-08:00

單中杰,

In your paper I read

> This representation is almost the same as in §1.1, only written with lowercase identifiers.

At one point I started writing exactly the same sentence when composing my blog post. I'll have to read the rest of that paper, it seems interesting.

Mikael,Well there's already a nice description in ...

2008-02-04T16:20:06.911-08:00

Mikael,

Well there's already a nice description in terms of initial F-algebras but I think I see what you mean.

Now I -really- want to see (or write) a discussion...

2008-02-03T01:39:00.000-08:00

Now I -really- want to see (or write) a discussion of recursive data types and generalized folds in the language of operads! What you said a generalized fold is looks to me very much like the construction of a free operads on a set of operations. (and/or possibly representations of such)

Good post. I think what's missing is a discussion ...

2008-02-02T15:58:00.000-08:00

Good post. I think what's missing is a discussion of the connection with lambda calculus, since all you're really describing is a couple of implementations in concrete languages of standard l-c types.