[Python-checkins] r83003 - peps/trunk/pep-3150.txt
nick.coghlan
python-checkins at python.org
Wed Jul 21 00:34:39 CEST 2010
Author: nick.coghlan
Date: Wed Jul 21 00:34:39 2010
New Revision: 83003
Log:
Tidy up code indenting using 3-space top-level indents and 4-space indents within the sample Python code
Modified:
peps/trunk/pep-3150.txt
Modified: peps/trunk/pep-3150.txt
==============================================================================
--- peps/trunk/pep-3150.txt (original)
+++ peps/trunk/pep-3150.txt Wed Jul 21 00:34:39 2010
@@ -59,9 +59,9 @@
name in the header line, with the actual definitions following in
the indented clause. As a simple example::
- c = sqrt(a*a + b*b) given:
- a = retrieve_a()
- b = retrieve_b()
+ c = sqrt(a*a + b*b) given:
+ a = retrieve_a()
+ b = retrieve_b()
Rationale
=========
@@ -88,9 +88,9 @@
Using the simple example from the proposal section, the current Python
equivalent would be::
- a = retrieve_a()
- b = retrieve_b()
- c = sqrt(a*a + b*b)
+ a = retrieve_a()
+ b = retrieve_b()
+ c = sqrt(a*a + b*b)
If later code is only interested in the value of c, then the
details involved in retrieving the values of a and b may be an
@@ -103,29 +103,29 @@
Subexpressions up front?::
- sea = water()
- temp = get_temperature(sea)
- depth = get_depth(sea)
- purity = get_purity(sea)
- saltiness = get_salinity(sea)
- size = get_size(sea)
- density = get_density(sea)
- desired_property = calc_value(temp, depth, purity,
- salinity, size, density)
- # Further operations using desired_property
+ sea = water()
+ temp = get_temperature(sea)
+ depth = get_depth(sea)
+ purity = get_purity(sea)
+ saltiness = get_salinity(sea)
+ size = get_size(sea)
+ density = get_density(sea)
+ desired_property = calc_value(temp, depth, purity,
+ salinity, size, density)
+ # Further operations using desired_property
Or subexpressions indented?::
- desired_property = calc_value(temp, depth, purity,
+ desired_property = calc_value(temp, depth, purity,
salinity, size, density) given:
- sea = water()
- temp = get_temperature(sea)
- depth = get_depth(sea)
- purity = get_purity(sea)
- saltiness = get_salinity(sea)
- size = get_size(sea)
- density = get_density(sea)
- # Further operations using desired_property
+ sea = water()
+ temp = get_temperature(sea)
+ depth = get_depth(sea)
+ purity = get_purity(sea)
+ saltiness = get_salinity(sea)
+ size = get_size(sea)
+ density = get_density(sea)
+ # Further operations using desired_property
The ``given`` clause may also function as a more readable
alternative to some uses of lambda expressions and similar
@@ -162,25 +162,25 @@
Current::
- expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) |
- ('=' (yield_expr|testlist_star_expr))*)
- del_stmt: 'del' exprlist
- return_stmt: 'return' [testlist]
- yield_stmt: yield_expr
- raise_stmt: 'raise' [test ['from' test]]
- assert_stmt: 'assert' test [',' test]
+ expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) |
+ ('=' (yield_expr|testlist_star_expr))*)
+ del_stmt: 'del' exprlist
+ return_stmt: 'return' [testlist]
+ yield_stmt: yield_expr
+ raise_stmt: 'raise' [test ['from' test]]
+ assert_stmt: 'assert' test [',' test]
New::
- expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) |
- ('=' (yield_expr|testlist_star_expr))*) [where_clause]
- del_stmt: 'del' exprlist [given_clause]
- return_stmt: 'return' [testlist] [given_clause]
- yield_stmt: yield_expr [given_clause]
- raise_stmt: 'raise' [test ['from' test]] [given_clause]
- assert_stmt: 'assert' test [',' test] [given_clause]
- given_clause: "given" ":" suite
+ expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) |
+ ('=' (yield_expr|testlist_star_expr))*) [where_clause]
+ del_stmt: 'del' exprlist [given_clause]
+ return_stmt: 'return' [testlist] [given_clause]
+ yield_stmt: yield_expr [given_clause]
+ raise_stmt: 'raise' [test ['from' test]] [given_clause]
+ assert_stmt: 'assert' test [',' test] [given_clause]
+ given_clause: "given" ":" suite
(Note that expr_stmt in the grammar covers assignment and augmented
assignment in addition to simple expression statements)
@@ -205,24 +205,24 @@
subexpressions and then allowing a single one of those statements with
a ``given`` clause at the simple_stmt level. Something along the lines of::
- stmt: simple_stmt | given_stmt | compound_stmt
- simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
- small_stmt: (pass_stmt | flow_stmt | import_stmt |
- global_stmt | nonlocal_stmt)
- flow_stmt: break_stmt | continue_stmt
- given_stmt: subexpr_stmt (given_clause |
- (';' (small_stmt | subexpr_stmt))* [';']) NEWLINE
- subexpr_stmt: expr_stmt | del_stmt | flow_subexpr_stmt | assert_stmt
- flow_subexpr_stmt: return_stmt | raise_stmt | yield_stmt
- given_clause: "given" ":" suite
+ stmt: simple_stmt | given_stmt | compound_stmt
+ simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+ small_stmt: (pass_stmt | flow_stmt | import_stmt |
+ global_stmt | nonlocal_stmt)
+ flow_stmt: break_stmt | continue_stmt
+ given_stmt: subexpr_stmt (given_clause |
+ (';' (small_stmt | subexpr_stmt))* [';']) NEWLINE
+ subexpr_stmt: expr_stmt | del_stmt | flow_subexpr_stmt | assert_stmt
+ flow_subexpr_stmt: return_stmt | raise_stmt | yield_stmt
+ given_clause: "given" ":" suite
For reference, here are the current definitions at that level::
- stmt: simple_stmt | compound_stmt
- simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
- small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
- import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
- flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
+ stmt: simple_stmt | compound_stmt
+ simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+ small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
+ import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
+ flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
Common Objections
@@ -275,17 +275,17 @@
An implementation of this PEP must support execution of the following
code at module, class and function scope::
- b = {}
- a = b[f(a)] = x given:
- x = 42
- def f(x):
- return x
- assert "x" not in locals()
- assert "f" not in locals()
- assert a == 42
- assert d[42] == 42 given:
- d = b
- assert "d" not in locals()
+ b = {}
+ a = b[f(a)] = x given:
+ x = 42
+ def f(x):
+ return x
+ assert "x" not in locals()
+ assert "f" not in locals()
+ assert a == 42
+ assert d[42] == 42 given:
+ d = b
+ assert "d" not in locals()
Most naive implementations will choke on the first complex assignment,
while less naive but still broken implementations will fail when
@@ -294,15 +294,15 @@
And yes, that's a perfectly well-defined assignment statement. Insane,
you might rightly say, but legal::
- >>> def f(x): return x
- ...
- >>> x = 42
- >>> b = {}
- >>> a = b[f(a)] = x
- >>> a
- 42
- >>> b
- {42: 42}
+ >>> def f(x): return x
+ ...
+ >>> x = 42
+ >>> b = {}
+ >>> a = b[f(a)] = x
+ >>> a
+ 42
+ >>> b
+ {42: 42}
Possible Implementation Strategy
@@ -326,23 +326,23 @@
bindings between the inner and outer scopes. The torture test above
would then translate to something like the following::
- b = {}
- def _anon1(b): # 'b' reference copied in
- x = 42
- def f(x):
- return x
- a = b[f(a)] = x
- return a # 'a' reference copied out
- a = _anon1(b)
- assert "x" not in locals()
- assert "f" not in locals()
- assert a == 42
- def _anon2(b) # 'b' reference copied in
- d = b
- assert d[42] == 42
- # Nothing to copy out (not an assignment)
- _anon2()
- assert "d" not in locals()
+ b = {}
+ def _anon1(b): # 'b' reference copied in
+ x = 42
+ def f(x):
+ return x
+ a = b[f(a)] = x
+ return a # 'a' reference copied out
+ a = _anon1(b)
+ assert "x" not in locals()
+ assert "f" not in locals()
+ assert a == 42
+ def _anon2(b) # 'b' reference copied in
+ d = b
+ assert d[42] == 42
+ # Nothing to copy out (not an assignment)
+ _anon2()
+ assert "d" not in locals()
However, as noted in the abstract, an actual implementation of
this idea has never been tried.
More information about the Python-checkins
mailing list