---

if map[x][y].overlay:
   map[x][y].overlay.blit(x,y)

---

... and ...

---

if map[x][y].overpay as ob:
   ob.blit(x, y)

---

the second one looks much more fun I think.

Toss your idea out on python-ideas.
It isn't horrible.
And it helps with while-statement issues.

FWIW, I have a patch for it. :)

Hi, 

I like this idea. 

I've put together a short patch that will implement inline
assignment. 

if f() -> name:
  use(name)

or more powerfully:

if f() -> name == 'spam':
   usespam(name)

the old syntax if something as x: is still available if that
is what is desired.

if (f() == 'spam') -> name:
   newname = name.replace('p', 'h') 

Patched against Py3k please kick the tires, I've added some tests and
developed a PEP.

What's wrong with this?

ob = map[x][y].overpay
if ob:
   ob.blit(x, y)


Is this proposal just about saving one line?

If we allow this, how many of the following will be allowed?

if expr as name: <block>
while expr as name: <block>
expr as name  # alternative to "name = expr"

Frankly, the only one that seems to be useful to me is the second.

As for using "->", please no, there are plenty of languages that use 
line noise, but Python doesn't need to be one of them.

Regarding the proposed syntax:

if (f() == 'spam') -> name:
   newname = name.replace('p', 'h') 

Surely that should assign the *bool* result of comparing f() 
with 'spam' to name? Doing anything else is opening the door to a 
world of pain.

if (f() == 'spam') -> name  # binds name=f()
if ('spam' == f()) -> name  # binds 'spam' to name?
if (f() == g()) -> name  # binds what to name?
if (f() or g()) -> name  # binds what to name?

> If we allow this, how many of the following will be allowed?

> if expr as name: <block>
> while expr as name: <block>
> expr as name  # alternative to "name = expr"

This patch implements your final point:
 expr as name (albeit with a nominal '->' RARROW rather than 'as')

the patch creates a new expression, assexp (assignment expression) 
there is no need to implement this for countless other 
if/while/for because
they accept expressions and this assignment is an expression.
(Note it is a patch for a different behaviour than the OP suggested.)


> As for using "->", please no, there are plenty of languages that use 
> line noise, but Python doesn't need to be one of them.

I have begun a discussion about this on python-ideas to give it some
air as suggested by Raymond. We can always close the issue as 'wont fix'
if it doesn't get off the ground. 

This issue (although addressing an old concern dating back 
to the beginning of python) has been sitting unloved for 9 or so months
and I felt that we should at least resolve it.

Cheers, 

Jervis

> Regarding the proposed syntax:

> if (f() == 'spam') -> name:
>   newname = name.replace('p', 'h') 

> Surely that should assign the *bool* result of comparing f() 
> with 'spam' to name? Doing anything else is opening the door to a 
> world of pain.

You are correct. It does assign the result of the bool. I have
made an error in creating the example. This is what happens when
I copy and paste and don't check the result.

should read

 if f -> name:
   # use name, (pointless example but in line with the OP's suggestion)

Thanks for picking this up.

At the moment binding occurs either right-to-left with "=", eg.

    x = y

where "x" is the new name, or left-to-right, eg.

    import x as y

where "y" is the new name.

If the order is to be right-to-left then using "as" seems to be the best
choice.

On the other hand, if there should be a form of binding explicitly for
use in an expression in order to prevent accidental use of "=" then the
order should probably be the same as "=", ie right-to-left, and a new
symbol is needed (using punctuation feels preferable somehow, because
"=" uses punctuation).

The only symbol I can think of is "~=".

How does this:

if ob ~= map[x][y].overpay:
   ob.blit(x, y)

look compared to:

if map[x][y].overpay as ob:
   ob.blit(x, y)

IMHO, of course.

Matthew suggested ~= instead of -> or "as".

I dislike this because ~= first makes me think of "approximately equal 
to", and then it makes me think of augmented assignment, and only then 
do I remember that although ~ is used in Python for bitwise-not, ~= is 
not a legal augmented assignment.

> Matthew suggested ~= instead of -> or "as".

Try the patch, you can make changes (for those that aren't aware) 
by changing the token in Grammar/Grammar to whatever you wish. It is easy
to do and you need only recompile after this step. 

example:

    assexp: xor_expr ['->' xor_expr] 

could become

    assexp: xor_expr ['magic' xor_expr]


    >>> 'hello' magic words
    'hello'
    >>> words
    'hello'


Note that Mr Barnett may need to look at other fixes to get
his '~=' idea off the ground (tokenizer.c and specifically adding a new
token)

I've recommended that we close this issue.

Cheers,

Jervis

Rejecting this after discussion on python-ideas:
http://mail.python.org/pipermail/python-ideas/2009-March/003423.html

Overview of some of the major objections here:
http://mail.python.org/pipermail/python-ideas/2009-March/003440.html

Just for the record, I wasn't happy with "~=" either, and I have no
problem with just forgetting the whole idea.