Tidy up code indenting using 3-space top-level indents and 4-space indents within the sample Python code
This commit is contained in:
Nick Coghlan
parent
f9ab5fc41e
commit
7530a8f583
184
pep-3150.txt
184
pep-3150.txt
|
|
@ -59,9 +59,9 @@ The ``given`` clause would allow subexpressions to be referenced by
|
|||
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 @@ significance for later code) while hiding the most likely irrelevant
|
|||
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 @@ which of the following is easier to comprehend?
|
|||
|
||||
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 @@ Syntax Change
|
|||
|
||||
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 @@ flow_stmt to separate the statements that potentially contain arbitrary
|
|||
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 @@ Torture Test
|
|||
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 @@ the torture test is executed at class scope.
|
|||
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 @@ copy-in-copy-out referencing semantics to move any required name
|
|||
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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue