[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