Snap for 6029552 from e8635854e4dd46c3ec9ea1490025a7d3f7ad5eae to rvc-release
Change-Id: Ie1e714fe23070acc33ce40f727507bc0f8c0993f
diff --git a/README.md b/README.md
index b8f87fc..3a239c3 100644
--- a/README.md
+++ b/README.md
@@ -39,7 +39,7 @@
[objc]: objcguide.md
[java]: https://google.github.io/styleguide/javaguide.html
[py]: https://google.github.io/styleguide/pyguide.html
-[r]: https://google.github.io/styleguide/Rguide.xml
+[r]: https://google.github.io/styleguide/Rguide.html
[sh]: https://google.github.io/styleguide/shell.xml
[htmlcss]: https://google.github.io/styleguide/htmlcssguide.html
[js]: https://google.github.io/styleguide/jsguide.html
diff --git a/Rguide.md b/Rguide.md
new file mode 100644
index 0000000..de27371
--- /dev/null
+++ b/Rguide.md
@@ -0,0 +1,109 @@
+# Google's R Style Guide
+
+R is a high-level programming language used primarily for statistical computing
+and graphics. The goal of the R Programming Style Guide is to make our R code
+easier to read, share, and verify.
+
+The Google R Style Guide is a fork of the
+[Tidyverse Style Guide](https://style.tidyverse.org/) by Hadley Wickham
+[license](https://creativecommons.org/licenses/by-sa/2.0/). Google modifications
+were developed in collaboration with the internal R user community. The rest of
+this document explains Google's primary differences with the Tidyverse guide,
+and why these differences exist.
+
+## Syntax
+
+### Naming conventions
+
+Google prefers identifying functions with `BigCamelCase` to clearly distinguish
+them from other objects.
+
+```
+# Good
+DoNothing <- function() {
+ return(invisible(NULL))
+}
+```
+
+The names of private functions should begin with a dot. This helps communicate
+both the origin of the function and its intended use.
+
+```
+# Good
+.DoNothingPrivately <- function() {
+ return(invisible(NULL))
+}
+```
+
+We previously recommended naming objects with `dot.case`. We're moving away from
+that, as it creates confusion with S3 methods.
+
+### Don't use attach()
+
+The possibilities for creating errors when using `attach()` are numerous.
+
+## Pipes
+
+### Right-hand assignment
+
+We do not support using right-hand assignment.
+
+```
+# Bad
+iris %>%
+ dplyr::summarize(max_petal = max(Petal.Width)) -> results
+```
+
+This convention differs substantially from practices in other languages and
+makes it harder to see in code where an object is defined. E.g. searching for
+`foo <-` is easier than searching for `foo <-` and `-> foo` (possibly split over
+lines).
+
+### Use explicit returns
+
+Do not rely on R's implicit return feature. It is better to be clear about your
+intent to `return()` an object.
+
+```
+# Good
+AddValues <- function(x, y) {
+ return(x + y)
+}
+
+# Bad
+AddValues <- function(x, y) {
+ x + y
+}
+```
+
+### Qualifying namespaces
+
+Users should explicitly qualify namespaces for all external functions.
+
+```
+# Good
+purrr::map()
+```
+
+We discourage using the `@import` Roxygen tag to bring in all functions into a
+NAMESPACE. Google has a very big R codebase, and importing all functions creates
+too much risk for name collisions.
+
+While there is a small performance penalty for using `::`, it makes it easier to
+understand dependencies in your code. There are some exceptions to this rule.
+
+* Infix functions (`%name%`) always need to be imported.
+* Certain `rlang` pronouns, notably `.data`, need to be imported.
+* Functions from default R packages, including `datasets`, `utils`,
+ `grDevices`, `graphics`, `stats` and `methods`. If needed, you can `@import`
+ the full package.
+
+When importing functions, place the `@importFrom` tag in the Roxygen header
+above the function where the external dependency is used.
+
+## Documentation
+
+### Package-level documentation
+
+All packages should have a package documentation file, in a
+`packagename-package.R` file.
diff --git a/Rguide.xml b/Rguide.xml
index ef87872..ae6a93d 100644
--- a/Rguide.xml
+++ b/Rguide.xml
@@ -2,446 +2,14 @@
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+ <meta http-equiv="refresh" content="0; URL=Rguide.html"/>
<link rel="stylesheet" type="text/css" href="styleguide.css"/>
<title>Google's R Style Guide</title>
</head>
-
<body>
-
<h1>Google's R Style Guide</h1>
-
<p>
- R is a high-level programming language used primarily for
- statistical computing and graphics. The goal of the R
- Programming Style Guide is to make our R code easier to read,
- share, and verify. The rules below were designed in
- collaboration with the entire R user community at Google.
-
+ The style guide has moved to <a href="Rguide.html">Rguide.html</a>
</p>
-
-
-
-
-
-
- <h2>Summary: R Style Rules</h2>
-
- <ol>
- <li><a href="#filenames">File Names</a>: end in <code>.R</code></li>
- <li><a href="#identifiers">Identifiers</a>: <code>variable.name</code>
- (or <code>variableName</code>),
- <code>FunctionName</code>, <code>kConstantName</code></li>
- <li><a href="#linelength">Line Length</a>: maximum 80 characters</li>
- <li><a href="#indentation">Indentation</a>: two spaces, no tabs</li>
- <li><a href="#spacing">Spacing</a></li>
- <li><a href="#curlybraces">Curly Braces</a>: first on same line, last on
- own line</li>
- <li><a href="#else">else</a>: Surround else with braces </li>
- <li><a href="#assignment">Assignment</a>: use <code><-</code>, not
- <code>=</code></li>
- <li><a href="#semicolons">Semicolons</a>: don't use them</li>
- <li><a href="#generallayout"> General Layout and Ordering</a></li>
- <li><a href="#comments"> Commenting Guidelines</a>: all comments begin
- with <code>#</code> followed by a space; inline comments need two
- spaces before the <code>#</code></li>
- <li><a href="#functiondefinition">Function Definitions and Calls</a></li>
- <li><a href="#functiondocumentation"> Function Documentation</a></li>
- <li><a href="#examplefunction"> Example Function</a></li>
- <li><a href="#todo"> TODO Style</a>: <code>TODO(username)</code></li>
- </ol>
-
- <h2>Summary: R Language Rules</h2>
- <ol>
- <li><a href="#attach"> <code>attach</code></a>: avoid using it</li>
- <li><a href="#functionlanguage"> Functions</a>:
- errors should be raised using <code>stop()</code></li>
- <li><a href="#object"> Objects and Methods</a>: avoid S4 objects and
- methods when possible; never mix S3 and S4 </li>
- </ol>
-
- <h3>Notation and Naming</h3>
-
- <h4 id="filenames">File Names</h4>
- <p>
- File names should end in <code>.R</code> and, of course, be
- meaningful.
- <br/> GOOD: <code>predict_ad_revenue.R</code>
- <br/> BAD: <code><span style="color:red">foo.R</span></code>
- </p>
-
- <h4 id="identifiers">Identifiers</h4>
- <p>
- Don't use underscores ( <code>_</code> ) or hyphens
- ( <code>-</code> ) in identifiers.
- Identifiers should be named according to the following conventions.
- The preferred form for variable names is all lower case
- letters and words separated with dots
- (<code>variable.name</code>), but <code>variableName</code>
- is also accepted;
- function names have initial capital letters and no dots
- (<code>FunctionName</code>);
- constants are named like functions but with an initial
- <code>k</code>.
- </p>
- <ul>
- <li><code>variable.name</code> is preferred, <code>variableName</code> is accepted
- <br/> GOOD: <code>avg.clicks</code>
- <br/> OK: <code>avgClicks</code>
- <br/> BAD: <code><span style="color:red">avg_Clicks</span></code>
- </li>
- <li><code>FunctionName </code>
- <br/> GOOD: <code>CalculateAvgClicks</code>
- <br/> BAD: <code><span style="color:red">calculate_avg_clicks
- </span></code>,
- <code><span style="color:red">calculateAvgClicks</span></code>
- <br/> Make function names verbs.
- <br/><em>Exception: When creating a classed object, the function
- name (constructor) and class should match (e.g., lm).</em></li>
- <li><code>kConstantName </code></li>
- </ul>
-
-
- <h3>Syntax</h3>
-
- <h4 id="linelength">Line Length</h4>
-<p>
- The maximum line length is 80 characters.
-</p>
-
- <h4 id="indentation">Indentation</h4>
- <p>
- When indenting your code, use two spaces. Never use tabs or mix
- tabs and spaces.
- <br/><em>Exception: When a line break occurs inside parentheses,
- align the wrapped line with the first character inside the
- parenthesis.</em>
- </p>
-
- <h4 id="spacing">Spacing</h4>
- <p>
- Place spaces around all binary operators (<code>=</code>,
- <code>+</code>, <code>-</code>, <code><-</code>, etc.).
- <br/><em> Exception: Spaces around <code>=</code>'s are
- optional when passing parameters in a function call.</em>
- </p>
- <p>
- Do not place a space before a comma, but always place one after a
- comma.
- <br/><br/> GOOD:
- </p>
-<pre>tab.prior <- table(df[df$days.from.opt < 0, "campaign.id"])
-total <- sum(x[, 1])
-total <- sum(x[1, ])</pre>
- <p>
- BAD:
- </p>
-<pre><span style="color:red">tab.prior <- table(df[df$days.from.opt<0, "campaign.id"]) # Needs spaces around '<'
-tab.prior <- table(df[df$days.from.opt < 0,"campaign.id"]) # Needs a space after the comma
-tab.prior<- table(df[df$days.from.opt < 0, "campaign.id"]) # Needs a space before <-
-tab.prior<-table(df[df$days.from.opt < 0, "campaign.id"]) # Needs spaces around <-
-total <- sum(x[,1]) # Needs a space after the comma
-total <- sum(x[ ,1]) # Needs a space after the comma, not before</span>
-</pre>
- <p>
- Place a space before left parenthesis, except in a function call.
- </p>
- <p>
- GOOD:
- <br/><code>if (debug)</code>
- </p>
- <p>
- BAD:
- <br/><code><span style="color:red">if(debug)</span></code>
- </p>
- <p>
- Extra spacing (i.e., more than one space in a row) is okay if it
- improves alignment of equals signs or arrows (<code><-</code>).
- </p>
-<pre>plot(x = x.coord,
- y = data.mat[, MakeColName(metric, ptiles[1], "roiOpt")],
- ylim = ylim,
- xlab = "dates",
- ylab = metric,
- main = (paste(metric, " for 3 samples ", sep = "")))
-</pre>
- <p>
- Do not place spaces around code in parentheses or square brackets.
- <br/><em> Exception: Always place a space after a comma.</em>
- </p>
- <p>
- GOOD:</p><pre>if (debug)
-x[1, ]</pre>
- <p>
- BAD:</p><pre><span style="color:red">if ( debug ) # No spaces around debug
-x[1,] # Needs a space after the comma </span></pre>
-
- <h4 id="curlybraces">Curly Braces</h4>
- <p>
- An opening curly brace should never go on its own line; a closing
- curly brace should always go on its own line. You may omit curly
- braces when a block consists of a single statement; however, you
- must <em>consistently</em> either use or not use curly braces for
- single statement blocks.
- </p>
- <pre>
-if (is.null(ylim)) {
- ylim <- c(0, 0.06)
-}</pre>
- <p>
- xor (but not both)
- </p>
- <pre>
-if (is.null(ylim))
- ylim <- c(0, 0.06)</pre>
- <p>
- Always begin the body of a block on a new line.
- </p>
- <p>
- BAD:
- <br/><code><span style="color:red"> if (is.null(ylim))
- ylim <- c(0, 0.06)</span></code>
- <br/><code><span style="color:red"> if (is.null(ylim))
- {ylim <- c(0, 0.06)} </span></code>
- </p>
-
- <h4 id="else">Surround else with braces</h4>
- <p>
- An <code>else</code> statement should always be surrounded on the
- same line by curly braces.</p>
- <pre>
-if (condition) {
- one or more lines
-} else {
- one or more lines
-}
-</pre>
- <p>
- BAD:<br/>
- </p>
- <pre style="color:red">
-if (condition) {
- one or more lines
-}
-else {
- one or more lines
-}
-</pre>
- <p>
- BAD:<br/>
- </p>
- <pre style="color:red">
-if (condition)
- one line
-else
- one line
-</pre>
-
- <h4 id="assignment">Assignment</h4>
- <p>
- Use <code><-</code>, not <code>=</code>, for assignment.
- </p>
- <p>
- GOOD:
- <br/><code> x <- 5 </code>
- </p>
- <p>
- BAD:
- <br/><code><span style="color:red"> x = 5</span></code>
- </p>
- <h4 id="semicolons">Semicolons</h4>
- <p>
- Do not terminate your lines with semicolons or use semicolons to
- put more than one command on the same line. (Semicolons are not
- necessary, and are omitted for consistency with other Google style
- guides.)
- </p>
-
-
- <h3> Organization </h3>
- <h4 id="generallayout">General Layout and Ordering</h4>
- <p>
- If everyone uses the same general ordering, we'll be able to
- read and understand each other's scripts faster and more easily.
- </p>
- <ol>
- <li>Copyright statement comment </li>
- <li>Author comment</li>
- <li>File description comment, including purpose of
- program, inputs, and outputs</li>
- <li><code>source()</code> and <code>library()</code> statements</li>
- <li>Function definitions</li>
- <li>Executed statements, if applicable (e.g.,
- <code> print</code>, <code>plot</code>)</li>
- </ol>
- <p>
- Unit tests should go in a separate file named
- <code>originalfilename_test.R</code>.
- </p>
- <h4 id="comments">Commenting Guidelines</h4>
- <p>
- Comment your code. Entire commented lines should begin with
- <code>#</code> and one space.
- </p>
- <p>
- Short comments can be placed after code preceded by two spaces,
- <code>#</code>, and then one space.
- </p>
-<pre># Create histogram of frequency of campaigns by pct budget spent.
-hist(df$pct.spent,
- breaks = "scott", # method for choosing number of buckets
- main = "Histogram: fraction budget spent by campaignid",
- xlab = "Fraction of budget spent",
- ylab = "Frequency (count of campaignids)")
-</pre>
- <h4 id="functiondefinition">Function Definitions and
- Calls</h4>
- <p>
- Function definitions should first list arguments without default
- values, followed by those with default values.
- </p>
- <p>
- In both function definitions and function calls, multiple
- arguments per line are allowed; line breaks are only allowed
- between assignments.
- <br/>GOOD:
- </p>
-<pre>PredictCTR <- function(query, property, num.days,
- show.plot = TRUE)
-</pre>
- BAD:
-<pre><span style="color:red">PredictCTR <- function(query, property, num.days, show.plot =
- TRUE)
-</span></pre>
- <p> Ideally, unit tests should serve as sample function calls (for
- shared library routines).
- </p>
- <h4 id="functiondocumentation">Function Documentation</h4>
- <p> Functions should contain a comments section immediately below
- the function definition line. These comments should consist of a
- one-sentence description of the function; a list of the function's
- arguments, denoted by <code>Args:</code>, with a description of
- each (including the data type); and a description of the return
- value, denoted by <code>Returns:</code>. The comments should be
- descriptive enough that a caller can use the function without
- reading any of the function's code.
- </p>
-
- <h4 id="examplefunction">Example Function</h4>
-<pre>
-CalculateSampleCovariance <- function(x, y, verbose = TRUE) {
- # Computes the sample covariance between two vectors.
- #
- # Args:
- # x: One of two vectors whose sample covariance is to be calculated.
- # y: The other vector. x and y must have the same length, greater than one,
- # with no missing values.
- # verbose: If TRUE, prints sample covariance; if not, not. Default is TRUE.
- #
- # Returns:
- # The sample covariance between x and y.
- n <- length(x)
- # Error handling
- if (n <= 1 || n != length(y)) {
- stop("Arguments x and y have different lengths: ",
- length(x), " and ", length(y), ".")
- }
- if (TRUE %in% is.na(x) || TRUE %in% is.na(y)) {
- stop(" Arguments x and y must not have missing values.")
- }
- covariance <- var(x, y)
- if (verbose)
- cat("Covariance = ", round(covariance, 4), ".\n", sep = "")
- return(covariance)
-}
-</pre>
-
-<h4 id="todo">TODO Style</h4>
-
-<p>
- Use a consistent style for TODOs throughout your code.
- <br/><code>TODO(username): Explicit description of action to
- be taken</code>
-</p>
-
-
- <h3> Language </h3>
-
- <h4 id="attach">Attach</h4>
- <p> The possibilities for creating errors when using
- <code>attach</code> are numerous. Avoid it.</p>
- <h4 id="functionlanguage">Functions</h4>
- <p> Errors should be raised using <code>stop()</code>.</p>
- <h4 id="object">Objects and Methods</h4>
- <p> The S language has two object systems, S3 and S4, both of which
- are available in R. S3 methods are more interactive and flexible,
- whereas S4 methods are more formal and rigorous. (For an illustration
- of the two systems, see Thomas Lumley's
- "Programmer's Niche: A Simple
- Class, in S3 and S4" in R News 4/1, 2004, pgs. 33 - 36:
- <a href="https://cran.r-project.org/doc/Rnews/Rnews_2004-1.pdf">
- https://cran.r-project.org/doc/Rnews/Rnews_2004-1.pdf</a>.)
- </p>
- <p>Use S3 objects and methods unless there is a strong reason to use
- S4 objects or methods. A primary justification for an S4 object
- would be to use objects directly in C++ code. A primary
- justification for an S4 generic/method would be to dispatch on two
- arguments.
- </p>
- <p>Avoid mixing S3 and S4: S4 methods ignore S3 inheritance and
- vice-versa.
- </p>
-
-
- <h3>Exceptions</h3>
-
-<p>
- The coding conventions described above should be followed, unless
- there is good reason to do otherwise. Exceptions include legacy
- code and modifying third-party code.
-</p>
-
-
-<h3>Parting Words</h3>
-
-<p>
- Use common sense and BE CONSISTENT.
-</p>
- <p>
- If you are editing code, take a few minutes to look at the code around
- you and determine its style. If others use spaces around their
- <code>if </code>
- clauses, you should, too. If their comments have little boxes of stars
- around them, make your comments have little boxes of stars around them,
- too.
- </p>
- <p>
- The point of having style guidelines is to have a common vocabulary of
- coding so people can concentrate on <em>what</em> you are saying,
- rather than on <em>how</em> you are saying it. We present global style
- rules here so people
- know the vocabulary. But local style is also important. If code you add
- to a file looks drastically different from the existing code around it,
- the discontinuity will throw readers out of their rhythm when they go to
- read it. Try to avoid this.
- </p>
-
- <p>
- OK, enough writing about writing code; the code itself is much more
- interesting. Have fun!
- </p>
-
-
- <h3>References</h3>
-
- <p>
- <a href="http://www.maths.lth.se/help/R/RCC/">
- http://www.maths.lth.se/help/R/RCC/</a> - R Coding Conventions
- </p>
- <p>
- <a href="http://ess.r-project.org/">http://ess.r-project.org/</a> - For
- emacs users. This runs R in your emacs and has an emacs mode.
- </p>
-
</body>
-
</html>
diff --git a/cppguide.html b/cppguide.html
index 590cc9f..bbf1f64 100644
--- a/cppguide.html
+++ b/cppguide.html
@@ -1,20 +1,19 @@
<!DOCTYPE html>
-<html>
+<html lang="en">
<head>
-<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+<meta charset="utf-8">
<title>Google C++ Style Guide</title>
-<link rel="stylesheet" type="text/css" href="include/styleguide.css">
-<script language="javascript" src="include/styleguide.js"></script>
-<link rel="shortcut icon" type="image/x-icon" href="https://www.google.com/favicon.ico" />
+<link rel="stylesheet" href="include/styleguide.css">
+<script src="include/styleguide.js"></script>
+<link rel="shortcut icon" href="https://www.google.com/favicon.ico">
</head>
<body onload="initStyleGuide();">
<div id="content">
<h1>Google C++ Style Guide</h1>
<div class="horizontal_toc" id="tocDiv"></div>
-
<div class="main_body">
-<h2 class="ignoreLink" id="Background">Background</h2>
+<h2 id="Background" class="ignoreLink">Background</h2>
<p>C++ is one of the main development languages used by
many of Google's open-source projects. As every C++
@@ -23,8 +22,8 @@
code more bug-prone and harder to read and maintain.</p>
<p>The goal of this guide is to manage this complexity by
-describing in detail the dos and don'ts of writing C++ code.
-These rules exist to
+describing in detail the dos and don'ts of writing C++ code
+. These rules exist to
keep the code base manageable while still allowing
coders to use C++ language features productively.</p>
@@ -40,13 +39,11 @@
-
-
<p>Note that this guide is not a C++ tutorial: we assume that
the reader is familiar with the language. </p>
<h3 id="Goals">Goals of the Style Guide</h3>
-<div class="stylebody">
+
<p>Why do we have this document?</p>
<p>There are a few core goals that we believe this guide should
@@ -126,7 +123,7 @@
implementation are multiplied widely by usage, and the cost in understanding
the complexity does not need to be paid again when working with new
portions of the codebase. When in doubt, waivers to rules of this type
-can be sought by asking
+can be sought by asking
your project leads. This is specifically
important for our codebase because code ownership and team membership
changes over time: even if everyone that works with some piece of code
@@ -158,9 +155,22 @@
unsure, please don't hesitate to ask your project leads to get additional
input.</p>
-</div>
-
+
+<h2 id="C++_Version">C++ Version</h2>
+
+<p>Currently, code should target C++17, i.e., should not use C++2x
+ features. The C++ version targeted by this guide will advance
+ (aggressively) over time.</p>
+
+
+
+<p>Do not use
+ <a href="#Nonstandard_Extensions">non-standard extensions</a>.</p>
+
+ <div>Consider portability to other environments
+before using features from C++14 and C++17 in your project.
+</div>
<h2 id="Header_Files">Header Files</h2>
@@ -179,13 +189,10 @@
<a id="The_-inl.h_Files"></a>
<h3 id="Self_contained_Headers">Self-contained Headers</h3>
-<div class="summary">
<p>Header files should be self-contained (compile on their own) and
end in <code>.h</code>. Non-header files that are meant for inclusion
should end in <code>.inc</code> and be used sparingly.</p>
-</div>
-<div class="stylebody">
<p>All header files should be self-contained. Users and refactoring
tools should not have to adhere to special conditions to include the
header. Specifically, a header should
@@ -214,26 +221,23 @@
extension. Use sparingly, and prefer self-contained headers when
possible.</p>
-</div>
-
<h3 id="The__define_Guard">The #define Guard</h3>
-<div class="summary">
<p>All header files should have <code>#define</code> guards to
prevent multiple inclusion. The format of the symbol name
should be
+
<code><i><PROJECT></i>_<i><PATH></i>_<i><FILE></i>_H_</code>.</p>
-</div>
-
-<div class="stylebody">
+<div>
<p>To guarantee uniqueness, they should
be based on the full path in a project's source tree. For
example, the file <code>foo/src/bar/baz.h</code> in
project <code>foo</code> should have the following
guard:</p>
+</div>
<pre>#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_
@@ -245,24 +249,16 @@
-
-</div>
-
<h3 id="Forward_Declarations">Forward Declarations</h3>
-<div class="summary">
- <p>Avoid using forward declarations where possible.
- Just <code>#include</code> the headers you need.</p>
-</div>
+<p>Avoid using forward declarations where possible.
+Instead, <code>#include</code> the headers you need.</p>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>A "forward declaration" is a declaration of a class,
function, or template without an associated definition.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>Forward declarations can save compile time, as
<code>#include</code>s force the compiler to open
@@ -273,9 +269,8 @@
your code to be recompiled more often, due to unrelated
changes in the header.</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Forward declarations can hide a dependency, allowing
user code to skip necessary recompilation when headers
@@ -319,11 +314,10 @@
(e.g. using pointer members instead of object members)
can make the code slower and more complex.</li>
-
-</ul>
-</div>
-<div class="decision">
+</ul>
+
+<p class="decision"></p>
<ul>
<li>Try to avoid forward declarations of entities
defined in another project.</li>
@@ -337,33 +331,24 @@
<p>Please see <a href="#Names_and_Order_of_Includes">Names and Order
of Includes</a> for rules about when to #include a header.</p>
-</div>
-
-</div>
<h3 id="Inline_Functions">Inline Functions</h3>
-<div class="summary">
<p>Define functions inline only when they are small, say, 10
lines or fewer.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>You can declare functions in a way that allows the compiler to expand
them inline rather than calling them through the usual
function call mechanism.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Inlining a function can generate more efficient object
code, as long as the inlined function is small. Feel free
to inline accessors and mutators, and other short,
performance-critical functions.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Overuse of inlining can actually make programs slower.
Depending on a function's size, inlining it can cause the
code size to increase or decrease. Inlining a very small
@@ -371,9 +356,8 @@
inlining a very large function can dramatically increase
code size. On modern processors smaller code usually runs
faster due to better use of the instruction cache.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>A decent rule of thumb is to not inline a function if
it is more than 10 lines long. Beware of destructors,
which are often longer than they appear because of
@@ -392,23 +376,18 @@
place its definition in the class, either for convenience
or to document its behavior, e.g., for accessors and
mutators.</p>
-</div>
-
-</div>
<h3 id="Names_and_Order_of_Includes">Names and Order of Includes</h3>
-<div class="summary">
-<p>Use standard order for readability and to avoid hidden
-dependencies: Related header, C library, C++ library, other libraries'
-<code>.h</code>, your project's <code>.h</code>.</p>
-</div>
+<p>Include headers in the following order: Related header, C system headers,
+C++ standard library headers,
+other libraries' headers, your project's
+headers.</p>
-<div class="stylebody">
<p>
All of a project's header files should be
listed as descendants of the project's source
-directory without use of UNIX directory shortcuts
+directory without use of UNIX directory aliases
<code>.</code> (the current directory) or <code>..</code>
(the parent directory). For example,
@@ -427,19 +406,31 @@
<ol>
<li><code><var>dir2/foo2</var>.h</code>.</li>
- <li>C system files.</li>
+ <li>A blank line</li>
- <li>C++ system files.</li>
+ <li>C system headers (more precisely: headers in angle brackets with the
+ <code>.h</code> extension), e.g. <code><unistd.h></code>,
+ <code><stdlib.h></code>.</li>
- <li>Other libraries' <code>.h</code>
- files.</li>
+ <li>A blank line</li>
+
+ <li>C++ standard library headers (without file extension), e.g.
+ <code><algorithm></code>, <code><cstddef></code>.</li>
+
+ <li>A blank line</li>
+
+ <div>
+ <li>Other libraries' <code>.h</code> files.</li>
+ </div>
<li>
Your project's <code>.h</code>
files.</li>
</ol>
-<p>With the preferred ordering, if
+<p>Separate each non-empty group with one blank line.</p>
+
+<p>With the preferred ordering, if the related header
<code><var>dir2/foo2</var>.h</code> omits any necessary
includes, the build of <code><var>dir/foo</var>.cc</code>
or <code><var>dir/foo</var>_test.cc</code> will break.
@@ -455,6 +446,11 @@
+<p>Note that the C headers such as <code>stddef.h</code>
+are essentially interchangeable with their C++ counterparts
+(<code>cstddef</code>).
+Either style is acceptable, but prefer consistency with existing code.</p>
+
<p>Within each section the includes should be ordered
alphabetically. Note that older code might not conform to
this rule and should be fixed when convenient.</p>
@@ -465,23 +461,19 @@
don't count on the fact that you included <code>foo.h</code> which
(currently) includes <code>bar.h</code>: include <code>bar.h</code>
yourself, unless <code>foo.h</code> explicitly demonstrates its intent
-to provide you the symbols of <code>bar.h</code>. However, any
-includes present in the related header do not need to be included
-again in the related <code>cc</code> (i.e., <code>foo.cc</code> can
-rely on <code>foo.h</code>'s includes).</p>
+to provide you the symbols of <code>bar.h</code>.</p>
<p>For example, the includes in
<code>google-awesome-project/src/foo/internal/fooserver.cc</code>
might look like this:</p>
-
<pre>#include "foo/server/fooserver.h"
#include <sys/types.h>
#include <unistd.h>
-#include <hash_map>
+#include <string>
#include <vector>
#include "base/basictypes.h"
@@ -489,7 +481,9 @@
#include "foo/server/bar.h"
</pre>
-<p class="exception">Sometimes, system-specific code needs
+<p><b>Exception:</b></p>
+
+<p>Sometimes, system-specific code needs
conditional includes. Such code can put conditional
includes after other includes. Of course, keep your
system-specific code small and localized. Example:</p>
@@ -503,13 +497,10 @@
#endif // LANG_CXX11
</pre>
-</div>
-
<h2 id="Scoping">Scoping</h2>
<h3 id="Namespaces">Namespaces</h3>
-<div class="summary">
<p>With few exceptions, place code in a namespace. Namespaces
should have unique names based on the project name, and possibly
its path. Do not use <i>using-directives</i> (e.g.
@@ -517,17 +508,13 @@
inline namespaces. For unnamed namespaces, see
<a href="#Unnamed_Namespaces_and_Static_Variables">Unnamed Namespaces and
Static Variables</a>.
-</p></div>
-<div class="stylebody">
-
-<div class="definition">
+</p><p class="definition"></p>
<p>Namespaces subdivide the global scope
into distinct, named scopes, and so are useful for preventing
name collisions in the global scope.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Namespaces provide a method for preventing name conflicts
in large programs while allowing most code to use reasonably
@@ -545,20 +532,19 @@
the enclosing scope. Consider the following snippet, for
example:</p>
-<pre>namespace X {
-inline namespace Y {
+<pre class="neutralcode">namespace outer {
+inline namespace inner {
void foo();
-} // namespace Y
-} // namespace X
+} // namespace inner
+} // namespace outer
</pre>
-<p>The expressions <code>X::Y::foo()</code> and
-<code>X::foo()</code> are interchangeable. Inline
+<p>The expressions <code>outer::inner::foo()</code> and
+<code>outer::foo()</code> are interchangeable. Inline
namespaces are primarily intended for ABI compatibility
across versions.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Namespaces can be confusing, because they complicate
the mechanics of figuring out what definition a name refers
@@ -572,9 +558,8 @@
<p>In some contexts, it's necessary to repeatedly refer to
symbols by their fully-qualified names. For deeply-nested
namespaces, this can add a lot of clutter.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Namespaces should be used as follows:</p>
@@ -584,7 +569,7 @@
</li><li>
<p>Namespaces wrap the entire source file after
- includes,
+ includes,
<a href="https://gflags.github.io/gflags/">
gflags</a> definitions/declarations
and forward declarations of classes from other namespaces.</p>
@@ -619,19 +604,27 @@
<pre>#include "a.h"
-DEFINE_FLAG(bool, someflag, false, "dummy flag");
+ABSL_FLAG(bool, someflag, false, "dummy flag");
-namespace a {
+namespace mynamespace {
-using ::foo::bar;
+using ::foo::Bar;
-...code for a... // Code goes against the left margin.
+...code for mynamespace... // Code goes against the left margin.
-} // namespace a
+} // namespace mynamespace
</pre>
</li>
-
+ <li>To place generated protocol
+ message code in a namespace, use the
+ <code>package</code> specifier in the
+ <code>.proto</code> file. See
+
+
+ <a href="https://developers.google.com/protocol-buffers/docs/reference/cpp-generated#package">
+ Protocol Buffer Packages</a>
+ for details.</li>
<li>Do not declare anything in namespace
<code>std</code>, including forward declarations of
@@ -674,30 +667,23 @@
</li><li>Do not use inline namespaces.</li>
</ul>
-</div>
-</div>
<h3 id="Unnamed_Namespaces_and_Static_Variables">Unnamed Namespaces and Static
Variables</h3>
-<div class="summary">
<p>When definitions in a <code>.cc</code> file do not need to be
referenced outside that file, place them in an unnamed
namespace or declare them <code>static</code>. Do not use either
of these constructs in <code>.h</code> files.
-</p></div>
-<div class="stylebody">
-
-<div class="definition">
-<p>All declarations can be given internal linkage by placing them in
-unnamed namespaces, and functions and variables can be given internal linkage by
+</p><p class="definition"></p>
+<p>All declarations can be given internal linkage by placing them in unnamed
+namespaces. Functions and variables can also be given internal linkage by
declaring them <code>static</code>. This means that anything you're declaring
-can't be accessed from another file. If a different file declares something
-with the same name, then the two entities are completely independent.</p>
-</div>
+can't be accessed from another file. If a different file declares something with
+the same name, then the two entities are completely independent.</p>
-<div class="decision">
+<p class="decision"></p>
<p>Use of internal linkage in <code>.cc</code> files is encouraged
for all code that does not need to be referenced elsewhere.
@@ -710,76 +696,44 @@
...
} // namespace
</pre>
-</div>
-</div>
<h3 id="Nonmember,_Static_Member,_and_Global_Functions">Nonmember, Static Member, and Global Functions</h3>
-<div class="summary">
<p>Prefer placing nonmember functions in a namespace; use completely global
-functions rarely. Prefer grouping functions with a namespace instead of
-using a class as if it were a namespace. Static methods of a class should
-generally be closely related to instances of the class or the class's static
-data.</p>
-</div>
+functions rarely. Do not use a class simply to group static functions. Static
+methods of a class should generally be closely related to instances of the
+class or the class's static data.</p>
- <div class="stylebody">
- <div class="pros">
- <p>Nonmember and static member functions can be useful in
- some situations. Putting nonmember functions in a
- namespace avoids polluting the global namespace.</p>
- </div>
+<p class="pros"></p>
+<p>Nonmember and static member functions can be useful in
+some situations. Putting nonmember functions in a
+namespace avoids polluting the global namespace.</p>
-<div class="cons">
+<p class="cons"></p>
<p>Nonmember and static member functions may make more sense
as members of a new class, especially if they access
external resources or have significant dependencies.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Sometimes it is useful to define a
function not bound to a class instance. Such a function
can be either a static member or a nonmember function.
Nonmember functions should not depend on external
variables, and should nearly always exist in a namespace.
-Rather than creating classes only to group static member
-functions which do not share static data, use
-<a href="#Namespaces">namespaces</a> instead. For a header
-<code>myproject/foo_bar.h</code>, for example, write</p>
-<pre>namespace myproject {
-namespace foo_bar {
-void Function1();
-void Function2();
-} // namespace foo_bar
-} // namespace myproject
-</pre>
-<p>instead of</p>
-<pre class="badcode">namespace myproject {
-class FooBar {
- public:
- static void Function1();
- static void Function2();
-};
-} // namespace myproject
-</pre>
+Do not create classes only to group static member functions;
+this is no different than just giving the function names a
+common prefix, and such grouping is usually unnecessary anyway.</p>
<p>If you define a nonmember function and it is only
needed in its <code>.cc</code> file, use
<a href="#Unnamed_Namespaces_and_Static_Variables">internal linkage</a> to limit
its scope.</p>
-</div>
-
-</div>
<h3 id="Local_Variables">Local Variables</h3>
-<div class="summary">
<p>Place a function's variables in the narrowest scope
possible, and initialize variables in the declaration.</p>
-</div>
-
-<div class="stylebody">
<p>C++ allows you to declare variables anywhere in a
function. We encourage you to declare them in as local a
@@ -833,89 +787,286 @@
}
</pre>
-</div>
-
<h3 id="Static_and_Global_Variables">Static and Global Variables</h3>
-<div class="summary">
- <p>Variables of class type with <a href="http://en.cppreference.com/w/cpp/language/storage_duration#Storage_duration">
- static storage duration</a> are forbidden: they cause hard-to-find bugs due
- to indeterminate order of construction and destruction. However, such
- variables are allowed if they are <code>constexpr</code>: they have no
- dynamic initialization or destruction.</p>
-</div>
+<p>Objects with
+<a href="http://en.cppreference.com/w/cpp/language/storage_duration#Storage_duration">
+static storage duration</a> are forbidden unless they are
+<a href="http://en.cppreference.com/w/cpp/types/is_destructible">trivially
+destructible</a>. Informally this means that the destructor does not do
+anything, even taking member and base destructors into account. More formally it
+means that the type has no user-defined or virtual destructor and that all bases
+and non-static members are trivially destructible.
+Static function-local variables may use dynamic initialization.
+Use of dynamic initialization for static class member variables or variables at
+namespace scope is discouraged, but allowed in limited circumstances; see below
+for details.</p>
-<div class="stylebody">
+<p>As a rule of thumb: a global variable satisfies these requirements if its
+declaration, considered in isolation, could be <code>constexpr</code>.</p>
-<p>Objects with static storage duration, including global
-variables, static variables, static class member
-variables, and function static variables, must be Plain
-Old Data (POD): only ints, chars, floats, or pointers, or
-arrays/structs of POD.</p>
+<p class="definition"></p>
+<p>Every object has a <dfn>storage duration</dfn>, which correlates with its
+lifetime. Objects with static storage duration live from the point of their
+initialization until the end of the program. Such objects appear as variables at
+namespace scope ("global variables"), as static data members of classes, or as
+function-local variables that are declared with the <code>static</code>
+specifier. Function-local static variables are initialized when control first
+passes through their declaration; all other objects with static storage duration
+are initialized as part of program start-up. All objects with static storage
+duration are destroyed at program exit (which happens before unjoined threads
+are terminated).</p>
-<p>The order in which class constructors and initializers
-for static variables are called is only partially
-specified in C++ and can even change from build to build,
-which can cause bugs that are difficult to find.
-Therefore in addition to banning globals of class type,
-we do not allow non-local static variables to be initialized
-with the result of a function, unless that function (such
-as getenv(), or getpid()) does not itself depend on any
-other globals. However, a static POD variable within
-function scope may be initialized with the result of a
-function, since its initialization order is well-defined
-and does not occur until control passes through its
-declaration.</p>
+<p>Initialization may be <dfn>dynamic</dfn>, which means that something
+non-trivial happens during initialization. (For example, consider a constructor
+that allocates memory, or a variable that is initialized with the current
+process ID.) The other kind of initialization is <dfn>static</dfn>
+initialization. The two aren't quite opposites, though: static
+initialization <em>always</em> happens to objects with static storage duration
+(initializing the object either to a given constant or to a representation
+consisting of all bytes set to zero), whereas dynamic initialization happens
+after that, if required.</p>
-<p>Likewise, global and static variables are destroyed
-when the program terminates, regardless of whether the
-termination is by returning from <code>main()</code> or
-by calling <code>exit()</code>. The order in which
-destructors are called is defined to be the reverse of
-the order in which the constructors were called. Since
-constructor order is indeterminate, so is destructor
-order. For example, at program-end time a static variable
-might have been destroyed, but code still running
-— perhaps in another thread
-— tries to access it and fails. Or the
-destructor for a static <code>string</code> variable
-might be run prior to the destructor for another variable
-that contains a reference to that string.</p>
+<p class="pros"></p>
+<p>Global and static variables are very useful for a large number of
+applications: named constants, auxiliary data structures internal to some
+translation unit, command-line flags, logging, registration mechanisms,
+background infrastructure, etc.</p>
-<p>One way to alleviate the destructor problem is to
-terminate the program by calling
-<code>quick_exit()</code> instead of <code>exit()</code>.
-The difference is that <code>quick_exit()</code> does not
-invoke destructors and does not invoke any handlers that
-were registered by calling <code>atexit()</code>. If you
-have a handler that needs to run when a program
-terminates via <code>quick_exit()</code> (flushing logs,
-for example), you can register it using
-<code>at_quick_exit()</code>. (If you have a handler that
-needs to run at both <code>exit()</code> and
-<code>quick_exit()</code>, you need to register it in
-both places.)</p>
+<p class="cons"></p>
+<p>Global and static variables that use dynamic initialization or have
+non-trivial destructors create complexity that can easily lead to hard-to-find
+bugs. Dynamic initialization is not ordered across translation units, and
+neither is destruction (except that destruction
+happens in reverse order of initialization). When one initialization refers to
+another variable with static storage duration, it is possible that this causes
+an object to be accessed before its lifetime has begun (or after its lifetime
+has ended). Moreover, when a program starts threads that are not joined at exit,
+those threads may attempt to access objects after their lifetime has ended if
+their destructor has already run.</p>
-<p>As a result we only allow static variables to contain
-POD data. This rule completely disallows
-<code>std::vector</code> (use C arrays instead), or
-<code>string</code> (use <code>const char []</code>).</p>
+<p class="decision"></p>
+<h4>Decision on destruction</h4>
+
+<p>When destructors are trivial, their execution is not subject to ordering at
+all (they are effectively not "run"); otherwise we are exposed to the risk of
+accessing objects after the end of their lifetime. Therefore, we only allow
+objects with static storage duration if they are trivially destructible.
+Fundamental types (like pointers and <code>int</code>) are trivially
+destructible, as are arrays of trivially destructible types. Note that
+variables marked with <code>constexpr</code> are trivially destructible.</p>
+<pre>const int kNum = 10; // allowed
+
+struct X { int n; };
+const X kX[] = {{1}, {2}, {3}}; // allowed
+
+void foo() {
+ static const char* const kMessages[] = {"hello", "world"}; // allowed
+}
+
+// allowed: constexpr guarantees trivial destructor
+constexpr std::array<int, 3> kArray = {{1, 2, 3}};</pre>
+<pre class="badcode">// bad: non-trivial destructor
+const std::string kFoo = "foo";
+
+// bad for the same reason, even though kBar is a reference (the
+// rule also applies to lifetime-extended temporary objects)
+const std::string& kBar = StrCat("a", "b", "c");
+
+void bar() {
+ // bad: non-trivial destructor
+ static std::map<int, int> kData = {{1, 0}, {2, 0}, {3, 0}};
+}</pre>
+
+<p>Note that references are not objects, and thus they are not subject to the
+constraints on destructibility. The constraint on dynamic initialization still
+applies, though. In particular, a function-local static reference of the form
+<code>static T& t = *new T;</code> is allowed.</p>
+
+<h4>Decision on initialization</h4>
+
+<p>Initialization is a more complex topic. This is because we must not only
+consider whether class constructors execute, but we must also consider the
+evaluation of the initializer:</p>
+<pre class="neutralcode">int n = 5; // fine
+int m = f(); // ? (depends on f)
+Foo x; // ? (depends on Foo::Foo)
+Bar y = g(); // ? (depends on g and on Bar::Bar)
+</pre>
+
+<p>All but the first statement expose us to indeterminate initialization
+ordering.</p>
+
+<p>The concept we are looking for is called <em>constant initialization</em> in
+the formal language of the C++ standard. It means that the initializing
+expression is a constant expression, and if the object is initialized by a
+constructor call, then the constructor must be specified as
+<code>constexpr</code>, too:</p>
+<pre>struct Foo { constexpr Foo(int) {} };
+
+int n = 5; // fine, 5 is a constant expression
+Foo x(2); // fine, 2 is a constant expression and the chosen constructor is constexpr
+Foo a[] = { Foo(1), Foo(2), Foo(3) }; // fine</pre>
+
+<p>Constant initialization is always allowed. Constant initialization of
+static storage duration variables should be marked with <code>constexpr</code>
+or where possible the
+
+
+<a href="https://github.com/abseil/abseil-cpp/blob/03c1513538584f4a04d666be5eb469e3979febba/absl/base/attributes.h#L540">
+<code>ABSL_CONST_INIT</code></a>
+attribute. Any non-local static storage
+duration variable that is not so marked should be presumed to have
+dynamic initialization, and reviewed very carefully.</p>
+
+<p>By contrast, the following initializations are problematic:</p>
+
+<pre class="badcode">// Some declarations used below.
+time_t time(time_t*); // not constexpr!
+int f(); // not constexpr!
+struct Bar { Bar() {} };
+
+// Problematic initializations.
+time_t m = time(nullptr); // initializing expression not a constant expression
+Foo y(f()); // ditto
+Bar b; // chosen constructor Bar::Bar() not constexpr</pre>
+
+<p>Dynamic initialization of nonlocal variables is discouraged, and in general
+it is forbidden. However, we do permit it if no aspect of the program depends
+on the sequencing of this initialization with respect to all other
+initializations. Under those restrictions, the ordering of the initialization
+does not make an observable difference. For example:</p>
+<pre>int p = getpid(); // allowed, as long as no other static variable
+ // uses p in its own initialization</pre>
+
+<p>Dynamic initialization of static local variables is allowed (and common).</p>
-<p>If you need a static or global
-variable of a class type, consider initializing a pointer
-(which will never be freed), from either your main()
-function or from pthread_once(). Note that this must be a
-raw pointer, not a "smart" pointer, since the smart
-pointer's destructor will have the order-of-destructor
-issue that we are trying to avoid.</p>
+<h4>Common patterns</h4>
+
+<ul>
+ <li>Global strings: if you require a global or static string constant,
+ consider using a simple character array, or a char pointer to the first
+ element of a string literal. String literals have static storage duration
+ already and are usually sufficient.</li>
+ <li>Maps, sets, and other dynamic containers: if you require a static, fixed
+ collection, such as a set to search against or a lookup table, you cannot
+ use the dynamic containers from the standard library as a static variable,
+ since they have non-trivial destructors. Instead, consider a simple array of
+ trivial types, e.g. an array of arrays of ints (for a "map from int to
+ int"), or an array of pairs (e.g. pairs of <code>int</code> and <code>const
+ char*</code>). For small collections, linear search is entirely sufficient
+ (and efficient, due to memory locality); consider using the facilities from
+
+ <a href="https://github.com/abseil/abseil-cpp/blob/master/absl/algorithm/container.h">absl/algorithm/container.h</a>
+ for the standard operations. If necessary, keep the collection in sorted
+ order and use a binary search algorithm. If you do really prefer a dynamic
+ container from the standard library, consider using a function-local static
+ pointer, as described below.</li>
+ <li>Smart pointers (<code>unique_ptr</code>, <code>shared_ptr</code>): smart
+ pointers execute cleanup during destruction and are therefore forbidden.
+ Consider whether your use case fits into one of the other patterns described
+ in this section. One simple solution is to use a plain pointer to a
+ dynamically allocated object and never delete it (see last item).</li>
+ <li>Static variables of custom types: if you require static, constant data of
+ a type that you need to define yourself, give the type a trivial destructor
+ and a <code>constexpr</code> constructor.</li>
+ <li>If all else fails, you can create an object dynamically and never delete
+ it by using a function-local static pointer or reference (e.g. <code>static
+ const auto& impl = *new T(args...);</code>).</li>
+</ul>
+
+<h3 id="thread_local">thread_local Variables</h3>
+
+<p><code>thread_local</code> variables that aren't declared inside a function
+must be initialized with a true compile-time constant,
+and this must be enforced by using the
+<a href="https://github.com/abseil/abseil-cpp/blob/master/absl/base/attributes.h">
+<code>ABSL_CONST_INIT</code></a>
+attribute. Prefer
+<code>thread_local</code> over other ways of defining thread-local data.</p>
-</div>
+<p class="definition"></p>
+<p>Starting with C++11, variables can be declared with the
+<code>thread_local</code> specifier:</p>
+<pre>thread_local Foo foo = ...;
+</pre>
+<p>Such a variable is actually a collection of objects, so that when different
+threads access it, they are actually accessing different objects.
+<code>thread_local</code> variables are much like
+<a href="#Static_and_Global_Variables">static storage duration variables</a>
+in many respects. For instance, they can be declared at namespace scope,
+inside functions, or as static class members, but not as ordinary class
+members.</p>
+
+<p><code>thread_local</code> variable instances are initialized much like
+static variables, except that they must be initialized separately for each
+thread, rather than once at program startup. This means that
+<code>thread_local</code> variables declared within a function are safe, but
+other <code>thread_local</code> variables are subject to the same
+initialization-order issues as static variables (and more besides).</p>
+
+<p><code>thread_local</code> variable instances are destroyed when their thread
+terminates, so they do not have the destruction-order issues of static
+variables.</p>
+
+<p class="pros"></p>
+<ul>
+ <li>Thread-local data is inherently safe from races (because only one thread
+ can ordinarily access it), which makes <code>thread_local</code> useful for
+ concurrent programming.</li>
+ <li><code>thread_local</code> is the only standard-supported way of creating
+ thread-local data.</li>
+</ul>
+
+<p class="cons"></p>
+<ul>
+ <li>Accessing a <code>thread_local</code> variable may trigger execution of
+ an unpredictable and uncontrollable amount of other code.</li>
+ <li><code>thread_local</code> variables are effectively global variables,
+ and have all the drawbacks of global variables other than lack of
+ thread-safety.</li>
+ <li>The memory consumed by a <code>thread_local</code> variable scales with
+ the number of running threads (in the worst case), which can be quite large
+ in a program.</li>
+ <li>An ordinary class member cannot be <code>thread_local</code>.</li>
+ <li><code>thread_local</code> may not be as efficient as certain compiler
+ intrinsics.</li>
+</ul>
+
+<p class="decision"></p>
+ <p><code>thread_local</code> variables inside a function have no safety
+ concerns, so they can be used without restriction. Note that you can use
+ a function-scope <code>thread_local</code> to simulate a class- or
+ namespace-scope <code>thread_local</code> by defining a function or
+ static method that exposes it:</p>
+
+<pre>Foo& MyThreadLocalFoo() {
+ thread_local Foo result = ComplicatedInitialization();
+ return result;
+}
+</pre>
+
+<p><code>thread_local</code> variables at class or namespace scope must be
+initialized with a true compile-time constant (i.e. they must have no
+dynamic initialization). To enforce this, <code>thread_local</code> variables
+at class or namespace scope must be annotated with
+
+
+<a href="https://github.com/abseil/abseil-cpp/blob/master/absl/base/attributes.h">
+<code>ABSL_CONST_INIT</code></a>
+(or <code>constexpr</code>, but that should be rare):</p>
+
+<pre>ABSL_CONST_INIT thread_local Foo foo = ...;
+</pre>
+
+<p><code>thread_local</code> should be preferred over other mechanisms for
+defining thread-local data.</p>
<h2 id="Classes">Classes</h2>
@@ -925,19 +1076,14 @@
<h3 id="Doing_Work_in_Constructors">Doing Work in Constructors</h3>
-<div class="summary">
<p>Avoid virtual method calls in constructors, and avoid
initialization that can fail if you can't signal an error.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>It is possible to perform arbitrary initialization in the body
of the constructor.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>No need to worry about whether the class has been initialized or
not.</li>
@@ -947,9 +1093,7 @@
or algorithms.</li>
</ul>
-</div>
-
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>If the work calls virtual functions, these calls
will not get dispatched to the subclass
@@ -970,35 +1114,28 @@
is done in the constructor cannot easily be handed off to, for
example, another thread.</li>
</ul>
-</div>
-
-<div class="decision">
+<p class="decision"></p>
<p>Constructors should never call virtual functions. If appropriate
-for your code
-,
+for your code ,
terminating the program may be an appropriate error handling
response. Otherwise, consider a factory function
-or <code>Init()</code> method. Avoid <code>Init()</code> methods on objects with
+or <code>Init()</code> method as described in
+<a href="https://abseil.io/tips/42">TotW #42</a>
+.
+Avoid <code>Init()</code> methods on objects with
no other states that affect which public methods may be called
(semi-constructed objects of this form are particularly hard to work
with correctly).</p>
-</div>
-
-</div>
<a id="Explicit_Constructors"></a>
<h3 id="Implicit_Conversions">Implicit Conversions</h3>
-<div class="summary">
<p>Do not define implicit conversions. Use the <code>explicit</code>
keyword for conversion operators and single-argument
constructors.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>Implicit conversions allow an
object of one type (called the <dfn>source type</dfn>) to
be used where a different type (called the <dfn>destination
@@ -1031,21 +1168,22 @@
</pre>
This kind of code isn't technically an implicit conversion, but the
language treats it as one as far as <code>explicit</code> is concerned.
-</div>
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>Implicit conversions can make a type more usable and
expressive by eliminating the need to explicitly name a type
when it's obvious.</li>
<li>Implicit conversions can be a simpler alternative to
- overloading.</li>
+ overloading, such as when a single
+ function with a <code>string_view</code> parameter takes the
+ place of separate overloads for <code>std::string</code> and
+ <code>const char*</code>.</li>
<li>List initialization syntax is a concise and expressive
way of initializing objects.</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Implicit conversions can hide type-mismatch bugs, where the
destination type does not match the user's expectation, or
@@ -1071,9 +1209,8 @@
the destination type is implicit, particularly if the
list has only a single element.</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Type conversion operators, and constructors that are
callable with a single argument, must be marked
<code>explicit</code> in the class definition. As an
@@ -1081,47 +1218,47 @@
<code>explicit</code>, since they do not perform type
conversion. Implicit conversions can sometimes be necessary and
appropriate for types that are designed to transparently wrap other
-types. In that case, contact
+types. In that case, contact
your project leads to request
a waiver of this rule.</p>
<p>Constructors that cannot be called with a single argument
-should usually omit <code>explicit</code>. Constructors that
+may omit <code>explicit</code>. Constructors that
take a single <code>std::initializer_list</code> parameter should
also omit <code>explicit</code>, in order to support copy-initialization
(e.g. <code>MyType m = {1, 2};</code>).</p>
-</div>
-
-</div>
<h3 id="Copyable_Movable_Types">Copyable and Movable Types</h3>
<a id="Copy_Constructors"></a>
-<div class="summary">
-<p>Support copying and/or moving if these operations are clear and meaningful
-for your type. Otherwise, disable the implicitly generated special functions
-that perform copies and moves.
-</p></div>
-<div class="stylebody">
+<p>A class's public API must make clear whether the class is copyable,
+move-only, or neither copyable nor movable. Support copying and/or
+moving if these operations are clear and meaningful for your type.</p>
-<div class="definition">
-<p>A copyable type allows its objects to be initialized or assigned
-from any other object of the same type, without changing the value of the source.
-For user-defined types, the copy behavior is defined by the copy
-constructor and the copy-assignment operator.
-<code>string</code> is an example of a copyable type.</p>
-
+<p class="definition"></p>
<p>A movable type is one that can be initialized and assigned
-from temporaries (all copyable types are therefore movable).
+from temporaries.</p>
+
+<p>A copyable type is one that can be initialized or assigned from
+any other object of the same type (so is also movable by definition), with the
+stipulation that the value of the source does not change.
<code>std::unique_ptr<int></code> is an example of a movable but not
-copyable type. For user-defined types, the move behavior is defined by the move
-constructor and the move-assignment operator.</p>
+copyable type (since the value of the source
+<code>std::unique_ptr<int></code> must be modified during assignment to
+the destination). <code>int</code> and <code>std::string</code> are examples of
+movable types that are also copyable. (For <code>int</code>, the move and copy
+operations are the same; for <code>std::string</code>, there exists a move operation
+that is less expensive than a copy.)</p>
+
+<p>For user-defined types, the copy behavior is defined by the copy
+constructor and the copy-assignment operator. Move behavior is defined by the
+move constructor and the move-assignment operator, if they exist, or by the
+copy constructor and the copy-assignment operator otherwise.</p>
<p>The copy/move constructors can be implicitly invoked by the compiler
in some situations, e.g. when passing objects by value.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Objects of copyable and movable types can be passed and returned by value,
which makes APIs simpler, safer, and more general. Unlike when passing objects
by pointer or reference, there's no risk of confusion over ownership,
@@ -1148,9 +1285,8 @@
<p>Move operations allow the implicit and efficient transfer of
resources out of rvalue objects. This allows a plainer coding style
in some cases.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Some types do not need to be copyable, and providing copy
operations for such types can be confusing, nonsensical, or outright
incorrect. Types representing singleton objects (<code>Registerer</code>),
@@ -1166,65 +1302,93 @@
invocation easy to miss. This may cause confusion for programmers used to
languages where pass-by-reference is conventional or mandatory. It may also
encourage excessive copying, which can cause performance problems.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
-<p>Provide the copy and move operations if their meaning is clear to a casual
-user and the copying/moving does not incur unexpected costs. If you define a
-copy or move constructor, define the corresponding assignment operator, and
-vice-versa. If your type is copyable, do not define move operations unless they
-are significantly more efficient than the corresponding copy operations. If your
-type is not copyable, but the correctness of a move is obvious to users of the
-type, you may make the type move-only by defining both of the move operations.
-</p>
+<p>Every class's public interface must make clear which copy and move
+operations the class supports. This should usually take the form of explicitly
+declaring and/or deleting the appropriate operations in the <code>public</code>
+section of the declaration.</p>
-<p>If your type provides copy operations, it is recommended that you design
-your class so that the default implementation of those operations is correct.
-Remember to review the correctness of any defaulted operations as you would any
-other code, and to document that your class is copyable and/or cheaply movable
-if that's an API guarantee.</p>
+<p>Specifically, a copyable class should explicitly declare the copy
+operations, a move-only class should explicitly declare the move operations,
+and a non-copyable/movable class should explicitly delete the copy operations.
+Explicitly declaring or deleting all four copy/move operations is permitted,
+but not required. If you provide a copy or move assignment operator, you
+must also provide the corresponding constructor.</p>
-<pre class="badcode">class Foo {
+<pre>class Copyable {
public:
- Foo(Foo&& other) : field_(other.field) {}
- // Bad, defines only move constructor, but not operator=.
+ Copyable(const Copyable& other) = default;
+ Copyable& operator=(const Copyable& other) = default;
- private:
- Field field_;
+ // The implicit move operations are suppressed by the declarations above.
+};
+
+class MoveOnly {
+ public:
+ MoveOnly(MoveOnly&& other);
+ MoveOnly& operator=(MoveOnly&& other);
+
+ // The copy operations are implicitly deleted, but you can
+ // spell that out explicitly if you want:
+ MoveOnly(const MoveOnly&) = delete;
+ MoveOnly& operator=(const MoveOnly&) = delete;
+};
+
+class NotCopyableOrMovable {
+ public:
+ // Not copyable or movable
+ NotCopyableOrMovable(const NotCopyableOrMovable&) = delete;
+ NotCopyableOrMovable& operator=(const NotCopyableOrMovable&)
+ = delete;
+
+ // The move operations are implicitly disabled, but you can
+ // spell that out explicitly if you want:
+ NotCopyableOrMovable(NotCopyableOrMovable&&) = delete;
+ NotCopyableOrMovable& operator=(NotCopyableOrMovable&&)
+ = delete;
};
</pre>
-<p>Due to the risk of slicing, avoid providing an assignment
-operator or public copy/move constructor for a class that's
-intended to be derived from (and avoid deriving from a class
+<p>These declarations/deletions can be omitted only if they are obvious:
+</p><ul>
+<li>If the class has no <code>private</code> section, like a
+ <a href="#Structs_vs._Classes">struct</a> or an interface-only base class,
+ then the copyability/movability can be determined by the
+ copyability/movability of any public data members.
+</li><li>If a base class clearly isn't copyable or movable, derived classes
+ naturally won't be either. An interface-only base class that leaves these
+ operations implicit is not sufficient to make concrete subclasses clear.
+</li><li>Note that if you explicitly declare or delete either the constructor or
+ assignment operation for copy, the other copy operation is not obvious and
+ must be declared or deleted. Likewise for move operations.
+</li></ul>
+
+<p>A type should not be copyable/movable if the meaning of
+copying/moving is unclear to a casual user, or if it incurs unexpected
+costs. Move operations for copyable types are strictly a performance
+optimization and are a potential source of bugs and complexity, so
+avoid defining them unless they are significantly more efficient than
+the corresponding copy operations. If your type provides copy operations, it is
+recommended that you design your class so that the default implementation of
+those operations is correct. Remember to review the correctness of any
+defaulted operations as you would any other code.</p>
+
+<p>Due to the risk of slicing, prefer to avoid providing a public assignment
+operator or copy/move constructor for a class that's
+intended to be derived from (and prefer to avoid deriving from a class
with such members). If your base class needs to be
copyable, provide a public virtual <code>Clone()</code>
method, and a protected copy constructor that derived classes
can use to implement it.</p>
-<p>If you do not want to support copy/move operations on your type,
-explicitly disable them using <code>= delete</code> in
-the <code>public:</code> section:</p>
-<pre class="code">// MyClass is neither copyable nor movable.
-MyClass(const MyClass&) = delete;
-MyClass& operator=(const MyClass&) = delete;
-</pre>
-
-<p></p>
-
-</div>
-</div>
<h3 id="Structs_vs._Classes">Structs vs. Classes</h3>
-<div class="summary">
<p>Use a <code>struct</code> only for passive objects that
carry data; everything else is a <code>class</code>.</p>
-</div>
-
-<div class="stylebody">
<p>The <code>struct</code> and <code>class</code>
keywords behave almost identically in C++. We add our own
@@ -1232,51 +1396,67 @@
appropriate keyword for the data-type you're
defining.</p>
-<p><code>structs</code> should be used for passive
-objects that carry data, and may have associated
-constants, but lack any functionality other than
-access/setting the data members. The accessing/setting of
-fields is done by directly accessing the fields rather
-than through method invocations. Methods should not
-provide behavior but should only be used to set up the
-data members, e.g., constructor, destructor,
-<code>Initialize()</code>, <code>Reset()</code>,
-<code>Validate()</code>.</p>
+<p><code>structs</code> should be used for passive objects that carry
+data, and may have associated constants, but lack any functionality
+other than access/setting the data members. All fields must be public,
+and accessed directly rather than through getter/setter methods. The
+struct must not have invariants that imply relationships between
+different fields, since direct user access to those fields may break
+those invariants. Methods should not provide behavior but should only
+be used to set up the data members, e.g., constructor, destructor,
+<code>Initialize()</code>, <code>Reset()</code>.</p>
-<p>If more functionality is required, a
+<p>If more functionality or invariants are required, a
<code>class</code> is more appropriate. If in doubt, make
it a <code>class</code>.</p>
<p>For consistency with STL, you can use
<code>struct</code> instead of <code>class</code> for
-functors and traits.</p>
+stateless types, such as traits,
+<a href="#Template_metaprogramming">template metafunctions</a>,
+and some functors.</p>
<p>Note that member variables in structs and classes have
<a href="#Variable_Names">different naming rules</a>.</p>
-</div>
+<h3 id="Structs_vs._Tuples">Structs vs. Pairs and Tuples</h3>
+<p>Prefer to use a <code>struct</code> instead of a pair or a
+tuple whenever the elements can have meaningful names.</p>
+
+<p>
+ While using pairs and tuples can avoid the need to define a custom type,
+ potentially saving work when <em>writing</em> code, a meaningful field
+ name will almost always be much clearer when <em>reading</em> code than
+ <code>.first</code>, <code>.second</code>, or <code>std::get<X></code>.
+ While C++14's introduction of <code>std::get<Type></code> to access a
+ tuple element by type rather than index (when the type is unique) can
+ sometimes partially mitigate this, a field name is usually substantially
+ clearer and more informative than a type.
+</p>
+
+<p>
+ Pairs and tuples may be appropriate in generic code where there are not
+ specific meanings for the elements of the pair or tuple. Their use may
+ also be required in order to interoperate with existing code or APIs.
+</p>
+
+<a id="Multiple_Inheritance"></a>
<h3 id="Inheritance">Inheritance</h3>
-<div class="summary">
<p>Composition is often more appropriate than inheritance.
When using inheritance, make it <code>public</code>.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> When a sub-class
inherits from a base class, it includes the definitions
-of all the data and operations that the parent base class
-defines. In practice, inheritance is used in two major
-ways in C++: implementation inheritance, in which actual
-code is inherited by the child, and
-<a href="#Interfaces">interface inheritance</a>, in which
-only method names are inherited.</p>
-</div>
+of all the data and operations that the base class
+defines. "Interface inheritance" is inheritance from a
+pure abstract base class (one with no state or defined
+methods); all other inheritance is "implementation
+inheritance".</p>
-<div class="pros">
+<p class="pros"></p>
<p>Implementation inheritance reduces code size by re-using
the base class code as it specializes an existing type.
Because inheritance is a compile-time declaration, you
@@ -1286,20 +1466,24 @@
API. Again, the compiler can detect errors, in this case,
when a class does not define a necessary method of the
API.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>For implementation inheritance, because the code
implementing a sub-class is spread between the base and
the sub-class, it can be more difficult to understand an
implementation. The sub-class cannot override functions
that are not virtual, so the sub-class cannot change
-implementation. The base class may also define some data
-members, so that specifies physical layout of the base
-class.</p>
-</div>
+implementation.</p>
-<div class="decision">
+<p>Multiple inheritance is especially problematic, because
+it often imposes a higher performance overhead (in fact,
+the performance drop from single inheritance to multiple
+inheritance can often be greater than the performance
+drop from ordinary to virtual dispatch), and because
+it risks leading to "diamond" inheritance patterns,
+which are prone to ambiguity, confusion, and outright bugs.</p>
+
+<p class="decision"></p>
<p>All inheritance should be <code>public</code>. If you
want to do private inheritance, you should be including
@@ -1312,23 +1496,15 @@
that <code>Bar</code> "is a kind of"
<code>Foo</code>.</p>
-<p>Make your destructor <code>virtual</code> if
-necessary. If your class has virtual methods, its
-destructor should be virtual.</p>
-
<p>Limit the use of <code>protected</code> to those
member functions that might need to be accessed from
subclasses. Note that <a href="#Access_Control">data
members should be private</a>.</p>
-<p>Explicitly annotate overrides of virtual functions
-or virtual destructors with an <code>override</code>
-or (less frequently) <code>final</code> specifier.
-Older (pre-C++11) code will use the
-<code>virtual</code> keyword as an inferior
-alternative annotation. For clarity, use exactly one of
-<code>override</code>, <code>final</code>, or
-<code>virtual</code> when declaring an override.
+<p>Explicitly annotate overrides of virtual functions or virtual
+destructors with exactly one of an <code>override</code> or (less
+frequently) <code>final</code> specifier. Do not
+use <code>virtual</code> when declaring an override.
Rationale: A function or destructor marked
<code>override</code> or <code>final</code> that is
not an override of a base class virtual function will
@@ -1337,132 +1513,15 @@
present, the reader has to check all ancestors of the
class in question to determine if the function or
destructor is virtual or not.</p>
-</div>
-</div>
-
-<h3 id="Multiple_Inheritance">Multiple Inheritance</h3>
-
-<div class="summary">
-<p>Only very rarely is multiple implementation inheritance
-actually useful. We allow multiple inheritance only when at
-most one of the base classes has an implementation; all
-other base classes must be <a href="#Interfaces">pure
-interface</a> classes tagged with the
-<code>Interface</code> suffix.</p>
-</div>
-
-<div class="stylebody">
-
-<div class="definition">
-<p>Multiple inheritance allows a sub-class to have more than
-one base class. We distinguish between base classes that are
-<em>pure interfaces</em> and those that have an
-<em>implementation</em>.</p>
-</div>
-
-<div class="pros">
-<p>Multiple implementation inheritance may let you re-use
-even more code than single inheritance (see <a href="#Inheritance">Inheritance</a>).</p>
-</div>
-
-<div class="cons">
-<p>Only very rarely is multiple <em>implementation</em>
-inheritance actually useful. When multiple implementation
-inheritance seems like the solution, you can usually find
-a different, more explicit, and cleaner solution.</p>
-</div>
-
-<div class="decision">
-<p> Multiple inheritance is allowed only when all
-superclasses, with the possible exception of the first one,
-are <a href="#Interfaces">pure interfaces</a>. In order to
-ensure that they remain pure interfaces, they must end with
-the <code>Interface</code> suffix.</p>
-</div>
-
-<div class="note">
-<p>There is an <a href="#Windows_Code">exception</a> to
-this rule on Windows.</p>
-</div>
-
-</div>
-
-<h3 id="Interfaces">Interfaces</h3>
-
-<div class="summary">
-<p>Classes that satisfy certain conditions are allowed, but
-not required, to end with an <code>Interface</code> suffix.</p>
-</div>
-
-<div class="stylebody">
-
-<div class="definition">
-<p>A class is a pure interface if it meets the following
-requirements:</p>
-
-<ul>
- <li>It has only public pure virtual ("<code>=
- 0</code>") methods and static methods (but see below
- for destructor).</li>
-
- <li>It may not have non-static data members.</li>
-
- <li>It need not have any constructors defined. If a
- constructor is provided, it must take no arguments and
- it must be protected.</li>
-
- <li>If it is a subclass, it may only be derived from
- classes that satisfy these conditions and are tagged
- with the <code>Interface</code> suffix.</li>
-</ul>
-
-<p>An interface class can never be directly instantiated
-because of the pure virtual method(s) it declares. To
-make sure all implementations of the interface can be
-destroyed correctly, the interface must also declare a
-virtual destructor (in an exception to the first rule,
-this should not be pure). See Stroustrup, <cite>The C++
-Programming Language</cite>, 3rd edition, section 12.4
-for details.</p>
-</div>
-
-<div class="pros">
-<p>Tagging a class with the <code>Interface</code> suffix
-lets others know that they must not add implemented
-methods or non static data members. This is particularly
-important in the case of <a href="#Multiple_Inheritance">multiple inheritance</a>.
-Additionally, the interface concept is already
-well-understood by Java programmers.</p>
-</div>
-
-<div class="cons">
-<p>The <code>Interface</code> suffix lengthens the class
-name, which can make it harder to read and understand.
-Also, the interface property may be considered an
-implementation detail that shouldn't be exposed to
-clients.</p>
-</div>
-
-<div class="decision">
-<p>A class may end
-with <code>Interface</code> only if it meets the above
-requirements. We do not require the converse, however:
-classes that meet the above requirements are not required
-to end with <code>Interface</code>.</p>
-</div>
-
-</div>
+<p>Multiple inheritance is permitted, but multiple <em>implementation</em>
+inheritance is strongly discouraged.</p>
<h3 id="Operator_Overloading">Operator Overloading</h3>
-<div class="summary">
-<p>Overload operators judiciously. Do not create user-defined literals.</p>
-</div>
+<p>Overload operators judiciously. Do not use user-defined literals.</p>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>C++ permits user code to
<a href="http://en.cppreference.com/w/cpp/language/operators">declare
overloaded versions of the built-in operators</a> using the
@@ -1471,9 +1530,8 @@
permits user code to define new kinds of literals using
<code>operator""</code>, and to define type-conversion functions
such as <code>operator bool()</code>.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Operator overloading can make code more concise and
intuitive by enabling user-defined types to behave the same
as built-in types. Overloaded operators are the idiomatic names
@@ -1485,9 +1543,8 @@
<p>User-defined literals are a very concise notation for
creating objects of user-defined types.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Providing a correct, consistent, and unsurprising
set of operator overloads requires some care, and failure
@@ -1529,13 +1586,23 @@
in undefined behavior, which can manifest as subtle
run-time bugs.</li>
- <li>User-defined literals allow the creation of new
+ <li>User-defined literals (UDLs) allow the creation of new
syntactic forms that are unfamiliar even to experienced C++
- programmers.</li>
-</ul>
-</div>
+ programmers, such as <code>"Hello World"sv</code> as a
+ shorthand for <code>std::string_view("Hello World")</code>.
+ Existing notations are clearer, though less terse.</li>
-<div class="decision">
+ <li>Because they can't be namespace-qualified, uses of UDLs also require
+ use of either using-directives (which <a href="#Namespaces">we ban</a>) or
+ using-declarations (which <a href="#Aliases">we ban in header files</a> except
+ when the imported names are part of the interface exposed by the header
+ file in question). Given that header files would have to avoid UDL
+ suffixes, we prefer to avoid having conventions for literals differ
+ between header files and source files.
+ </li>
+</ul>
+
+<p class="decision"></p>
<p>Define overloaded operators only if their meaning is
obvious, unsurprising, and consistent with the corresponding
built-in operators. For example, use <code>|</code> as a
@@ -1575,7 +1642,8 @@
<p>Do not overload <code>&&</code>, <code>||</code>,
<code>,</code> (comma), or unary <code>&</code>. Do not overload
<code>operator""</code>, i.e. do not introduce user-defined
-literals.</p>
+literals. Do not use any such literals provided by others
+(including the standard library).</p>
<p>Type conversion operators are covered in the section on
<a href="#Implicit_Conversions">implicit conversions</a>.
@@ -1585,32 +1653,25 @@
section on <a href="#Streams">streams</a>. See also the rules on
<a href="#Function_Overloading">function overloading</a>, which
apply to operator overloading as well.</p>
-</div>
-
-</div>
<h3 id="Access_Control">Access Control</h3>
-<div class="summary">
-<p> Make data members <code>private</code>, unless they are
-<code>static const</code> (and follow the <a href="#Constant_Names">
-naming convention for constants</a>). For technical
-reasons, we allow data members of a test fixture class to
+<p>Make classes' data members <code>private</code>, unless they are
+<a href="#Constant_Names">constants</a>. This simplifies reasoning about invariants, at the cost
+of some easy boilerplate in the form of accessors (usually <code>const</code>) if necessary.</p>
+
+<p>For technical
+reasons, we allow data members of a test fixture class in a .cc file to
be <code>protected</code> when using
<a href="https://github.com/google/googletest">Google
Test</a>).</p>
-</div>
<h3 id="Declaration_Order">Declaration Order</h3>
-<div class="summary">
<p>Group similar declarations together, placing public parts
earlier.</p>
-</div>
-
-<div class="stylebody">
<p>A class definition should usually start with a
<code>public:</code> section, followed by
@@ -1630,43 +1691,39 @@
defined inline. See <a href="#Inline_Functions">Inline
Functions</a> for more details.</p>
-</div>
-
<h2 id="Functions">Functions</h2>
-<h3 id="Function_Parameter_Ordering">Parameter Ordering</h3>
+<a id="Function_Parameter_Ordering"></a>
+<h3 id="Output_Parameters">Output Parameters</h3>
-<div class="summary">
-<p>When defining a function, parameter order is: inputs, then
-outputs.</p>
-</div>
+<p>The output of a C++ function is naturally provided via
+a return value and sometimes via output parameters.</p>
-<div class="stylebody">
-<p>Parameters to C/C++ functions are either input to the
-function, output from the function, or both. Input
-parameters are usually values or <code>const</code>
-references, while output and input/output parameters will
-be pointers to non-<code>const</code>. When ordering
-function parameters, put all input-only parameters before
-any output parameters. In particular, do not add new
-parameters to the end of the function just because they
-are new; place new input-only parameters before the
-output parameters.</p>
+<p>Prefer using return values over output parameters: they
+improve readability, and often provide the same or better
+performance. If output-only parameters are used,
+they should appear after input parameters.</p>
+
+<p>Parameters are either input to the function, output from the
+function, or both. Input parameters are usually values or
+<code>const</code> references, while output and input/output
+parameters will be pointers to non-<code>const</code>.</p>
+
+<p>When ordering function parameters, put all input-only
+parameters before any output parameters. In particular,
+do not add new parameters to the end of the function just
+because they are new; place new input-only parameters before
+the output parameters.</p>
<p>This is not a hard-and-fast rule. Parameters that are
both input and output (often classes/structs) muddy the
waters, and, as always, consistency with related
functions may require you to bend the rule.</p>
-</div>
-
<h3 id="Write_Short_Functions">Write Short Functions</h3>
-<div class="summary">
<p>Prefer small and focused functions.</p>
-</div>
-<div class="stylebody">
<p>We recognize that long functions are sometimes
appropriate, so no hard limit is placed on functions
length. If a function exceeds about 40 lines, think about
@@ -1677,10 +1734,11 @@
someone modifying it in a few months may add new
behavior. This could result in bugs that are hard to
find. Keeping your functions short and simple makes it
-easier for other people to read and modify your code.</p>
+easier for other people to read and modify your code.
+Small functions are also easier to test.</p>
<p>You could find long and complicated functions when
-working with
+working with
some code. Do not be
intimidated by modifying existing code: if working with
such a function proves to be difficult, you find that
@@ -1688,43 +1746,34 @@
it in several different contexts, consider breaking up
the function into smaller and more manageable pieces.</p>
-</div>
-
<h3 id="Reference_Arguments">Reference Arguments</h3>
-<div class="summary">
-<p>All parameters passed by reference must be labeled
+<p>All parameters passed by lvalue reference must be labeled
<code>const</code>.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>In C, if a
function needs to modify a variable, the parameter must
use a pointer, eg <code>int foo(int *pval)</code>. In
C++, the function can alternatively declare a reference
parameter: <code>int foo(int &val)</code>.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Defining a parameter as reference avoids ugly code like
<code>(*pval)++</code>. Necessary for some applications
like copy constructors. Makes it clear, unlike with
pointers, that a null pointer is not a possible
value.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>References can be confusing, as they have value syntax
but pointer semantics.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Within function parameter lists all references must be
<code>const</code>:</p>
-<pre>void Foo(const string &in, string *out);
+<pre>void Foo(const std::string &in, std::string *out);
</pre>
<p>In fact it is a very strong convention in Google code
@@ -1755,77 +1804,64 @@
for a concrete reason; otherwise it will likely confuse
readers by making them look for an explanation that
doesn't exist.</p>
-</div>
-
-</div>
<h3 id="Function_Overloading">Function Overloading</h3>
-<div class="summary">
<p>Use overloaded functions (including constructors) only if a
reader looking at a call site can get a good idea of what
is happening without having to first figure out exactly
which overload is being called.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>You may write a function that takes a <code>const
-string&</code> and overload it with another that
-takes <code>const char*</code>.</p>
+std::string&</code> and overload it with another that
+takes <code>const char*</code>. However, in this case consider
+std::string_view
+ instead.</p>
<pre>class MyClass {
public:
- void Analyze(const string &text);
+ void Analyze(const std::string &text);
void Analyze(const char *text, size_t textlen);
};
</pre>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Overloading can make code more intuitive by allowing an
identically-named function to take different arguments.
It may be necessary for templatized code, and it can be
convenient for Visitors.</p>
-</div>
+<p>Overloading based on const or ref qualification may make utility
+ code more usable, more efficient, or both.
+ (See <a href="http://abseil.io/tips/148">TotW 148</a> for more.)
+</p>
-<div class="cons">
+<p class="cons"></p>
<p>If a function is overloaded by the argument types alone,
a reader may have to understand C++'s complex matching
rules in order to tell what's going on. Also many people
are confused by the semantics of inheritance if a derived
class overrides only some of the variants of a
function.</p>
-</div>
-<div class="decision">
-<p>If you want to overload a function, consider qualifying
-the name with some information about the arguments, e.g.,
-<code>AppendString()</code>, <code>AppendInt()</code>
-rather than just <code>Append()</code>. If you are
-overloading a function to support variable number of
-arguments of the same type, consider making it take a
-<code>std::vector</code> so that the user can use an
-<a href="#Braced_Initializer_List">initializer list
-</a> to specify the arguments.</p>
-</div>
-
-</div>
+<p class="decision"></p>
+<p>You may overload a function when there are no semantic differences
+between variants. These overloads may vary in types, qualifiers, or
+argument count. However, a reader of such a call must not need to know
+which member of the overload set is chosen, only that <b>something</b>
+from the set is being called. If you can document all entries in the
+overload set with a single comment in the header, that is a good sign
+that it is a well-designed overload set.</p>
<h3 id="Default_Arguments">Default Arguments</h3>
-<div class="summary">
<p>Default arguments are allowed on non-virtual functions
when the default is guaranteed to always have the same
value. Follow the same restrictions as for <a href="#Function_Overloading">function overloading</a>, and
prefer overloaded functions if the readability gained with
default arguments doesn't outweigh the downsides below.</p>
-</div>
-<div class="stylebody">
-
-<div class="pros">
+<p class="pros"></p>
<p>Often you have a function that uses default values, but
occasionally you want to override the defaults. Default
parameters allow an easy way to do this without having to
@@ -1834,9 +1870,8 @@
cleaner syntax, with less boilerplate and a clearer
distinction between 'required' and 'optional'
arguments.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Defaulted arguments are another way to achieve the
semantics of overloaded functions, so all the <a href="#Function_Overloading">reasons not to overload
functions</a> apply.</p>
@@ -1855,9 +1890,8 @@
default arguments, since the function signature often
doesn't match the call signature. Adding
function overloads avoids these problems.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Default arguments are banned on virtual functions, where
they don't work properly, and in cases where the specified
default might not evaluate to the same value depending on
@@ -1868,22 +1902,18 @@
readability of their function declarations enough to
overcome the downsides above, so they are allowed. When in
doubt, use overloads.</p>
-</div>
-
-</div>
<h3 id="trailing_return">Trailing Return Type Syntax</h3>
-<div class="summary">
+
<p>Use trailing return types only where using the ordinary syntax (leading
return types) is impractical or much less readable.</p>
-</div>
-<div class="definition">
+<p class="definition"></p>
<p>C++ allows two different forms of function declarations. In the older
form, the return type appears before the function name. For example:</p>
<pre>int foo(int x);
</pre>
-<p>The new form, introduced in C++11, uses the <code>auto</code>
+<p>The newer form, introduced in C++11, uses the <code>auto</code>
keyword before the function name and a trailing return type after
the argument list. For example, the declaration above could
equivalently be written:</p>
@@ -1893,10 +1923,8 @@
make a difference for a simple case like <code>int</code> but it matters
for more complicated cases, like types declared in class scope or
types written in terms of the function parameters.</p>
-</div>
-<div class="stylebody">
-<div class="pros">
+<p class="pros"></p>
<p>Trailing return types are the only way to explicitly specify the
return type of a <a href="#Lambda_expressions">lambda expression</a>.
In some cases the compiler is able to deduce a lambda's return type,
@@ -1907,22 +1935,24 @@
after the function's parameter list has already appeared. This is
particularly true when the return type depends on template parameters.
For example:</p>
- <pre>template <class T, class U> auto add(T t, U u) -> decltype(t + u);</pre>
+ <pre> template <typename T, typename U>
+ auto add(T t, U u) -> decltype(t + u);
+ </pre>
versus
- <pre>template <class T, class U> decltype(declval<T&>() + declval<U&>()) add(T t, U u);</pre>
-</div>
+ <pre> template <typename T, typename U>
+ decltype(declval<T&>() + declval<U&>()) add(T t, U u);
+ </pre>
-<div class="cons">
+<p class="cons"></p>
<p>Trailing return type syntax is relatively new and it has no
- analogue in C++-like languages like C and Java, so some readers may
+ analogue in C++-like languages such as C and Java, so some readers may
find it unfamiliar.</p>
<p>Existing code bases have an enormous number of function
declarations that aren't going to get changed to use the new syntax,
so the realistic choices are using the old syntax only or using a mixture
of the two. Using a single version is better for uniformity of style.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>In most cases, continue to use the older style of function
declaration where the return type goes before the function name.
Use the new trailing-return-type form only in cases where it's
@@ -1932,30 +1962,26 @@
issue in fairly complicated template code, which is
<a href="#Template_metaprogramming">discouraged in most cases</a>.</p>
-</div>
-</div>
<h2 id="Google-Specific_Magic">Google-Specific Magic</h2>
+<div>
<p>There are various tricks and utilities that
we use to make C++ code more robust, and various ways we use
C++ that may differ from what you see elsewhere.</p>
+</div>
-
+
<h3 id="Ownership_and_Smart_Pointers">Ownership and Smart Pointers</h3>
-<div class="summary">
<p>Prefer to have single, fixed owners for dynamically
allocated objects. Prefer to transfer ownership with smart
pointers.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>"Ownership" is a bookkeeping technique for managing
dynamically allocated memory (and other resources). The
owner of a dynamically allocated object is an object or
@@ -1985,9 +2011,8 @@
can be copied; ownership of the object is shared among
all copies, and the object is deleted when the last
<code>std::shared_ptr</code> is destroyed. </p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>It's virtually impossible to manage dynamically
allocated memory without some sort of ownership
@@ -2012,9 +2037,8 @@
<li>For const objects, shared ownership can be a simple
and efficient alternative to deep copying.</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Ownership must be represented and transferred via
pointers (whether smart or plain). Pointer semantics
@@ -2051,9 +2075,8 @@
<li>Smart pointers are not perfect substitutes for
plain pointers.</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>If dynamic allocation is necessary, prefer to keep
ownership with the code that allocated it. If other code
needs access to the object, consider passing it a copy,
@@ -2078,18 +2101,10 @@
<p>Never use <code>std::auto_ptr</code>. Instead, use
<code>std::unique_ptr</code>.</p>
-</div>
-
-</div>
<h3 id="cpplint">cpplint</h3>
-<div class="summary">
-<p>Use <code>cpplint.py</code>
-to detect style errors.</p>
-</div>
-
-<div class="stylebody">
+<p>Use <code>cpplint.py</code> to detect style errors.</p>
<p><code>cpplint.py</code>
is a tool that reads a source file and identifies many
@@ -2101,56 +2116,60 @@
+<div>
<p>Some projects have instructions on
how to run <code>cpplint.py</code> from their project
tools. If the project you are contributing to does not,
you can download
<a href="https://raw.githubusercontent.com/google/styleguide/gh-pages/cpplint/cpplint.py">
<code>cpplint.py</code></a> separately.</p>
+</div>
-</div>
-
<h2 id="Other_C++_Features">Other C++ Features</h2>
<h3 id="Rvalue_references">Rvalue References</h3>
-<div class="summary">
-<p>Use rvalue references only to define move constructors and move assignment
-operators, or for perfect forwarding.
-</p>
-</div>
+<p>Use rvalue references to:</p>
+<ul>
+ <li>Define move constructors and move assignment operators.</li>
-<div class="stylebody">
+ <li>Define <a href="#Function_Overloading">overload sets</a> with
+ const& and && variants if you have evidence that this
+ provides meaningfully better performance than passing by value,
+ or if you're writing low-overhead generic code that needs to support
+ arbitrary types. Beware combinatorial overload sets, that is, seldom
+ overload more than one parameter.</li>
-<div class="definition">
+ <li>Support 'perfect forwarding' in generic code.</li>
+</ul>
+
+<p class="definition"></p>
<p> Rvalue references
are a type of reference that can only bind to temporary
objects. The syntax is similar to traditional reference
-syntax. For example, <code>void f(string&&
+syntax. For example, <code>void f(std::string&&
s);</code> declares a function whose argument is an
-rvalue reference to a string.</p>
-</div>
+rvalue reference to a std::string.</p>
-<div class="pros">
+<p id="Forwarding_references"> When the token '&&' is applied to
+an unqualified template argument in a function
+parameter, special template argument deduction
+rules apply. Such a reference is called forwarding reference.</p>
+
+<p class="pros"></p>
<ul>
<li>Defining a move constructor (a constructor taking
an rvalue reference to the class type) makes it
possible to move a value instead of copying it. If
- <code>v1</code> is a <code>std::vector<string></code>,
+ <code>v1</code> is a <code>std::vector<std::string></code>,
for example, then <code>auto v2(std::move(v1))</code>
will probably just result in some simple pointer
manipulation instead of copying a large amount of data.
- In some cases this can result in a major performance
+ In many cases this can result in a major performance
improvement.</li>
- <li>Rvalue references make it possible to write a
- generic function wrapper that forwards its arguments to
- another function, and works whether or not its
- arguments are temporary objects. (This is sometimes called
- "perfect forwarding".)</li>
-
<li>Rvalue references make it possible to implement
types that are movable but not copyable, which can be
useful for types that have no sensible definition of
@@ -2160,37 +2179,50 @@
<li><code>std::move</code> is necessary to make
effective use of some standard-library types, such as
<code>std::unique_ptr</code>.</li>
-</ul>
-</div>
-<div class="cons">
+ <li><a href="#Forwarding_references">Forwarding references</a> which
+ use the rvalue reference token, make it possible to write a
+ generic function wrapper that forwards its arguments to
+ another function, and works whether or not its
+ arguments are temporary objects and/or const.
+ This is called 'perfect forwarding'.</li>
+</ul>
+
+<p class="cons"></p>
<ul>
- <li>Rvalue references are a relatively new feature
- (introduced as part of C++11), and not yet widely
- understood. Rules like reference collapsing, and
- automatic synthesis of move constructors, are
- complicated.</li>
+ <li>Rvalue references are not yet widely understood. Rules like reference
+ collapsing and the special deduction rule for forwarding references
+ are somewhat obscure.</li>
+
+ <li>Rvalue references are often misused. Using rvalue
+ references is counter-intuitive in signatures where the argument is expected
+ to have a valid specified state after the function call, or where no move
+ operation is performed.</li>
</ul>
-</div>
-<div class="decision">
- <p>Use rvalue references only to define move constructors and move assignment
- operators (as described in <a href="#Copyable_Movable_Types">Copyable and
- Movable Types</a>) and, in conjunction with <code><a href="http://en.cppreference.com/w/cpp/utility/forward">std::forward</a></code>,
-to support perfect forwarding. You may use <code>std::move</code> to express
-moving a value from one object to another rather than copying it. </p>
-</div>
+<p class="decision"></p>
+<p>You may use rvalue references to define move constructors and move
+assignment operators (as described in
+<a href="#Copyable_Movable_Types">Copyable and Movable Types</a>). See the
+<a href="primer#copying_moving">C++ Primer</a> for more information about
+move semantics and <code>std::move</code>.</p>
-</div>
+<p>You may use rvalue references to define pairs of overloads, one taking
+<code>Foo&&</code> and the other taking <code>const Foo&</code>.
+Usually the preferred solution is just to pass by value, but an overloaded pair
+of functions sometimes yields better performance and is sometimes necessary in
+generic code that needs to support a wide variety of types. As always: if
+you're writing more complicated code for the sake of performance, make sure you
+have evidence that it actually helps.</p>
+
+<p>You may use forwarding references in conjunction with <code>
+<a href="http://en.cppreference.com/w/cpp/utility/forward">std::forward</a></code>,
+to support perfect forwarding.</p>
<h3 id="Friends">Friends</h3>
-<div class="summary">
<p>We allow use of <code>friend</code> classes and functions,
within reason.</p>
-</div>
-
-<div class="stylebody">
<p>Friends should usually be defined in the same file so
that the reader does not have to look in another file to
@@ -2209,29 +2241,25 @@
interact with other classes solely through their public
members.</p>
-</div>
-
<h3 id="Exceptions">Exceptions</h3>
-<div class="summary">
<p>We do not use C++ exceptions.</p>
-</div>
-<div class="stylebody">
-
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>Exceptions allow higher levels of an application to
decide how to handle "can't happen" failures in deeply
nested functions, without the obscuring and error-prone
bookkeeping of error codes.</li>
-
+
+ <div>
<li>Exceptions are used by most other
modern languages. Using them in C++ would make it more
consistent with Python, Java, and the C++ that others
are familiar with.</li>
+ </div>
<li>Some third-party C++ libraries use exceptions, and
turning them off internally makes it harder to
@@ -2245,9 +2273,8 @@
<li>Exceptions are really handy in testing
frameworks.</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>When you add a <code>throw</code> statement to an
existing function, you must examine all of its
@@ -2291,9 +2318,8 @@
to be thrown. We would need to make the style guide
even longer to document these restrictions!</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>On their face, the benefits of using exceptions
outweigh the costs, especially in new projects. However,
for existing code, the introduction of exceptions has
@@ -2322,46 +2348,108 @@
Things would probably be different if we had to do it all
over again from scratch.</p>
-<p>This prohibition also applies to the exception-related
-features added in C++11, such as <code>noexcept</code>,
-<code>std::exception_ptr</code>, and
+<p>This prohibition also applies to the exception handling related
+features added in C++11, such as
+<code>std::exception_ptr</code> and
<code>std::nested_exception</code>.</p>
<p>There is an <a href="#Windows_Code">exception</a> to
this rule (no pun intended) for Windows code.</p>
-</div>
-</div>
+<h3 id="noexcept"><code>noexcept</code></h3>
+
+<p>Specify <code>noexcept</code> when it is useful and correct.</p>
+
+<p class="definition"></p>
+<p>The <code>noexcept</code> specifier is used to specify whether
+a function will throw exceptions or not. If an exception
+escapes from a function marked <code>noexcept</code>, the program
+crashes via <code>std::terminate</code>.</p>
+
+<p>The <code>noexcept</code> operator performs a compile-time
+check that returns true if an expression is declared to not
+throw any exceptions.</p>
+
+<p class="pros"></p>
+<ul>
+ <li>Specifying move constructors as <code>noexcept</code>
+ improves performance in some cases, e.g.
+ <code>std::vector<T>::resize()</code> moves rather than
+ copies the objects if T's move constructor is
+ <code>noexcept</code>.</li>
+
+ <li>Specifying <code>noexcept</code> on a function can
+ trigger compiler optimizations in environments where
+ exceptions are enabled, e.g. compiler does not have to
+ generate extra code for stack-unwinding, if it knows
+ that no exceptions can be thrown due to a
+ <code>noexcept</code> specifier.</li>
+</ul>
+
+<p class="cons"></p>
+<ul>
+ <li>
+
+ In projects following this guide
+ that have exceptions disabled it is hard
+ to ensure that <code>noexcept</code>
+ specifiers are correct, and hard to define what
+ correctness even means.</li>
+
+ <li>It's hard, if not impossible, to undo <code>noexcept</code>
+ because it eliminates a guarantee that callers may be relying
+ on, in ways that are hard to detect.</li>
+</ul>
+
+<p class="decision"></p>
+<p>You may use <code>noexcept</code> when it is useful for
+performance if it accurately reflects the intended semantics
+of your function, i.e. that if an exception is somehow thrown
+from within the function body then it represents a fatal error.
+You can assume that <code>noexcept</code> on move constructors
+has a meaningful performance benefit. If you think
+there is significant performance benefit from specifying
+<code>noexcept</code> on some other function, please discuss it
+with
+your project leads.</p>
+
+<p>Prefer unconditional <code>noexcept</code> if exceptions are
+completely disabled (i.e. most Google C++ environments).
+Otherwise, use conditional <code>noexcept</code> specifiers
+with simple conditions, in ways that evaluate false only in
+the few cases where the function could potentially throw.
+The tests might include type traits check on whether the
+involved operation might throw (e.g.
+<code>std::is_nothrow_move_constructible</code> for
+move-constructing objects), or on whether allocation can throw
+(e.g. <code>absl::default_allocator_is_nothrow</code> for
+standard default allocation). Note in many cases the only
+possible cause for an exception is allocation failure (we
+believe move constructors should not throw except due to
+allocation failure), and there are many applications where it’s
+appropriate to treat memory exhaustion as a fatal error rather
+than an exceptional condition that your program should attempt
+to recover from. Even for other
+potential failures you should prioritize interface simplicity
+over supporting all possible exception throwing scenarios:
+instead of writing a complicated <code>noexcept</code> clause
+that depends on whether a hash function can throw, for example,
+simply document that your component doesn’t support hash
+functions throwing and make it unconditionally
+<code>noexcept</code>.</p>
<h3 id="Run-Time_Type_Information__RTTI_">Run-Time Type
Information (RTTI)</h3>
-<div class="summary">
<p>Avoid using Run Time Type Information (RTTI).</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> RTTI allows a
programmer to query the C++ class of an object at run
time. This is done by use of <code>typeid</code> or
<code>dynamic_cast</code>.</p>
-</div>
-<div class="cons">
-<p>Querying the type of an object at run-time frequently
-means a design problem. Needing to know the type of an
-object at runtime is often an indication that the design
-of your class hierarchy is flawed.</p>
-
-<p>Undisciplined use of RTTI makes code hard to maintain.
-It can lead to type-based decision trees or switch
-statements scattered throughout the code, all of which
-must be examined when making further changes.</p>
-</div>
-
-<div class="pros">
+<p class="pros"></p>
<p>The standard alternatives to RTTI (described below)
require modification or redesign of the class hierarchy
in question. Sometimes such modifications are infeasible
@@ -2380,14 +2468,24 @@
<pre>bool Base::Equal(Base* other) = 0;
bool Derived::Equal(Base* other) {
Derived* that = dynamic_cast<Derived*>(other);
- if (that == NULL)
+ if (that == nullptr)
return false;
...
}
</pre>
-</div>
-<div class="decision">
+<p class="cons"></p>
+<p>Querying the type of an object at run-time frequently
+means a design problem. Needing to know the type of an
+object at runtime is often an indication that the design
+of your class hierarchy is flawed.</p>
+
+<p>Undisciplined use of RTTI makes code hard to maintain.
+It can lead to type-based decision trees or switch
+statements scattered throughout the code, all of which
+must be examined when making further changes.</p>
+
+<p class="decision"></p>
<p>RTTI has legitimate uses but is prone to abuse, so you
must be careful when using it. You may use it freely in
unittests, but avoid it when possible in other code. In
@@ -2437,13 +2535,9 @@
arguments against RTTI apply just as much to workarounds
like class hierarchies with type tags. Moreover,
workarounds disguise your true intent.</p>
-</div>
-
-</div>
<h3 id="Casting">Casting</h3>
-<div class="summary">
<p>Use C++-style casts
like <code>static_cast<float>(double_value)</code>, or brace
initialization for conversion of arithmetic types like
@@ -2451,17 +2545,13 @@
cast formats like
<code>int y = (int)x</code> or <code>int y = int(x)</code> (but the latter
is okay when invoking a constructor of a class type).</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> C++ introduced a
different cast system from C that distinguishes the types
of cast operations.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>The problem with C casts is the ambiguity of the operation;
sometimes you are doing a <em>conversion</em>
(e.g., <code>(int)3.5</code>) and sometimes you are doing
@@ -2469,13 +2559,11 @@
initialization and C++ casts can often help avoid this
ambiguity. Additionally, C++ casts are more visible when searching for
them.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>The C++-style cast syntax is verbose and cumbersome.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Do not use C-style casts. Instead, use these C++-style casts when
explicit type conversion is necessary. </p>
@@ -2485,7 +2573,7 @@
will not compile if conversion can result in information loss. The
syntax is also concise.</li>
-
+
<li>Use <code>static_cast</code> as the equivalent of a C-style cast
that does value conversion, when you need to
@@ -2494,49 +2582,47 @@
subclass. In this last case, you must be sure your object is
actually an instance of the subclass.</li>
-
+
<li>Use <code>const_cast</code> to remove the
<code>const</code> qualifier (see <a href="#Use_of_const">const</a>).</li>
- <li>Use <code>reinterpret_cast</code> to do unsafe
- conversions of pointer types to and from integer and
- other pointer types. Use this only if you know what you
- are doing and you understand the aliasing issues.
- </li>
+ <li>Use <code>reinterpret_cast</code> to do unsafe conversions of
+ pointer types to and from integer and other pointer
+ types. Use this
+ only if you know what you are doing and you understand the aliasing
+ issues. Also, consider the alternative
+ <code>absl::bit_cast</code>.</li>
-
+ <li>Use <code>absl::bit_cast</code> to interpret the raw bits of a
+ value using a different type of the same size (a type pun), such as
+ interpreting the bits of a <code>double</code> as
+ <code>int64</code>.</li>
</ul>
<p>See the <a href="#Run-Time_Type_Information__RTTI_">
RTTI section</a> for guidance on the use of
<code>dynamic_cast</code>.</p>
-</div>
-
-</div>
<h3 id="Streams">Streams</h3>
-<div class="summary">
<p>Use streams where appropriate, and stick to "simple"
-usages.</p>
-</div>
+usages. Overload <code><<</code> for streaming only for types
+representing values, and write only the user-visible value, not any
+implementation details.</p>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>Streams are the standard I/O abstraction in C++, as
exemplified by the standard header <code><iostream></code>.
-They are widely used in Google code, but only for debug logging
+They are widely used in Google code, mostly for debug logging
and test diagnostics.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>The <code><<</code> and <code>>></code>
stream operators provide an API for formatted I/O that
is easily learned, portable, reusable, and extensible.
<code>printf</code>, by contrast, doesn't even support
-<code>string</code>, to say nothing of user-defined types,
+<code>std::string</code>, to say nothing of user-defined types,
and is very difficult to use portably.
<code>printf</code> also obliges you to choose among the
numerous slightly different versions of that function,
@@ -2547,9 +2633,8 @@
<code>std::cerr</code>, and <code>std::clog</code>.
The C APIs do as well, but are hampered by the need to
manually buffer the input. </p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Stream formatting can be configured by mutating the
state of the stream. Such mutations are persistent, so
@@ -2576,27 +2661,30 @@
<li>The streams API is subtle and complex, so programmers must
-develop experience with it in order to use it effectively.
-However, streams were historically banned in Google code (except
-for logging and diagnostics), so Google engineers tend not to
-have that experience. Consequently, streams-based code is likely
-to be less readable and maintainable by Googlers than code based
-on more familiar abstractions.</li>
+develop experience with it in order to use it effectively.</li>
<li>Resolving the many overloads of <code><<</code> is
extremely costly for the compiler. When used pervasively in a
large code base, it can consume as much as 20% of the parsing
and semantic analysis time.</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Use streams only when they are the best tool for the job.
This is typically the case when the I/O is ad-hoc, local,
human-readable, and targeted at other developers rather than
end-users. Be consistent with the code around you, and with the
codebase as a whole; if there's an established tool for
-your problem, use that tool instead. </p>
+your problem, use that tool instead.
+In particular,
+
+logging libraries are usually a better
+choice than <code>std::cerr</code> or <code>std::clog</code>
+for diagnostic output, and the libraries in
+
+<code>absl/strings</code>
+or the equivalent are usually a
+better choice than <code>std::stringstream</code>.</p>
<p>Avoid using streams for I/O that faces external users or
handles untrusted data. Instead, find and use the appropriate
@@ -2606,7 +2694,10 @@
<p>If you do use streams, avoid the stateful parts of the
streams API (other than error state), such as <code>imbue()</code>,
<code>xalloc()</code>, and <code>register_callback()</code>.
-Use explicit formatting functions rather than
+Use explicit formatting functions (see e.g.
+
+<code>absl/strings</code>)
+rather than
stream manipulators or formatting flags to control formatting
details such as number base, precision, or padding.</p>
@@ -2618,30 +2709,22 @@
object internals for debugging, use named functions instead
(a method named <code>DebugString()</code> is the most common
convention).</p>
-</div>
-
-</div>
<h3 id="Preincrement_and_Predecrement">Preincrement and Predecrement</h3>
-<div class="summary">
<p>Use prefix form (<code>++i</code>) of the increment and
decrement operators with iterators and other template
objects.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> When a variable
is incremented (<code>++i</code> or <code>i++</code>) or
decremented (<code>--i</code> or <code>i--</code>) and
the value of the expression is not used, one must decide
whether to preincrement (decrement) or postincrement
(decrement).</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>When the return value is ignored, the "pre" form
(<code>++i</code>) is never less efficient than the
"post" form (<code>i++</code>), and is often more
@@ -2652,36 +2735,27 @@
could be expensive. Since the two types of increment
behave the same when the value is ignored, why not just
always pre-increment?</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>The tradition developed, in C, of using post-increment
when the expression value is not used, especially in
<code>for</code> loops. Some find post-increment easier
to read, since the "subject" (<code>i</code>) precedes
the "verb" (<code>++</code>), just like in English.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p> For simple scalar
(non-object) values there is no reason to prefer one form
and we allow either. For iterators and other template
types, use pre-increment.</p>
-</div>
-
-</div>
<h3 id="Use_of_const">Use of const</h3>
-<div class="summary">
-<p>Use <code>const</code> whenever it makes sense. With C++11,
+<p>In APIs, use <code>const</code> whenever it makes sense.
<code>constexpr</code> is a better choice for some uses of
const.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> Declared variables and parameters can be preceded
by the keyword <code>const</code> to indicate the variables
are not changed (e.g., <code>const int foo</code>). Class
@@ -2689,9 +2763,8 @@
indicate the function does not change the state of the
class member variables (e.g., <code>class Foo { int
Bar(char c) const; };</code>).</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Easier for people to understand how variables are being
used. Allows the compiler to do better type checking,
and, conceivably, generate better code. Helps people
@@ -2700,23 +2773,24 @@
modify your variables. Helps people know what functions
are safe to use without locks in multi-threaded
programs.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p><code>const</code> is viral: if you pass a
<code>const</code> variable to a function, that function
must have <code>const</code> in its prototype (or the
variable will need a <code>const_cast</code>). This can
be a particular problem when calling library
functions.</p>
-</div>
-<div class="decision">
-<p><code>const</code> variables, data members, methods
-and arguments add a level of compile-time type checking;
-it is better to detect errors as soon as possible.
-Therefore we strongly recommend that you use
-<code>const</code> whenever it makes sense to do so:</p>
+<p class="decision"></p>
+<p>We strongly recommend using <code>const</code>
+in APIs (i.e. on function parameters, methods, and
+non-local variables) wherever it is meaningful and accurate. This
+provides consistent, mostly compiler-verified documentation
+of what objects an operation can mutate. Having
+a consistent and reliable way to distinguish reads from writes
+is critical to writing thread-safe code, and is useful in
+many other contexts as well. In particular:</p>
<ul>
<li>If a function guarantees that it will not modify an argument
@@ -2724,25 +2798,28 @@
should be a reference-to-const (<code>const T&</code>) or
pointer-to-const (<code>const T*</code>), respectively.</li>
- <li>Declare methods to be <code>const</code> whenever
- possible. Accessors should almost always be
- <code>const</code>. Other methods should be const if
- they do not modify any data members, do not call any
- non-<code>const</code> methods, and do not return a
- non-<code>const</code> pointer or
- non-<code>const</code> reference to a data member.</li>
+ <li>For a function parameter passed by value, <code>const</code> has
+ no effect on the caller, thus is not recommended in function
+ declarations. See
- <li>Consider making data members <code>const</code>
- whenever they do not need to be modified after
- construction.</li>
+
+ <a href="https://abseil.io/tips/109">TotW #109</a>.
+
+
+ </li><li>Declare methods to be <code>const</code> unless they
+ alter the logical state of the object (or enable the user to modify
+ that state, e.g. by returning a non-const reference, but that's
+ rare), or they can't safely be invoked concurrently.</li>
</ul>
-<p>The <code>mutable</code> keyword is allowed but is
-unsafe when used with threads, so thread safety should be
-carefully considered first.</p>
-</div>
+<p>Using <code>const</code> on local variables is neither encouraged
+nor discouraged.</p>
-<div class="stylepoint_subsection">
+<p>All of a class's <code>const</code> operations should be safe
+to invoke concurrently with each other. If that's not feasible, the class must
+be clearly documented as "thread-unsafe".</p>
+
+
<h4>Where to put the const</h4>
<p>Some people favor the form <code>int const *foo</code>
@@ -2762,45 +2839,35 @@
<p>That said, while we encourage putting
<code>const</code> first, we do not require it. But be
consistent with the code around you!</p>
-</div>
-
-</div>
<h3 id="Use_of_constexpr">Use of constexpr</h3>
-<div class="summary">
-<p>In C++11, use <code>constexpr</code> to define true
+<p>Use <code>constexpr</code> to define true
constants or to ensure constant initialization.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> Some variables can be declared <code>constexpr</code>
to indicate the variables are true constants, i.e. fixed at
compilation/link time. Some functions and constructors
can be declared <code>constexpr</code> which enables them
to be used in defining a <code>constexpr</code>
variable.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Use of <code>constexpr</code> enables definition of
constants with floating-point expressions rather than
just literals; definition of constants of user-defined
types; and definition of constants with function
calls.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Prematurely marking something as constexpr may cause
migration problems if later on it has to be downgraded.
Current restrictions on what is allowed in constexpr
functions and constructors may invite obscure workarounds
in these definitions.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p><code>constexpr</code> definitions enable a more
robust specification of the constant parts of an
interface. Use <code>constexpr</code> to specify true
@@ -2808,17 +2875,13 @@
definitions. Avoid complexifying function definitions to
enable their use with <code>constexpr</code>. Do not use
<code>constexpr</code> to force inlining.</p>
-</div>
-
-</div>
<h3 id="Integer_Types">Integer Types</h3>
-<div class="summary">
<p>Of the built-in C++ integer types, the only one used
is
<code>int</code>. If a program needs a variable of a
-different size, use
+different size, use
a precise-width integer type from
<code><stdint.h></code>, such as
<code>int16_t</code>. If your variable represents a
@@ -2829,30 +2892,25 @@
for an <code>int</code>, it may be used in intermediate
calculations which may require a larger type. When in doubt,
choose a larger type.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
-<p> C++ does not specify the sizes of its integer types.
-Typically people assume that <code>short</code> is 16 bits,
+<p class="definition"></p>
+<p> C++ does not specify the sizes of integer types
+like <code>int</code>. Typically people assume
+that <code>short</code> is 16 bits,
<code>int</code> is 32 bits, <code>long</code> is 32 bits
and <code>long long</code> is 64 bits.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Uniformity of declaration.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>The sizes of integral types in C++ can vary based on
compiler and architecture.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>
-<code><stdint.h></code> defines types
+<code><cstdint></code> defines types
like <code>int16_t</code>, <code>uint32_t</code>,
<code>int64_t</code>, etc. You should always use
those in preference to <code>short</code>, <code>unsigned
@@ -2880,11 +2938,13 @@
</p>
<p>You should not use the unsigned integer types such as
+
<code>uint32_t</code>, unless there is a valid
reason such as representing a bit pattern rather than a
number, or you need defined overflow modulo 2^N. In
particular, do not use unsigned types to say a number
-will never be negative. Instead, use
+will never be negative. Instead, use
+
assertions for this.</p>
@@ -2894,153 +2954,68 @@
usage of your container. When in doubt, use a larger type
rather than a smaller type.</p>
-<p>Use care when converting integer types. Integer
-conversions and promotions can cause non-intuitive
-behavior. </p>
-</div>
-
-<div class="stylepoint_subsection">
+<p>Use care when converting integer types. Integer conversions and
+promotions can cause undefined behavior, leading to security bugs and
+other problems.</p>
<h4>On Unsigned Integers</h4>
-<p>Some people, including some textbook authors,
-recommend using unsigned types to represent numbers that
-are never negative. This is intended as a form of
-self-documentation. However, in C, the advantages of such
-documentation are outweighed by the real bugs it can
-introduce. Consider:</p>
+<p>Unsigned integers are good for representing bitfields and modular
+arithmetic. Because of historical accident, the C++ standard also uses
+unsigned integers to represent the size of containers - many members
+of the standards body believe this to be a mistake, but it is
+effectively impossible to fix at this point. The fact that unsigned
+arithmetic doesn't model the behavior of a simple integer, but is
+instead defined by the standard to model modular arithmetic (wrapping
+around on overflow/underflow), means that a significant class of bugs
+cannot be diagnosed by the compiler. In other cases, the defined
+behavior impedes optimization.</p>
-<pre>for (unsigned int i = foo.Length()-1; i >= 0; --i) ...
-</pre>
-
-<p>This code will never terminate! Sometimes gcc will
-notice this bug and warn you, but often it will not.
-Equally bad bugs can occur when comparing signed and
-unsigned variables. Basically, C's type-promotion scheme
-causes unsigned types to behave differently than one
-might expect.</p>
-
-<p>So, document that a variable is non-negative using
-assertions. Don't use an unsigned
-type.</p>
-</div>
-
-</div>
+<p>That said, mixing signedness of integer types is responsible for an
+equally large class of problems. The best advice we can provide: try
+to use iterators and containers rather than pointers and sizes, try
+not to mix signedness, and try to avoid unsigned types (except for
+representing bitfields or modular arithmetic). Do not use an unsigned
+type merely to assert that a variable is non-negative.</p>
<h3 id="64-bit_Portability">64-bit Portability</h3>
-<div class="summary">
<p>Code should be 64-bit and 32-bit friendly. Bear in mind
problems of printing, comparisons, and structure alignment.</p>
-</div>
-
-<div class="stylebody">
<ul>
<li>
- <p><code>printf()</code> specifiers for some types
- are not cleanly portable between 32-bit and 64-bit
- systems. C99 defines some portable format specifiers.
- Unfortunately, MSVC 7.1 does not understand some of
- these specifiers and the standard is missing a few,
- so we
- have to define our own ugly versions in some cases
- (in the style of the standard include file
- <code>inttypes.h</code>):</p>
+ <p>Correct portable <code>printf()</code> conversion specifiers for
+ some integral typedefs rely on macro expansions that we find unpleasant to
+ use and impractical to require (the <code>PRI</code> macros from
+ <code><cinttypes></code>). Unless there is no reasonable alternative
+ for your particular case, try to avoid or even upgrade APIs that rely on the
+ <code>printf</code> family. Instead use a library supporting typesafe numeric
+ formatting, such as
- <div>
- <pre>// printf macros for size_t, in the style of inttypes.h
-#ifdef _LP64
-#define __PRIS_PREFIX "z"
-#else
-#define __PRIS_PREFIX
-#endif
-// Use these macros after a % in a printf format string
-// to get correct 32/64 bit behavior, like this:
-// size_t size = records.size();
-// printf("%" PRIuS "\n", size);
+ <a href="https://github.com/abseil/abseil-cpp/blob/master/absl/strings/str_cat.h"><code>StrCat</code></a>
-#define PRIdS __PRIS_PREFIX "d"
-#define PRIxS __PRIS_PREFIX "x"
-#define PRIuS __PRIS_PREFIX "u"
-#define PRIXS __PRIS_PREFIX "X"
-#define PRIoS __PRIS_PREFIX "o"
- </pre>
- </div>
+ or
- <table border="1" summary="portable printf specifiers">
- <tbody><tr align="center">
- <th>Type</th>
- <th>DO NOT use</th>
- <th>DO use</th>
- <th>Notes</th>
- </tr>
- <tr align="center">
- <td><code>void *</code> (or any pointer)</td>
- <td><code>%lx</code></td>
- <td><code>%p</code></td>
- <td></td>
- </tr>
+ <a href="https://github.com/abseil/abseil-cpp/blob/master/absl/strings/substitute.h"><code>Substitute</code></a>
-
+ for fast simple conversions,
- <tr align="center">
- <td><code>int64_t</code></td>
- <td><code>%qd</code>, <code>%lld</code></td>
- <td><code>%" PRId64 "</code></td>
- <td></td>
- </tr>
+ or <a href="#Streams"><code>std::ostream</code></a>.</p>
-
+ <p>Unfortunately, the <code>PRI</code> macros are the only portable way to
+ specify a conversion for the standard bitwidth typedefs (e.g.
+ <code>int64_t</code>, <code>uint64_t</code>, <code>int32_t</code>,
+ <code>uint32_t</code>, etc).
- <tr align="center">
- <td><code>uint64_t</code></td>
- <td><code>%qu</code>, <code>%llu</code>,
- <code>%llx</code></td>
- <td><code>%" PRIu64 "</code>,
- <code>%" PRIx64 "</code></td>
- <td></td>
- </tr>
-
-
-
- <tr align="center">
- <td><code>size_t</code></td>
- <td><code>%u</code></td>
- <td><code>%" PRIuS "</code>, <code>%" PRIxS "</code></td>
- <td>
- C99 specifies <code>%zu</code></td>
- </tr>
-
- <tr align="center">
- <td><code>ptrdiff_t</code></td>
- <td><code>%d</code></td>
- <td><code>%" PRIdS "</code></td>
- <td>
- C99 specifies <code>%td</code></td>
- </tr>
-
-
- </tbody></table>
-
- <p>Note that the <code>PRI*</code> macros expand to
- independent strings which are concatenated by the
- compiler. Hence if you are using a non-constant
- format string, you need to insert the value of the
- macro into the format, rather than the name. Note also
- that spaces are required around the macro identifier to
- separate it from the string literal. It is
- still possible, as usual, to include length
- specifiers, etc., after the <code>%</code> when using
- the <code>PRI*</code> macros. So, e.g.
- <code>printf("x = %30" PRIuS "\n", x)</code> would
- expand on 32-bit Linux to <code>printf("x = %30" "u"
- "\n", x)</code>, which the compiler will treat as
- <code>printf("x = %30u\n", x)</code>.</p>
-
-
+ Where possible, avoid passing arguments of types specified by bitwidth
+ typedefs to <code>printf</code>-based APIs. Note that it is acceptable
+ to use typedefs for which printf has dedicated length modifiers, such as
+ <code>size_t</code> (<code>z</code>),
+ <code>ptrdiff_t</code> (<code>t</code>), and
+ <code>maxint_t</code> (<code>j</code>).</p>
</li>
<li>Remember that <code>sizeof(void *)</code> !=
@@ -3049,13 +3024,13 @@
<li>You may need to be careful with structure
alignments, particularly for structures being stored on
- disk. Any class/structure with a
+ disk. Any class/structure with a
<code>int64_t</code>/<code>uint64_t</code>
member will by default end up being 8-byte aligned on a
64-bit system. If you have such structures being shared
on disk between 32-bit and 64-bit code, you will need
to ensure that they are packed the same on both
- architectures.
+ architectures.
Most compilers offer a way to
alter structure alignment. For gcc, you can use
<code>__attribute__((packed))</code>. MSVC offers
@@ -3063,29 +3038,24 @@
<code>__declspec(align())</code>.</li>
<li>
- <p>Use the <code>LL</code> or <code>ULL</code>
- suffixes as needed to create 64-bit constants. For
- example:</p>
+ <p>Use <a href="#Casting">braced-initialization</a> as needed to create
+ 64-bit constants. For example:</p>
-<pre>int64_t my_value = 0x123456789LL;
-uint64_t my_mask = 3ULL << 48;
+<div>
+<pre>int64_t my_value{0x123456789};
+uint64_t my_mask{3ULL << 48};
</pre>
+</div>
</li>
</ul>
-</div>
-
<h3 id="Preprocessor_Macros">Preprocessor Macros</h3>
-<div class="summary">
<p>Avoid defining macros, especially in headers; prefer
inline functions, enums, and <code>const</code> variables.
Name macros with a project-specific prefix. Do not use
macros to define pieces of a C++ API.</p>
-</div>
-
-<div class="stylebody">
<p>Macros mean that the code you see is not the same as
the code the compiler sees. This can introduce unexpected
@@ -3130,7 +3100,7 @@
available through the language proper. But before using a
macro, consider carefully whether there's a non-macro way
to achieve the same result. If you need to use a macro to
-define an interface, contact
+define an interface, contact
your project leads to request
a waiver of this rule.</p>
@@ -3163,46 +3133,27 @@
must be named with a prefix consisting of your project's namespace
name (but upper case). </p>
-</div>
-
<h3 id="0_and_nullptr/NULL">0 and nullptr/NULL</h3>
-<div class="summary">
-<p>Use <code>0</code> for integers, <code>0.0</code> for
-reals, <code>nullptr</code> (or <code>NULL</code>) for
-pointers, and <code>'\0'</code> for chars.</p>
-</div>
+<p>Use <code>nullptr</code> for pointers, and <code>'\0'</code> for chars (and
+not the <code>0</code> literal).</p>
-<div class="stylebody">
+<p>For pointers (address values), use <code>nullptr</code>, as this
+provides type-safety.</p>
-<p>Use <code>0</code> for integers and <code>0.0</code>
-for reals. This is not controversial.</p>
+<p>For C++03 projects, prefer <code>NULL</code> to <code>0</code>. While the
+values are equivalent, <code>NULL</code> looks more like a pointer to the
+reader, and some C++ compilers provide special definitions of <code>NULL</code>
+which enable them to give useful warnings. Never use <code>NULL</code> for
+numeric (integer or floating-point) values.</p>
-<p> For
-pointers (address values), there is a choice between
-<code>0</code>, <code>NULL</code>, and
-<code>nullptr</code>. For projects that allow C++11
-features, use <code>nullptr</code>. For C++03 projects,
-we prefer <code>NULL</code> because it looks like a
-pointer. In fact, some C++ compilers provide special
-definitions of <code>NULL</code> which enable them to
-give useful warnings, particularly in situations where
-<code>sizeof(NULL)</code> is not equal to
-<code>sizeof(0)</code>.</p>
-
-<p>Use <code>'\0'</code> for chars. This is the correct
-type and also makes code more readable.</p>
-
-</div>
+<p>Use <code>'\0'</code> for the null character. Using the correct type makes
+the code more readable.</p>
<h3 id="sizeof">sizeof</h3>
-<div class="summary">
<p>Prefer <code>sizeof(<var>varname</var>)</code> to
<code>sizeof(<var>type</var>)</code>.</p>
-</div>
-
-<div class="stylebody">
<p>Use <code>sizeof(<var>varname</var>)</code> when you
take the size of a particular variable.
@@ -3214,7 +3165,7 @@
external or internal data format where a variable of an
appropriate C++ type is not convenient.</p>
-<pre>Struct data;
+<pre>struct data;
memset(&data, 0, sizeof(data));
</pre>
@@ -3227,205 +3178,310 @@
}
</pre>
-</div>
+<a name="auto"></a>
+<h3 id="Type_deduction">Type deduction</h3>
-<h3 id="auto">auto</h3>
+<p>Use type deduction only if it makes the code clearer to readers who aren't
+ familiar with the project, or if it makes the code safer. Do not use it
+ merely to avoid the inconvenience of writing an explicit type.</p>
-<div class="summary">
-<p>Use <code>auto</code> to avoid type names that are noisy, obvious,
-or unimportant - cases where the type doesn't aid in clarity for the
-reader. Continue to use manifest type declarations when it helps
-readability.</p>
-</div>
+<p class="definition"></p>
-<div class="stylebody">
+<p>There are several contexts in which C++ allows (or even requires) types to
+be deduced by the compiler, rather than spelled out explicitly in the code:</p>
+<dl>
+ <dt><a href="https://en.cppreference.com/w/cpp/language/template_argument_deduction">Function template argument deduction</a></dt>
+ <dd>A function template can be invoked without explicit template arguments.
+ The compiler deduces those arguments from the types of the function
+ arguments:
+ <pre class="neutralcode">template <typename T>
+void f(T t);
-<div class="pros">
-<p>
-</p><ul>
-<li>C++ type names can be long and cumbersome, especially when they
-involve templates or namespaces.</li>
-<li>When a C++ type name is repeated within a single declaration or a
-small code region, the repetition may not be aiding readability.</li>
-<li>It is sometimes safer to let the type be specified by the type of
-the initialization expression, since that avoids the possibility of
-unintended copies or type conversions.</li>
+f(0); // Invokes f<int>(0)</pre>
+ </dd>
+ <dt><a href="https://en.cppreference.com/w/cpp/language/auto"><code>auto</code> variable declarations</a></dt>
+ <dd>A variable declaration can use the <code>auto</code> keyword in place
+ of the type. The compiler deduces the type from the variable's
+ initializer, following the same rules as function template argument
+ deduction with the same initializer (so long as you don't use curly braces
+ instead of parentheses).
+ <pre class="neutralcode">auto a = 42; // a is an int
+auto& b = a; // b is an int&
+auto c = b; // c is an int
+auto d{42}; // d is an int, not a std::initializer_list<int>
+</pre>
+ <code>auto</code> can be qualified with <code>const</code>, and can be
+ used as part of a pointer or reference type, but it can't be used as a
+ template argument. A rare variant of this syntax uses
+ <code>decltype(auto)</code> instead of <code>auto</code>, in which case
+ the deduced type is the result of applying
+ <a href="https://en.cppreference.com/w/cpp/language/decltype"><code>decltype</code></a>
+ to the initializer.
+ </dd>
+ <dt><a href="https://en.cppreference.com/w/cpp/language/function#Return_type_deduction">Function return type deduction</a></dt>
+ <dd><code>auto</code> (and <code>decltype(auto)</code>) can also be used in
+ place of a function return type. The compiler deduces the return type from
+ the <code>return</code> statements in the function body, following the same
+ rules as for variable declarations:
+ <pre class="neutralcode">auto f() { return 0; } // The return type of f is int</pre>
+ <a href="#Lambda_expressions">Lambda expression</a> return types can be
+ deduced in the same way, but this is triggered by omitting the return type,
+ rather than by an explicit <code>auto</code>. Confusingly,
+ <a href="trailing_return">trailing return type</a> syntax for functions
+ also uses <code>auto</code> in the return-type position, but that doesn't
+ rely on type deduction; it's just an alternate syntax for an explicit
+ return type.
+ </dd>
+ <dt><a href="https://isocpp.org/wiki/faq/cpp14-language#generic-lambdas">Generic lambdas</a></dt>
+ <dd>A lambda expression can use the <code>auto</code> keyword in place of
+ one or more of its parameter types. This causes the lambda's call operator
+ to be a function template instead of an ordinary function, with a separate
+ template parameter for each <code>auto</code> function parameter:
+ <pre class="neutralcode">// Sort `vec` in increasing order
+std::sort(vec.begin(), vec.end(), [](auto lhs, auto rhs) { return lhs > rhs; });</pre>
+ </dd>
+ <dt><a href="https://isocpp.org/wiki/faq/cpp14-language#lambda-captures">Lambda init captures</a></dt>
+ <dd>Lambda captures can have explicit initializers, which can be used to
+ declare wholly new variables rather than only capturing existing ones:
+ <pre class="neutralcode">[x = 42, y = "foo"] { ... } // x is an int, and y is a const char*</pre>
+ This syntax doesn't allow the type to be specified; instead, it's deduced
+ using the rules for <code>auto</code> variables.
+ </dd>
+ <dt><a href="https://en.cppreference.com/w/cpp/language/class_template_argument_deduction">Class template argument deduction</a></dt>
+ <dd>See <a href="#CTAD">below</a>.</dd>
+ <dt><a href="https://en.cppreference.com/w/cpp/language/structured_binding">Structured bindings</a></dt>
+ <dd>When declaring a tuple, struct, or array using <code>auto</code>, you can
+ specify names for the individual elements instead of a name for the whole
+ object; these names are called "structured bindings", and the whole
+ declaration is called a "structured binding declaration". This syntax
+ provides no way of specifying the type of either the enclosing object
+ or the individual names:
+ <pre class="neutralcode">auto [iter, success] = my_map.insert({key, value});
+if (!success) {
+ iter->second = value;
+}</pre>
+ The <code>auto</code> can also be qualified with <code>const</code>,
+ <code>&</code>, and <code>&&</code>, but note that these qualifiers
+ technically apply to the anonymous tuple/struct/array, rather than the
+ individual bindings. The rules that determine the types of the bindings
+ are quite complex; the results tend to be unsurprising, except that
+ the binding types typically won't be references even if the declaration
+ declares a reference (but they will usually behave like references anyway).
+ </dd>
+
+<p>(These summaries omit many details and caveats; see the links for further
+ information.)</p>
+
+<p class="pros"></p>
+
+<ul>
+ <li>C++ type names can be long and cumbersome, especially when they
+ involve templates or namespaces.</li>
+ <li>When a C++ type name is repeated within a single declaration or a
+ small code region, the repetition may not be aiding readability.</li>
+ <li>It is sometimes safer to let the type be deduced, since that avoids
+ the possibility of unintended copies or type conversions.</li>
</ul>
-</div>
-<div class="cons">
-<p>Sometimes code is clearer when types are manifest,
-especially when a variable's initialization depends on
-things that were declared far away. In expressions
-like:</p>
+<p class="cons"></p>
+<p>C++ code is usually clearer when types are explicit,
+ especially when type deduction would depend on information from
+ distant parts of the code. In expressions like:</p>
<pre class="badcode">auto foo = x.add_foo();
auto i = y.Find(key);
</pre>
<p>it may not be obvious what the resulting types are if the type
-of <code>y</code> isn't very well known, or if <code>y</code> was
-declared many lines earlier.</p>
+ of <code>y</code> isn't very well known, or if <code>y</code> was
+ declared many lines earlier.</p>
-<p>Programmers have to understand the difference between
-<code>auto</code> and <code>const auto&</code> or
-they'll get copies when they didn't mean to.</p>
+<p>Programmers have to understand when type deduction will or won't
+ produce a reference type, or they'll get copies when they didn't
+ mean to.</p>
-<p>If an <code>auto</code> variable is used as part of an
-interface, e.g. as a constant in a header, then a
-programmer might change its type while only intending to
-change its value, leading to a more radical API change
-than intended.</p>
-</div>
+<p>If a deduced type is used as part of an interface, then a
+ programmer might change its type while only intending to
+ change its value, leading to a more radical API change
+ than intended.</p>
-<div class="decision">
+<p class="decision"></p>
-<p><code>auto</code> is permitted when it increases readability,
-particularly as described below. Never initialize an <code>auto</code>-typed
-variable with a braced initializer list.</p>
+<p>The fundamental rule is: use type deduction only to make the code
+ clearer or safer, and do not use it merely to avoid the
+ inconvenience of writing an explicit type. When judging whether the
+ code is clearer, keep in mind that your readers are not necessarily
+ on your team, or familiar with your project, so types that you and
+ your reviewer experience as as unnecessary clutter will very often
+ provide useful information to others. For example, you can assume that
+ the return type of <code>make_unique<Foo>()</code> is obvious,
+ but the return type of <code>MyWidgetFactory()</code> probably isn't.</p>
-<p>Specific cases where <code>auto</code> is allowed or encouraged:
-</p><ul>
-<li>(Encouraged) For iterators and other long/cluttery type names, particularly
-when the type is clear from context (calls
-to <code>find</code>, <code>begin</code>, or <code>end</code> for
-instance).</li>
-<li>(Allowed) When the type is clear from local context (in the same expression
-or within a few lines). Initialization of a pointer or smart pointer
-with calls
-to <code>new</code>
-commonly falls into this category, as does use of <code>auto</code> in
-a range-based loop over a container whose type is spelled out
-nearby.</li>
-<li>(Allowed) When the type doesn't matter because it isn't being used for
-anything other than equality comparison.</li>
-<li>(Encouraged) When iterating over a map with a range-based loop
-(because it is often assumed that the correct type
-is <code>std::pair<KeyType, ValueType></code> whereas it is actually
-<code>std::pair<const KeyType, ValueType></code>). This is
-particularly well paired with local <code>key</code>
-and <code>value</code> aliases for <code>.first</code>
-and <code>.second</code> (often const-ref).
-<pre class="code">for (const auto& item : some_map) {
- const KeyType& key = item.first;
- const ValType& value = item.second;
- // The rest of the loop can now just refer to key and value,
- // a reader can see the types in question, and we've avoided
- // the too-common case of extra copies in this iteration.
-}
-</pre>
-</li>
-</ul>
+ <p>These principles applies to all forms of type deduction, but the
+ details vary, as described in the following sections.</p>
-</div>
+<h4>Function template argument deduction</h4>
-</div>
+<p>Function template argument deduction is almost always OK. Type deduction
+ is the expected default way of interacting with function templates,
+ because it allows function templates to act like infinite sets of ordinary
+ function overloads. Consequently, function templates are almost always
+ designed so that template argument deduction is clear and safe, or
+ doesn't compile.</p>
-<h3 id="Braced_Initializer_List">Braced Initializer List</h3>
+<h4>Local variable type deduction</h4>
-<div class="summary">
-<p>You may use braced initializer lists.</p>
-</div>
+<p>For local variables, you can use type deduction to make the code clearer
+ by eliminating type information that is obvious or irrelevant, so that
+ the reader can focus on the meaningful parts of the code:
+ </p><pre class="neutralcode">std::unique_ptr<WidgetWithBellsAndWhistles> widget_ptr =
+ absl::make_unique<WidgetWithBellsAndWhistles>(arg1, arg2);
+absl::flat_hash_map<std::string,
+ std::unique_ptr<WidgetWithBellsAndWhistles>>::const_iterator
+ it = my_map_.find(key);
+std::array<int, 0> numbers = {4, 8, 15, 16, 23, 42};</pre>
-<div class="stylebody">
+ <pre class="goodcode">auto widget_ptr = absl::make_unique<WidgetWithBellsAndWhistles>(arg1, arg2);
+auto it = my_map_.find(key);
+std::array numbers = {4, 8, 15, 16, 23, 42};</pre>
-<p>In C++03, aggregate types (arrays and structs with no
-constructor) could be initialized with braced initializer lists.</p>
+<p>Types sometimes contain a mixture of useful information and boilerplate,
+ such as <code>it</code> in the example above: it's obvious that the
+ type is an iterator, and in many contexts the container type and even the
+ key type aren't relevant, but the type of the values is probably useful.
+ In such situations, it's often possible to define local variables with
+ explicit types that convey the relevant information:
+ </p><pre class="goodcode">auto it = my_map_.find(key);
+if (it != my_map_.end()) {
+ WidgetWithBellsAndWhistles& widget = *it->second;
+ // Do stuff with `widget`
+}</pre>
+ If the type is a template instance, and the parameters are
+ boilerplate but the template itself is informative, you can use
+ class template argument deduction to suppress the boilerplate. However,
+ cases where this actually provides a meaningful benefit are quite rare.
+ Note that class template argument deduction is also subject to a
+ <a href="#CTAD">separate style rule</a>.
-<pre>struct Point { int x; int y; };
-Point p = {1, 2};
-</pre>
+<p>Do not use <code>decltype(auto)</code> if a simpler option will work,
+ because it's a fairly obscure feature, so it has a high cost in code
+ clarity.</p>
-<p>In C++11, this syntax was generalized, and any object type can now
-be created with a braced initializer list, known as a
-<i>braced-init-list</i> in the C++ grammar. Here are a few examples
-of its use.</p>
+<h4>Return type deduction</h4>
-<pre>// Vector takes a braced-init-list of elements.
-std::vector<string> v{"foo", "bar"};
+<p>Use return type deduction (for both functions and lambdas) only if the
+ function body has a very small number of <code>return</code> statements,
+ and very little other code, because otherwise the reader may not be able
+ to tell at a glance what the return type is. Furthermore, use it only
+ if the function or lambda has a very narrow scope, because functions with
+ deduced return types don't define abstraction boundaries: the implementation
+ <em>is</em> the interface. In particular, public functions in header files
+ should almost never have deduced return types.</p>
-// Basically the same, ignoring some small technicalities.
-// You may choose to use either form.
-std::vector<string> v = {"foo", "bar"};
+<h4>Parameter type deduction</h4>
-// Usable with 'new' expressions.
-auto p = new vector<string>{"foo", "bar"};
+<p><code>auto</code> parameter types for lambdas should be used with caution,
+ because the actual type is determined by the code that calls the lambda,
+ rather than by the definition of the lambda. Consequently, an explicit
+ type will almost always be clearer unless the lambda is explicitly called
+ very close to where it's defined (so that the reader can easily see both),
+ or the lambda is passed to an interface so well-known that it's
+ obvious what arguments it will eventually be called with (e.g.
+ the <code>std::sort</code> example above).</p>
-// A map can take a list of pairs. Nested braced-init-lists work.
-std::map<int, string> m = {{1, "one"}, {2, "2"}};
+<h4>Lambda init captures</h4>
-// A braced-init-list can be implicitly converted to a return type.
-std::vector<int> test_function() { return {1, 2, 3}; }
+<p>Init captures are covered by a <a href="#Lambda_expressions">more specific
+ style rule</a>, which largely supersedes the general rules for
+ type deduction.</p>
-// Iterate over a braced-init-list.
-for (int i : {-1, -2, -3}) {}
+<h4>Structured bindings</h4>
-// Call a function using a braced-init-list.
-void TestFunction2(std::vector<int> v) {}
-TestFunction2({1, 2, 3});
-</pre>
+<p>Unlike other forms of type deduction, structured bindings can actually
+ give the reader additional information, by giving meaningful names to the
+ elements of a larger object. This means that a structured binding declaration
+ may provide a net readability improvement over an explicit type, even in cases
+ where <code>auto</code> would not. Structured bindings are especially
+ beneficial when the object is a pair or tuple (as in the <code>insert</code>
+ example above), because they don't have meaningful field names to begin with,
+ but note that you generally <a href="#Structs_vs._Tuples">shouldn't use
+ pairs or tuples</a> unless a pre-existing API like <code>insert</code>
+ forces you to.</p>
-<p>A user-defined type can also define a constructor and/or assignment operator
-that take <code>std::initializer_list<T></code>, which is automatically
-created from <i>braced-init-list</i>:</p>
+<p>If the object being bound is a struct, it may sometimes be helpful to
+ provide names that are more specific to your usage, but keep in mind that
+ this may also mean the names are less recognizable to your reader than the
+ field names. We recommend using a comment to indicate the name of the
+ underlying field, if it doesn't match the name of the binding, using the
+ same syntax as for function parameter comments:
+ </p><pre>auto [/*field_name1=*/ bound_name1, /*field_name2=*/ bound_name2] = ...</pre>
+ As with function parameter comments, this can enable tools to detect if
+ you get the order of the fields wrong.
-<pre>class MyType {
- public:
- // std::initializer_list references the underlying init list.
- // It should be passed by value.
- MyType(std::initializer_list<int> init_list) {
- for (int i : init_list) append(i);
- }
- MyType& operator=(std::initializer_list<int> init_list) {
- clear();
- for (int i : init_list) append(i);
- }
-};
-MyType m{2, 3, 5, 7};
-</pre>
+<h3 id="CTAD">Class template argument deduction</h3>
-<p>Finally, brace initialization can also call ordinary
-constructors of data types, even if they do not have
-<code>std::initializer_list<T></code> constructors.</p>
+<p>Use class template argument deduction only with templates that have
+ explicitly opted into supporting it.</p>
-<pre>double d{1.23};
-// Calls ordinary constructor as long as MyOtherType has no
-// std::initializer_list constructor.
-class MyOtherType {
- public:
- explicit MyOtherType(string);
- MyOtherType(int, string);
-};
-MyOtherType m = {1, "b"};
-// If the constructor is explicit, you can't use the "= {}" form.
-MyOtherType m{"b"};
-</pre>
+<p class="definition"></p>
+<p><a href="https://en.cppreference.com/w/cpp/language/class_template_argument_deduction">Class
+ template argument deduction</a> (often abbreviated "CTAD") occurs when
+ a variable is declared with a type that names a template, and the template
+ argument list is not provided (not even empty angle brackets):
+ </p><pre class="neutralcode">std::array a = {1, 2, 3}; // `a` is a std::array<int, 3></pre>
+ The compiler deduces the arguments from the initializer using the
+ template's "deduction guides", which can be explicit or implicit.
-<p>Never assign a <i>braced-init-list</i> to an auto
-local variable. In the single element case, what this
-means can be confusing.</p>
+<p>Explicit deduction guides look like function declarations with trailing
+ return types, except that there's no leading <code>auto</code>, and the
+ function name is the name of the template. For example, the above example
+ relies on this deduction guide for <code>std::array</code>:
+ </p><pre class="neutralcode">namespace std {
+template <class T, class... U>
+array(T, U...) -> std::array<T, 1 + sizeof...(U)>;
+}</pre>
+ Constructors in a primary template (as opposed to a template specialization)
+ also implicitly define deduction guides.
-<pre class="badcode">auto d = {1.23}; // d is a std::initializer_list<double>
-</pre>
+<p>When you declare a variable that relies on CTAD, the compiler selects
+ a deduction guide using the rules of constructor overload resolution,
+ and that guide's return type becomes the type of the variable.</p>
-<pre>auto d = double{1.23}; // Good -- d is a double, not a std::initializer_list.
-</pre>
+<p class="pros"></p>
+<p>CTAD can sometimes allow you to omit boilerplate from your code.</p>
-<p>See <a href="#Braced_Initializer_List_Format">Braced_Initializer_List_Format</a> for formatting.</p>
+<p class="cons"></p>
+<p>The implicit deduction guides that are generated from constructors
+ may have undesirable behavior, or be outright incorrect. This is
+ particularly problematic for constructors written before CTAD was
+ introduced in C++17, because the authors of those constructors had no
+ way of knowing about (much less fixing) any problems that their
+ constructors would cause for CTAD. Furthermore, adding explicit deduction
+ guides to fix those problems might break any existing code that relies on
+ the implicit deduction guides.</p>
-</div>
+<p>CTAD also suffers from many of the same drawbacks as <code>auto</code>,
+ because they are both mechanisms for deducing all or part of a variable's
+ type from its initializer. CTAD does give the reader more information
+ than <code>auto</code>, but it also doesn't give the reader an obvious
+ cue that information has been omitted.</p>
+
+<p class="decision"></p>
+<p>Do not use CTAD with a given template unless the template's maintainers
+ have opted into supporting use of CTAD by providing at least one explicit
+ deduction guide (all templates in the <code>std</code> namespace are
+ also presumed to have opted in). This should be enforced with a compiler
+ warning if available.</p>
+
+<p>Uses of CTAD must also follow the general rules on
+ <a href="#Type_deduction">Type deduction</a>.</p>
<h3 id="Lambda_expressions">Lambda expressions</h3>
-<div class="summary">
<p>Use lambda expressions where appropriate. Prefer explicit captures
when the lambda will escape the current scope.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
-
+<p class="definition"></p>
<p> Lambda expressions are a concise way of creating anonymous
function objects. They're often useful when passing
functions as arguments. For example:</p>
@@ -3449,8 +3505,8 @@
</pre>
-Default captures implicitly capture any variable referenced in the
-lambda body, including <code>this</code> if any members are used:
+<p>Default captures implicitly capture any variable referenced in the
+lambda body, including <code>this</code> if any members are used:</p>
<pre>const std::vector<int> lookup_table = ...;
std::vector<int> indices = ...;
@@ -3461,13 +3517,24 @@
});
</pre>
-<p>Lambdas were introduced in C++11 along with a set of utilities
-for working with function objects, such as the polymorphic
-wrapper <code>std::function</code>.
-</p>
-</div>
+<p>A variable capture can also have an explicit initializer, which can
+ be used for capturing move-only variables by value, or for other situations
+ not handled by ordinary reference or value captures:
+ </p><pre>std::unique_ptr<Foo> foo = ...;
+[foo = std::move(foo)] () {
+ ...
+}</pre>
+ Such captures (often called "init captures" or "generalized lambda captures")
+ need not actually "capture" anything from the enclosing scope, or even have
+ a name from the enclosing scope; this syntax is a fully general way to define
+ members of a lambda object:
+ <pre class="neutralcode">[foo = std::vector<int>({1, 2, 3})] () {
+ ...
+}</pre>
+ The type of a capture with an initializer is deduced using the same rules
+ as <code>auto</code>.
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>Lambdas are much more concise than other ways of
defining function objects to be passed to STL
@@ -3484,9 +3551,8 @@
to write functions that take bound functions as
arguments.</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Variable capture in lambdas can be a source of dangling-pointer
bugs, particularly if a lambda escapes the current scope.</li>
@@ -3497,14 +3563,25 @@
This is especially confusing when capturing 'this' by value, since the use
of 'this' is often implicit.</li>
+ <li>Captures actually declare new variables (whether or not the captures have
+ initializers), but they look nothing like any other variable declaration
+ syntax in C++. In particular, there's no place for the variable's type,
+ or even an <code>auto</code> placeholder (although init captures can
+ indicate it indirectly, e.g. with a cast). This can make it difficult to
+ even recognize them as declarations.</li>
+
+ <li>Init captures inherently rely on <a href="#Type_deduction">type
+ deduction</a>, and suffer from many of the same drawbacks as
+ <code>auto</code>, with the additional problem that the syntax doesn't
+ even cue the reader that deduction is taking place.</li>
+
<li>It's possible for use of lambdas to get out of
hand; very long nested anonymous functions can make
code harder to understand.</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<ul>
<li>Use lambda expressions where appropriate, with formatting as
described <a href="#Formatting_Lambda_Expressions">below</a>.</li>
@@ -3543,48 +3620,41 @@
variables is obvious at a glance. Prefer not to write long or
complex lambdas with default capture by value.
</li>
-<li>Keep unnamed lambdas short. If a lambda body is more than
-maybe five lines long, prefer to give the lambda a name, or to
-use a named function instead of a lambda.</li>
-<li>Specify the return type of the lambda explicitly if that will
-make it more obvious to readers, as with
-<a href="#auto"><code>auto</code></a>.</li>
+<li>Use captures only to actually capture variables from the enclosing scope.
+ Do not use captures with initializers to introduce new names, or
+ to substantially change the meaning of an existing name. Instead,
+ declare a new variable in the conventional way and then capture it,
+ or avoid the lambda shorthand and define a function object explicitly.</li>
+<li>See the section on <a href="#Type_deduction">type deduction</a>
+ for guidance on specifying the parameter and return types.</li>
</ul>
-</div>
-
-</div>
<h3 id="Template_metaprogramming">Template metaprogramming</h3>
-<div class="summary">
+
<p>Avoid complicated template programming.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p>Template metaprogramming refers to a family of techniques that
exploit the fact that the C++ template instantiation mechanism is
Turing complete and can be used to perform arbitrary compile-time
computation in the type domain.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Template metaprogramming allows extremely flexible interfaces that
are type safe and high performance. Facilities like
<a href="https://code.google.com/p/googletest/">Google Test</a>,
<code>std::tuple</code>, <code>std::function</code>, and
Boost.Spirit would be impossible without it.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>The techniques used in template metaprogramming are often obscure
to anyone but language experts. Code that uses templates in
complicated ways is often unreadable, and is hard to debug or
maintain.</p>
-<p>Template metaprogramming often leads to extremely poor compiler
+<p>Template metaprogramming often leads to extremely poor compile
time error messages: even if an interface is simple, the complicated
implementation details become visible when the user does something
wrong.</p>
@@ -3597,9 +3667,8 @@
after template expansion. It can be difficult to automatically work
back to the original source construct that needs to be
rewritten.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Template metaprogramming sometimes allows cleaner and easier-to-use
interfaces than would be possible without it, but it's also often a
temptation to be overly clever. It's best used in a small number of
@@ -3630,42 +3699,31 @@
be tweaked as necessary so that the error messages are understandable
and actionable from a user point of view.</p>
-</div>
-</div>
-
-
<h3 id="Boost">Boost</h3>
-<div class="summary">
<p>Use only approved libraries from the Boost library
collection.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p> The
<a href="https://www.boost.org/">
Boost library collection</a> is a popular collection of
peer-reviewed, free, open-source C++ libraries.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p>Boost code is generally very high-quality, is widely
portable, and fills many important gaps in the C++
standard library, such as type traits and better binders.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Some Boost libraries encourage coding practices which can
hamper readability, such as metaprogramming and other
advanced template techniques, and an excessively
"functional" style of programming. </p>
-</div>
-<div class="decision">
+<p class="decision"></p>
-
+
<div>
<p>In order to maintain a high level of readability for
@@ -3713,6 +3771,9 @@
<li><a href="https://www.boost.org/libs/math/doc/html/special.html">
Special Functions</a> from <code>boost/math/special_functions</code></li>
+ <li><a href="https://www.boost.org/libs/math/doc/html/root_finding.html">
+ Root Finding Functions</a> from <code>boost/math/tools</code></li>
+
<li><a href="https://www.boost.org/libs/multi_index/">
Multi-index</a> from <code>boost/multi_index</code></li>
@@ -3737,44 +3798,21 @@
<p>We are actively considering adding other Boost
features to the list, so this list may be expanded in
the future.</p>
-</div>
+</div>
-<p>The following libraries are permitted, but their use
-is discouraged because they've been superseded by
-standard libraries in C++11:</p>
-<ul>
- <li><a href="https://www.boost.org/libs/array/">
- Array</a> from <code>boost/array.hpp</code>: use
- <a href="http://en.cppreference.com/w/cpp/container/array">
- <code>std::array</code></a> instead.</li>
-
- <li><a href="https://www.boost.org/libs/ptr_container/">
- Pointer Container</a> from <code>boost/ptr_container</code>: use containers of
- <a href="http://en.cppreference.com/w/cpp/memory/unique_ptr">
- <code>std::unique_ptr</code></a> instead.</li>
-</ul>
-</div>
-
-</div>
-
-
<h3 id="std_hash">std::hash</h3>
-<div class="summary">
<p>Do not define specializations of <code>std::hash</code>.</p>
-</div>
-<div class="stylebody">
-
-<div class="definition">
+<p class="definition"></p>
<p><code>std::hash<T></code> is the function object that the
C++11 hash containers use to hash keys of type <code>T</code>,
unless the user explicitly specifies a different hash function. For
-example, <code>std::unordered_map<int, string></code> is a hash
+example, <code>std::unordered_map<int, std::string></code> is a hash
map that uses <code>std::hash<int></code> to hash its keys,
-whereas <code>std::unordered_map<int, string, MyIntHash></code>
+whereas <code>std::unordered_map<int, std::string, MyIntHash></code>
uses <code>MyIntHash</code>.</p>
<p><code>std::hash</code> is defined for all integral, floating-point,
@@ -3782,17 +3820,15 @@
types such as <code>string</code> and <code>unique_ptr</code>. Users
can enable it to work for their own types by defining specializations
of it for those types.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<p><code>std::hash</code> is easy to use, and simplifies the code
since you don't have to name it explicitly. Specializing
<code>std::hash</code> is the standard way of specifying how to
hash a type, so it's what outside resources will teach, and what
new engineers will expect.</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p><code>std::hash</code> is hard to specialize. It requires a lot
of boilerplate code, and more importantly, it combines responsibility
for identifying the hash inputs with responsibility for executing the
@@ -3816,9 +3852,8 @@
<p>Due to exactly that issue, <code>std::hash</code> does not work
with <code>std::pair</code> or <code>std::tuple</code>, and the
language does not allow us to extend it to support them.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>You can use <code>std::hash</code> with the types that it supports
"out of the box", but do not specialize it to support additional types.
If you need a hash table with a key type that <code>std::hash</code>
@@ -3837,47 +3872,12 @@
<p>We are planning to provide a hash function that can work with any type,
using a new customization mechanism that doesn't have the drawbacks of
<code>std::hash</code>.</p>
-</div>
-</div>
-<h3 id="C++11">C++11</h3>
-<div class="summary">
-<p>Use libraries and language extensions from C++11 when appropriate.
-Consider portability to other environments
-before using C++11 features in your
-project. </p>
+<h3 id="Other_Features"><a name="C++11">Other C++ Features</a></h3>
-</div>
-
-<div class="stylebody">
-
-<div class="definition">
-<p> C++11 contains <a href="https://en.wikipedia.org/wiki/C%2B%2B11">
-significant changes</a> both to the language and
-libraries. </p>
-</div>
-
-<div class="pros">
-<p>C++11 was the official standard until august 2014, and
-is supported by most C++ compilers. It standardizes
-some common C++ extensions that we use already, allows
-shorthands for some operations, and has some performance
-and safety improvements.</p>
-</div>
-
-<div class="cons">
-<p>The C++11 standard is substantially more complex than
-its predecessor (1,300 pages versus 800 pages), and is
-unfamiliar to many developers. The long-term effects of
-some features on code readability and maintenance are
-unknown. We cannot predict when its various features will
-be implemented uniformly by tools that may be of
-interest, particularly in the case of projects that are
-forced to use older versions of tools.</p>
-
-<p>As with <a href="#Boost">Boost</a>, some C++11
+<p>As with <a href="#Boost">Boost</a>, some modern C++
extensions encourage coding practices that hamper
readability—for example by removing
checked redundancy (such as type names) that may be
@@ -3886,23 +3886,12 @@
available through existing mechanisms, which may lead to confusion
and conversion costs.</p>
-
-</div>
-
-<div class="decision">
-
-<p>C++11 features may be used unless specified otherwise.
-In addition to what's described in the rest of the style
-guide, the following C++11 features may not be used:</p>
+<p class="decision"></p>
+<p>In addition to what's described in the rest of the style
+guide, the following C++ features may not be used:</p>
<ul>
-
-
-
-
-
-
<li>Compile-time rational numbers
(<code><ratio></code>), because of concerns that
@@ -3913,35 +3902,29 @@
<code><fenv.h></code> headers, because many
compilers do not support those features reliably.</li>
- <li>Ref-qualifiers on member functions, such as <code>void X::Foo()
- &</code> or <code>void X::Foo() &&</code>, because of concerns
- that they're an overly obscure feature.</li>
+ <li>The <code><filesystem></code> header, which
-
+ does not have sufficient support for testing, and suffers
+ from inherent security vulnerabilities.</li>
-
+
</ul>
-</div>
-
-</div>
<h3 id="Nonstandard_Extensions">Nonstandard Extensions</h3>
-<div class="summary">
<p>Nonstandard extensions to C++ may not be used unless otherwise specified.</p>
-</div>
-<div class="stylebody">
-<div class="definition">
+
+<p class="definition"></p>
<p>Compilers support various extensions that are not part of standard C++. Such
extensions include GCC's <code>__attribute__</code>, intrinsic functions such
as <code>__builtin_prefetch</code>, designated initializers (e.g.
<code>Foo f = {.field = 3}</code>), inline assembly, <code>__COUNTER__</code>,
<code>__PRETTY_FUNCTION__</code>, compound statement expressions (e.g.
<code>foo = ({ int x; Bar(&x); x })</code>, variable-length arrays and
- <code>alloca()</code>, and the <code>a?:b</code> syntax.</p>
-</div>
+ <code>alloca()</code>, and the "<a href="https://en.wikipedia.org/wiki/Elvis_operator">Elvis Operator</a>"
+ <code>a?:b</code>.</p>
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>Nonstandard extensions may provide useful features that do not exist
in standard C++. For example, some people think that designated
@@ -3950,9 +3933,8 @@
<li>Important performance guidance to the compiler can only be specified
using extensions.</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>Nonstandard extensions do not work in all compilers. Use of nonstandard
extensions reduces portability of code.</li>
@@ -3962,47 +3944,44 @@
<li>Nonstandard extensions add to the language features that a reader must
know to understand the code.</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Do not use nonstandard extensions. You may use portability wrappers that
are implemented using nonstandard extensions, so long as those wrappers
-
+
are provided by a designated project-wide
portability header.</p>
-</div>
-</div>
<h3 id="Aliases">Aliases</h3>
-<div class="summary">
<p>Public aliases are for the benefit of an API's user, and should be clearly documented.</p>
-</div>
-<div class="stylebody">
-<div class="definition">
+
+<p class="definition"></p>
<p>There are several ways to create names that are aliases of other entities:</p>
<pre>typedef Foo Bar;
using Bar = Foo;
using other_namespace::Foo;
</pre>
+ <p>In new code, <code>using</code> is preferable to <code>typedef</code>,
+ because it provides a more consistent syntax with the rest of C++ and works
+ with templates.</p>
+
<p>Like other declarations, aliases declared in a header file are part of that
header's public API unless they're in a function definition, in the private portion of a class,
or in an explicitly-marked internal namespace. Aliases in such areas or in .cc files are
implementation details (because client code can't refer to them), and are not restricted by this
rule.</p>
-</div>
-<div class="pros">
+<p class="pros"></p>
<ul>
<li>Aliases can improve readability by simplifying a long or complicated name.</li>
<li>Aliases can reduce duplication by naming in one place a type used repeatedly in an API,
which <em>might</em> make it easier to change the type later.
</li>
</ul>
-</div>
-<div class="cons">
+<p class="cons"></p>
<ul>
<li>When placed in a header where client code can refer to them, aliases increase the
number of entities in that header's API, increasing its complexity.</li>
@@ -4016,9 +3995,8 @@
it is unclear whether the alias is guaranteed to be identical to the type it aliases,
to have the same API, or only to be usable in specified narrow ways</li>
</ul>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p>Don't put an alias in your public API just to save typing in the implementation;
do so only if you intend it to be used by your clients.</p>
<p>When defining a public alias, document the intent of
@@ -4031,37 +4009,34 @@
</p>
<p>For example, these aliases document how they are intended to be used in client code:</p>
-<pre>namespace a {
+<pre>namespace mynamespace {
// Used to store field measurements. DataPoint may change from Bar* to some internal type.
// Client code should treat it as an opaque pointer.
-using DataPoint = foo::bar::Bar*;
+using DataPoint = foo::Bar*;
// A set of measurements. Just an alias for user convenience.
using TimeSeries = std::unordered_set<DataPoint, std::hash<DataPoint>, DataPointComparator>;
-} // namespace a
+} // namespace mynamespace
</pre>
<p>These aliases don't document intended use, and half of them aren't meant for client use:</p>
-<pre class="badcode">namespace a {
+<pre class="badcode">namespace mynamespace {
// Bad: none of these say how they should be used.
-using DataPoint = foo::bar::Bar*;
+using DataPoint = foo::Bar*;
using std::unordered_set; // Bad: just for local convenience
using std::hash; // Bad: just for local convenience
typedef unordered_set<DataPoint, hash<DataPoint>, DataPointComparator> TimeSeries;
-} // namespace a
+} // namespace mynamespace
</pre>
<p>However, local convenience aliases are fine in function definitions, private sections of
classes, explicitly marked internal namespaces, and in .cc files:</p>
<pre>// In a .cc file
-using std::unordered_set;
+using foo::Bar;
</pre>
-</div>
-</div>
-
<h2 id="Naming">Naming</h2>
<p>The most important consistency rules are those that govern
@@ -4080,56 +4055,83 @@
<h3 id="General_Naming_Rules">General Naming Rules</h3>
-<div class="summary">
-<p>Names should be descriptive; avoid abbreviation.</p>
-</div>
+<p>Optimize for readability using names that would be clear
+even to people on a different team.</p>
-<div class="stylebody">
-<p>Give as descriptive a name as possible, within reason.
+<p>Use names that describe the purpose or intent of the object.
Do not worry about saving horizontal space as it is far
more important to make your code immediately
-understandable by a new reader. Do not use abbreviations
-that are ambiguous or unfamiliar to readers outside your
-project, and do not abbreviate by deleting letters within
-a word.</p>
+understandable by a new reader. Minimize the use of
+abbreviations that would likely be unknown to someone outside
+your project (especially acronyms and initialisms). Do not
+abbreviate by deleting letters within a word. As a rule of thumb,
+an abbreviation is probably OK if it's listed in
+ Wikipedia. Generally speaking, descriptiveness should be
+proportional to the name's scope of visibility. For example,
+<code>n</code> may be a fine name within a 5-line function,
+but within the scope of a class, it's likely too vague.</p>
-<pre>int price_count_reader; // No abbreviation.
-int num_errors; // "num" is a widespread convention.
-int num_dns_connections; // Most people know what "DNS" stands for.
+<pre>class MyClass {
+ public:
+ int CountFooErrors(const std::vector<Foo>& foos) {
+ int n = 0; // Clear meaning given limited scope and context
+ for (const auto& foo : foos) {
+ ...
+ ++n;
+ }
+ return n;
+ }
+ void DoSomethingImportant() {
+ std::string fqdn = ...; // Well-known abbreviation for Fully Qualified Domain Name
+ }
+ private:
+ const int kMaxAllowedConnections = ...; // Clear meaning within context
+};
</pre>
-<pre class="badcode">int n; // Meaningless.
-int nerr; // Ambiguous abbreviation.
-int n_comp_conns; // Ambiguous abbreviation.
-int wgc_connections; // Only your group knows what this stands for.
-int pc_reader; // Lots of things can be abbreviated "pc".
-int cstmr_id; // Deletes internal letters.
+<pre class="badcode">class MyClass {
+ public:
+ int CountFooErrors(const std::vector<Foo>& foos) {
+ int total_number_of_foo_errors = 0; // Overly verbose given limited scope and context
+ for (int foo_index = 0; foo_index < foos.size(); ++foo_index) { // Use idiomatic `i`
+ ...
+ ++total_number_of_foo_errors;
+ }
+ return total_number_of_foo_errors;
+ }
+ void DoSomethingImportant() {
+ int cstmr_id = ...; // Deletes internal letters
+ }
+ private:
+ const int kNum = ...; // Unclear meaning within broad scope
+};
</pre>
<p>Note that certain universally-known abbreviations are OK, such as
<code>i</code> for an iteration variable and <code>T</code> for a
template parameter.</p>
+<p>For the purposes of the naming rules below, a "word" is anything that you
+would write in English without internal spaces. This includes abbreviations and
+acronyms; e.g., for "<a href="https://en.wikipedia.org/wiki/Camel_case">camel
+case</a>" or "Pascal case," in which the first letter of each word is
+capitalized, use a name like <code>StartRpc()</code>, not
+<code>StartRPC()</code>.</p>
+
<p>Template parameters should follow the naming style for their
category: type template parameters should follow the rules for
<a href="#Type_Names">type names</a>, and non-type template
parameters should follow the rules for <a href="#Variable_Names">
variable names</a>.
-</p></div>
+</p><h3 id="File_Names">File Names</h3>
-<h3 id="File_Names">File Names</h3>
-
-<div class="summary">
<p>Filenames should be all lowercase and can include
underscores (<code>_</code>) or dashes (<code>-</code>).
Follow the convention that your
-
+
project uses. If there is no consistent
local pattern to follow, prefer "_".</p>
-</div>
-
-<div class="stylebody">
<p>Examples of acceptable file names:</p>
@@ -4155,21 +4157,11 @@
<code>foo_bar.cc</code>, defining a class called
<code>FooBar</code>.</p>
-<p>Inline functions must be in a <code>.h</code> file. If
-your inline functions are very short, they should go
-directly into your <code>.h</code> file. </p>
-
-</div>
-
<h3 id="Type_Names">Type Names</h3>
-<div class="summary">
<p>Type names start with a capital letter and have a capital
letter for each new word, with no underscores:
<code>MyExcitingClass</code>, <code>MyExcitingEnum</code>.</p>
-</div>
-
-<div class="stylebody">
<p>The names of all types — classes, structs, type aliases,
enums, and type template parameters — have the same naming convention.
@@ -4182,41 +4174,34 @@
struct UrlTableProperties { ...
// typedefs
-typedef hash_map<UrlTableProperties *, string> PropertiesMap;
+typedef hash_map<UrlTableProperties *, std::string> PropertiesMap;
// using aliases
-using PropertiesMap = hash_map<UrlTableProperties *, string>;
+using PropertiesMap = hash_map<UrlTableProperties *, std::string>;
// enums
enum UrlTableErrors { ...
</pre>
-</div>
-
<h3 id="Variable_Names">Variable Names</h3>
-<div class="summary">
<p>The names of variables (including function parameters) and data members are
all lowercase, with underscores between words. Data members of classes (but not
structs) additionally have trailing underscores. For instance:
<code>a_local_variable</code>, <code>a_struct_data_member</code>,
<code>a_class_data_member_</code>.</p>
-</div>
-<div class="stylebody">
-
-<h4 class="stylepoint_subsection">Common Variable names</h4>
+<h4>Common Variable names</h4>
<p>For example:</p>
-<pre>string table_name; // OK - uses underscore.
-string tablename; // OK - all lowercase.
+<pre>std::string table_name; // OK - lowercase with underscore.
</pre>
-<pre class="badcode">string tableName; // Bad - mixed case.
+<pre class="badcode">std::string tableName; // Bad - mixed case.
</pre>
-<h4 class="stylepoint_subsection">Class Data Members</h4>
+<h4>Class Data Members</h4>
<p>Data members of classes, both static and non-static, are
named like ordinary nonmember variables, but with a
@@ -4225,20 +4210,19 @@
<pre>class TableInfo {
...
private:
- string table_name_; // OK - underscore at end.
- string tablename_; // OK.
+ std::string table_name_; // OK - underscore at end.
static Pool<TableInfo>* pool_; // OK.
};
</pre>
-<h4 class="stylepoint_subsection">Struct Data Members</h4>
+<h4>Struct Data Members</h4>
<p>Data members of structs, both static and non-static,
are named like ordinary nonmember variables. They do not have
the trailing underscores that data members in classes have.</p>
<pre>struct UrlTableProperties {
- string name;
+ std::string name;
int num_entries;
static Pool<UrlTableProperties>* pool;
};
@@ -4249,44 +4233,30 @@
Classes</a> for a discussion of when to use a struct
versus a class.</p>
-</div>
-
<h3 id="Constant_Names">Constant Names</h3>
-<div class="summary">
- <p>Variables declared constexpr or const, and whose value is fixed for
- the duration of the program, are named with a leading "k" followed
- by mixed case. For example:</p>
-</div>
+<p>Variables declared constexpr or const, and whose value is fixed for
+the duration of the program, are named with a leading "k" followed
+by mixed case. Underscores can be used as separators in the rare cases
+where capitalization cannot be used for separation. For example:</p>
<pre>const int kDaysInAWeek = 7;
+const int kAndroid8_0_0 = 24; // Android 8.0.0
</pre>
-<div class="stylebody">
-
- <p>All such variables with static storage duration (i.e. statics and globals,
- see <a href="http://en.cppreference.com/w/cpp/language/storage_duration#Storage_duration">
- Storage Duration</a> for details) should be named this way. This
- convention is optional for variables of other storage classes, e.g. automatic
- variables, otherwise the usual variable naming rules apply.</p><p>
-
-</p></div>
+<p>All such variables with static storage duration (i.e. statics and globals,
+see <a href="http://en.cppreference.com/w/cpp/language/storage_duration#Storage_duration">
+Storage Duration</a> for details) should be named this way. This
+convention is optional for variables of other storage classes, e.g. automatic
+variables, otherwise the usual variable naming rules apply.</p>
<h3 id="Function_Names">Function Names</h3>
-<div class="summary">
<p>Regular functions have mixed case; accessors and mutators may be named
like variables.</p>
-</div>
-
-<div class="stylebody">
<p>Ordinarily, functions should start with a capital letter and have a
-capital letter for each new word
-(a.k.a. "<a href="https://en.wikipedia.org/wiki/Camel_case">Camel
-Case</a>" or "Pascal case"). Such names should not have
-underscores. Prefer to capitalize acronyms as single words
-(i.e. <code>StartRpc()</code>, not <code>StartRPC()</code>).</p>
+capital letter for each new word.</p>
<pre>AddTableEntry()
DeleteUrl()
@@ -4295,36 +4265,29 @@
<p>(The same naming rule applies to class- and namespace-scope
constants that are exposed as part of an API and that are intended to look
-like functions, because the fact that they're
-objects rather than functions is an unimportant implementation detail.)</p>
+like functions, because the fact that they're objects rather than functions
+is an unimportant implementation detail.)</p>
<p>Accessors and mutators (get and set functions) may be named like
variables. These often correspond to actual member variables, but this is
not required. For example, <code>int count()</code> and <code>void
set_count(int count)</code>.</p>
-</div>
-
<h3 id="Namespace_Names">Namespace Names</h3>
-<div class="summary">
Namespace names are all lower-case. Top-level namespace names are
based on the project name
. Avoid collisions
between nested namespaces and well-known top-level namespaces.
-</div>
-<div class="stylebody">
<p>The name of a top-level namespace should usually be the
name of the project or team whose code is contained in that
namespace. The code in that namespace should usually be in
-a directory whose basename matches the namespace name (or
+a directory whose basename matches the namespace name (or in
subdirectories thereof).</p>
-
-
<p>Keep in mind that the <a href="#General_Naming_Rules">rule
against abbreviated names</a> applies to namespaces just as much
as variable names. Code inside the namespace seldom needs to
@@ -4347,18 +4310,12 @@
(<code>websearch::index::frobber_internal</code> for use
in <code>frobber.h</code>)</p>
-</div>
-
<h3 id="Enumerator_Names">Enumerator Names</h3>
-<div class="summary">
<p>Enumerators (for both scoped and unscoped enums) should be named <i>either</i> like
<a href="#Constant_Names">constants</a> or like
<a href="#Macro_Names">macros</a>: either <code>kEnumName</code> or
<code>ENUM_NAME</code>.</p>
-</div>
-
-<div class="stylebody">
<p>Preferably, the individual enumerators should be named
like <a href="#Constant_Names">constants</a>. However, it
@@ -4369,7 +4326,7 @@
therefore mixed case.</p>
<pre>enum UrlTableErrors {
- kOK = 0,
+ kOk = 0,
kErrorOutOfMemory,
kErrorMalformedInput,
};
@@ -4391,17 +4348,12 @@
-</div>
-
<h3 id="Macro_Names">Macro Names</h3>
-<div class="summary">
<p>You're not really going to <a href="#Preprocessor_Macros">
define a macro</a>, are you? If you do, they're like this:
-<code>MY_MACRO_THAT_SCARES_SMALL_CHILDREN</code>.</p>
-</div>
-
-<div class="stylebody">
+<code>MY_MACRO_THAT_SCARES_SMALL_CHILDREN_AND_ADULTS_ALIKE</code>.
+</p>
<p>Please see the <a href="#Preprocessor_Macros">description
of macros</a>; in general macros should <em>not</em> be used.
@@ -4412,17 +4364,11 @@
#define PI_ROUNDED 3.0
</pre>
-</div>
-
<h3 id="Exceptions_to_Naming_Rules">Exceptions to Naming Rules</h3>
-<div class="summary">
<p>If you are naming something that is analogous to an
existing C or C++ entity then you can follow the existing
naming convention scheme.</p>
-</div>
-
-<div class="stylebody">
<dl>
<dt><code>bigopen()</code></dt>
@@ -4442,67 +4388,58 @@
<dd>a constant, as in <code>INT_MAX</code></dd>
</dl>
-</div>
-
<h2 id="Comments">Comments</h2>
-<p>Though a pain to write, comments are absolutely vital to
-keeping our code readable. The following rules describe what
-you should comment and where. But remember: while comments are
-very important, the best code is self-documenting. Giving
-sensible names to types and variables is much better than using
-obscure names that you must then explain through comments.</p>
+<p>Comments are absolutely vital to keeping our code readable. The following rules describe what you
+should comment and where. But remember: while comments are very important, the best code is
+self-documenting. Giving sensible names to types and variables is much better than using obscure
+names that you must then explain through comments.</p>
<p>When writing your comments, write for your audience: the
-next
+next
contributor who will need to
understand your code. Be generous — the next
one may be you!</p>
<h3 id="Comment_Style">Comment Style</h3>
-<div class="summary">
<p>Use either the <code>//</code> or <code>/* */</code>
syntax, as long as you are consistent.</p>
-</div>
-
-<div class="stylebody">
<p>You can use either the <code>//</code> or the <code>/*
*/</code> syntax; however, <code>//</code> is
<em>much</em> more common. Be consistent with how you
comment and what style you use where.</p>
-</div>
-
<h3 id="File_Comments">File Comments</h3>
-<div class="summary">
+<div>
<p>Start each file with license boilerplate.</p>
+</div>
<p>File comments describe the contents of a file. If a file declares,
implements, or tests exactly one abstraction that is documented by a comment
at the point of declaration, file comments are not required. All other files
must have file comments.</p>
-</div>
-
-<div class="stylebody">
-
-<h4 class="stylepoint_subsection">Legal Notice and Author
+<h4>Legal Notice and Author
Line</h4>
+<div>
<p>Every file should contain license
boilerplate. Choose the appropriate boilerplate for the
license used by the project (for example, Apache 2.0,
BSD, LGPL, GPL).</p>
+</div>
<p>If you make significant changes to a file with an
-author line, consider deleting the author line.</p>
+author line, consider deleting the author line.
+New files should usually not contain copyright notice or
+author line.</p>
-<h4 class="stylepoint_subsection">File Contents</h4>
+<h4>File Contents</h4>
<p>If a <code>.h</code> declares multiple abstractions, the file-level comment
should broadly describe the contents of the file, and how the abstractions are
@@ -4513,16 +4450,10 @@
<p>Do not duplicate comments in both the <code>.h</code> and the
<code>.cc</code>. Duplicated comments diverge.</p>
-</div>
-
<h3 id="Class_Comments">Class Comments</h3>
-<div class="summary">
<p>Every non-obvious class declaration should have an accompanying
comment that describes what it is for and how it should be used.</p>
-</div>
-
-<div class="stylebody">
<pre>// Iterates over the contents of a GargantuanTable.
// Example:
@@ -4551,29 +4482,24 @@
interface definition; comments about the class operation and implementation
should accompany the implementation of the class's methods.</p>
-</div>
-
<h3 id="Function_Comments">Function Comments</h3>
-<div class="summary">
<p>Declaration comments describe use of the function (when it is
non-obvious); comments at the definition of a function describe
operation.</p>
-</div>
-<div class="stylebody">
-
-<h4 class="stylepoint_subsection">Function Declarations</h4>
+<h4>Function Declarations</h4>
<p>Almost every function declaration should have comments immediately
preceding it that describe what the function does and how to use
it. These comments may be omitted only if the function is simple and
obvious (e.g. simple accessors for obvious properties of the
-class). These comments should be descriptive ("Opens the file")
-rather than imperative ("Open the file"); the comment describes the
-function, it does not tell the function what to do. In general, these
-comments do not describe how the function performs its task. Instead,
-that should be left to comments in the function definition.</p>
+class). These comments should open with descriptive verbs in the
+indicative mood ("Opens the file") rather than verbs in the imperative
+("Open the file"). The comment describes the function; it does not
+tell the function what to do. In general, these comments do not
+describe how the function performs its task. Instead, that should be
+left to comments in the function definition.</p>
<p>Types of things to mention in comments at the function
declaration:</p>
@@ -4619,13 +4545,7 @@
</pre>
<p>However, do not be unnecessarily verbose or state the
-completely obvious. Notice below that it is not necessary
- to say "returns false otherwise" because this is
-implied.</p>
-
-<pre>// Returns true if the table cannot hold any more entries.
-bool IsTableFull();
-</pre>
+completely obvious.</p>
<p>When documenting function overrides, focus on the
specifics of the override itself, rather than repeating
@@ -4643,7 +4563,7 @@
skip the comment. It is quite common for destructors not
to have a header comment.</p>
-<h4 class="stylepoint_subsection">Function Definitions</h4>
+<h4>Function Definitions</h4>
<p>If there is anything tricky about how a function does
its job, the function definition should have an
@@ -4662,19 +4582,13 @@
recapitulate briefly what the function does, but the
focus of the comments should be on how it does it.</p>
-</div>
-
<h3 id="Variable_Comments">Variable Comments</h3>
-<div class="summary">
<p>In general the actual name of the variable should be
descriptive enough to give a good idea of what the variable
is used for. In certain cases, more comments are required.</p>
-</div>
-<div class="stylebody">
-
-<h4 class="stylepoint_subsection">Class Data Members</h4>
+<h4>Class Data Members</h4>
<p>The purpose of each class data member (also called an instance
variable or member variable) must be clear. If there are any
@@ -4693,7 +4607,7 @@
int num_total_entries_;
</pre>
-<h4 class="stylepoint_subsection">Global Variables</h4>
+<h4>Global Variables</h4>
<p>All global variables should have a comment describing what they
are, what they are used for, and (if unclear) why it needs to be
@@ -4703,32 +4617,26 @@
const int kNumTestCases = 6;
</pre>
-</div>
-
<h3 id="Implementation_Comments">Implementation Comments</h3>
-<div class="summary">
<p>In your implementation you should have comments in tricky,
non-obvious, interesting, or important parts of your code.</p>
-</div>
-<div class="stylebody">
-
-<h4 class="stylepoint_subsection">Explanatory Comments</h4>
+<h4>Explanatory Comments</h4>
<p>Tricky or complicated code blocks should have comments
before them. Example:</p>
<pre>// Divide result by two, taking into account that x
// contains the carry from the add.
-for (int i = 0; i < result->size(); i++) {
+for (int i = 0; i < result->size(); ++i) {
x = (x << 8) + (*result)[i];
(*result)[i] = x >> 1;
x &= 1;
}
</pre>
-<h4 class="stylepoint_subsection">Line Comments</h4>
+<h4>Line-end Comments</h4>
<p>Also, lines that are non-obvious should get a comment
at the end of the line. These end-of-line comments should
@@ -4745,24 +4653,7 @@
error has already been logged when the function
returns.</p>
-<p>If you have several comments on subsequent lines, it
-can often be more readable to line them up:</p>
-
-<pre>DoSomething(); // Comment here so the comments line up.
-DoSomethingElseThatIsLonger(); // Two spaces between the code and the comment.
-{ // One space before comment when opening a new scope is allowed,
- // thus the comment lines up with the following comments and code.
- DoSomethingElse(); // Two spaces before line comments normally.
-}
-std::vector<string> list{
- // Comments in braced lists describe the next element...
- "First item",
- // .. and should be aligned appropriately.
- "Second item"};
-DoSomething(); /* For trailing block comments, one space is fine. */
-</pre>
-
-<h4 class="stylepoint_subsection">Function Argument Comments</h4>
+<h4 id="Function_Argument_Comments" class="stylepoint_subsection">Function Argument Comments</h4>
<p>When the meaning of a function argument is nonobvious, consider
one of the following remedies:</p>
@@ -4791,7 +4682,7 @@
<li>Replace large or complex nested expressions with named variables.</li>
<li>As a last resort, use comments to clarify argument meanings at the
- call site.</li>
+ call site. </li>
</ul>
Consider the following example:
@@ -4809,7 +4700,7 @@
CalculateProduct(values, options, /*completion_callback=*/nullptr);
</pre>
-<h4 class="stylepoint_subsection">Don'ts</h4>
+<h4 id="Implementation_Comment_Donts">Don'ts</h4>
<p>Do not state the obvious. In particular, don't literally describe what
code does, unless the behavior is nonobvious to a reader who understands
@@ -4842,17 +4733,11 @@
}
</pre>
-</div>
+<h3 id="Punctuation,_Spelling_and_Grammar">Punctuation, Spelling, and Grammar</h3>
-<h3 id="Punctuation,_Spelling_and_Grammar">Punctuation, Spelling and Grammar</h3>
-
-<div class="summary">
<p>Pay attention to punctuation, spelling, and grammar; it is
easier to read well-written comments than badly written
ones.</p>
-</div>
-
-<div class="stylebody">
<p>Comments should be as readable as narrative text, with
proper capitalization and punctuation. In many cases,
@@ -4868,16 +4753,10 @@
punctuation, spelling, and grammar help with that
goal.</p>
-</div>
-
<h3 id="TODO_Comments">TODO Comments</h3>
-<div class="summary">
<p>Use <code>TODO</code> comments for code that is temporary,
a short-term solution, or good-enough but not perfect.</p>
-</div>
-
-<div class="stylebody">
<p><code>TODO</code>s should include the string
<code>TODO</code> in all caps, followed by the
@@ -4908,50 +4787,6 @@
specific event ("Remove this code when all clients can
handle XML responses.").</p>
-</div>
-
-<h3 id="Deprecation_Comments">Deprecation Comments</h3>
-
-<div class="summary">
-<p>Mark deprecated interface points with <code>DEPRECATED</code>
-comments.</p>
-</div>
-
-<div class="stylebody">
-
-<p>You can mark an interface as deprecated by writing a
-comment containing the word <code>DEPRECATED</code> in
-all caps. The comment goes either before the declaration
-of the interface or on the same line as the
-declaration.</p>
-
-
-
-<p>After the word
-<code>DEPRECATED</code>, write your name, e-mail address,
-or other identifier in parentheses.</p>
-
-<p>A deprecation comment must include simple, clear
-directions for people to fix their callsites. In C++, you
-can implement a deprecated function as an inline function
-that calls the new interface point.</p>
-
-<p>Marking an interface point <code>DEPRECATED</code>
-will not magically cause any callsites to change. If you
-want people to actually stop using the deprecated
-facility, you will have to fix the callsites yourself or
-recruit a crew to help you.</p>
-
-<p>New code should not contain calls to deprecated
-interface points. Use the new interface point instead. If
-you cannot understand the directions, find the person who
-created the deprecation and ask them for help using the
-new interface point.</p>
-
-
-
-</div>
-
<h2 id="Formatting">Formatting</h2>
<p>Coding style and formatting are pretty arbitrary, but a
@@ -4962,33 +4797,32 @@
some getting used to, but it is important that all
project contributors follow the
-style rules so that
+style rules so that
they can all read and understand
everyone's code easily.</p>
-<p>To help you format code correctly, we've
-created a
+<div>
+<p>To help you format code correctly, we've created a
<a href="https://raw.githubusercontent.com/google/styleguide/gh-pages/google-c-style.el">
settings file for emacs</a>.</p>
+</div>
<h3 id="Line_Length">Line Length</h3>
-<div class="summary">
<p>Each line of text in your code should be at most 80
characters long.</p>
-</div>
-
-<div class="stylebody">
- <p>We recognize that this rule is
+<div>
+<p>We recognize that this rule is
controversial, but so much existing code already adheres
to it, and we feel that consistency is important.</p>
+</div>
-<div class="pros">
+<p class="pros"></p>
<p>Those who favor this rule
argue that it is rude to force them to resize
their windows and there is no need for anything longer.
@@ -4998,46 +4832,37 @@
assuming a particular maximum window width, and 80
columns has been the traditional standard. Why change
it?</p>
-</div>
-<div class="cons">
+<p class="cons"></p>
<p>Proponents of change argue that a wider line can make
code more readable. The 80-column limit is an hidebound
throwback to 1960s mainframes; modern equipment has wide screens that
can easily show longer lines.</p>
-</div>
-<div class="decision">
+<p class="decision"></p>
<p> 80 characters is the maximum.</p>
-<p class="exception">Comment lines can be longer than 80
-characters if it is not feasible to split them without
-harming readability, ease of cut and paste or auto-linking
--- e.g. if a line contains an example command or a literal
-URL longer than 80 characters.</p>
+<p>A line may exceed 80 characters if it is</p>
-<p class="exception">A raw-string literal may have content
-that exceeds 80 characters. Except for test code, such literals
-should appear near the top of a file.</p>
+<ul>
+ <li>a comment line which is not feasible to split without harming
+ readability, ease of cut and paste or auto-linking -- e.g. if a line
+ contains an example command or a literal URL longer than 80 characters.</li>
-<p class="exception">An <code>#include</code> statement with a
-long path may exceed 80 columns.</p>
+ <li>a raw-string literal with content that exceeds 80 characters. Except for
+ test code, such literals should appear near the top of a file.</li>
-<p class="exception">You needn't be concerned about
-<a href="#The__define_Guard">header guards</a> that exceed
-the maximum length. </p>
-</div>
+ <li>an include statement.</li>
-</div>
+ <li>a <a href="#The__define_Guard">header guard</a></li>
+
+ <li>a using-declaration</li>
+</ul>
<h3 id="Non-ASCII_Characters">Non-ASCII Characters</h3>
-<div class="summary">
<p>Non-ASCII characters should be rare, and must use UTF-8
formatting.</p>
-</div>
-
-<div class="stylebody">
<p>You shouldn't hard-code user-facing text in source,
even English, so use of non-ASCII characters should be
@@ -5074,32 +4899,20 @@
interacts with the Windows API, which uses
<code>wchar_t</code> extensively).</p>
-</div>
-
<h3 id="Spaces_vs._Tabs">Spaces vs. Tabs</h3>
-<div class="summary">
<p>Use only spaces, and indent 2 spaces at a time.</p>
-</div>
-
-<div class="stylebody">
<p>We use spaces for indentation. Do not use tabs in your
code. You should set your editor to emit spaces when you
hit the tab key.</p>
-</div>
-
<h3 id="Function_Declarations_and_Definitions">Function Declarations and Definitions</h3>
-<div class="summary">
<p>Return type on the same line as function name, parameters
on the same line if they fit. Wrap parameter lists which do
not fit on a single line as you would wrap arguments in a
<a href="#Function_Calls">function call</a>.</p>
-</div>
-
-<div class="stylebody">
<p>Functions look like this:</p>
@@ -5135,8 +4948,8 @@
<ul>
<li>Choose good parameter names.</li>
- <li>Parameter names may be omitted only if the parameter is unused and its
- purpose is obvious.</li>
+ <li>A parameter name may be omitted only if the parameter is not used in the
+ function's definition.</li>
<li>If you cannot fit the return type and the function
name on a single line, break between them.</li>
@@ -5173,10 +4986,8 @@
<pre>class Foo {
public:
- Foo(Foo&&);
- Foo(const Foo&);
- Foo& operator=(Foo&&);
- Foo& operator=(const Foo&);
+ Foo(const Foo&) = delete;
+ Foo& operator=(const Foo&) = delete;
};
</pre>
@@ -5204,19 +5015,14 @@
<p>Attributes, and macros that expand to attributes, appear at the very
beginning of the function declaration or definition, before the
return type:</p>
-<pre>MUST_USE_RESULT bool IsOK();
+<pre>ABSL_MUST_USE_RESULT bool IsOk();
</pre>
-</div>
-
<h3 id="Formatting_Lambda_Expressions">Lambda Expressions</h3>
-<div class="summary">
<p>Format parameters and bodies as for any other function, and capture
lists like other comma-separated lists.</p>
-</div>
-<div class="stylebody">
<p>For by-reference captures, do not leave a space between the
ampersand (&) and the variable name.</p>
<pre>int x = 0;
@@ -5231,20 +5037,38 @@
digits.end());
</pre>
-</div>
+<h3 id="Floating_Literals">Floating-point Literals</h3>
+
+<p>Floating-point literals should always have a radix point, with digits on both
+sides, even if they use exponential notation. Readability is improved if all
+floating-point literals take this familiar form, as this helps ensure that they
+are not mistaken for integer literals, and that the
+<code>E</code>/<code>e</code> of the exponential notation is not mistaken for a
+hexadecimal digit. It is fine to initialize a floating-point variable with an
+integer literal (assuming the variable type can exactly represent that integer),
+but note that a number in exponential notation is never an integer literal.
+</p>
+
+<pre class="badcode">float f = 1.f;
+long double ld = -.5L;
+double d = 1248e6;
+</pre>
+
+<pre class="goodcode">float f = 1.0f;
+float f2 = 1; // Also OK
+long double ld = -0.5L;
+double d = 1248.0e6;
+</pre>
+
<h3 id="Function_Calls">Function Calls</h3>
-<div class="summary">
<p>Either write the call all on a single line, wrap the
arguments at the parenthesis, or start the arguments on a new
line indented by four spaces and continue at that 4 space
indent. In the absence of other considerations, use the
minimum number of lines, including placing multiple arguments
on each line where appropriate.</p>
-</div>
-
-<div class="stylebody">
<p>Function calls have the following format:</p>
<pre>bool result = DoSomething(argument1, argument2, argument3);
@@ -5309,16 +5133,10 @@
z1, z2, z3);
</pre>
-</div>
-
<h3 id="Braced_Initializer_List_Format">Braced Initializer List Format</h3>
-<div class="summary">
<p>Format a <a href="#Braced_Initializer_List">braced initializer list</a>
exactly like you would format a function call in its place.</p>
-</div>
-
-<div class="stylebody">
<p>If the braced list follows a name (e.g. a type or
variable name), format as if the <code>{}</code> were the
@@ -5352,16 +5170,10 @@
interiorwrappinglist2}};
</pre>
-</div>
-
<h3 id="Conditionals">Conditionals</h3>
-<div class="summary">
<p>Prefer no spaces inside parentheses. The <code>if</code>
and <code>else</code> keywords belong on separate lines.</p>
-</div>
-
-<div class="stylebody">
<p>There are two acceptable formats for a basic
conditional statement. One includes spaces between the
@@ -5427,9 +5239,9 @@
single-line statements, but they are allowed if you like
them; conditional or loop statements with complex
conditions or statements may be more readable with curly
-braces. Some
+braces. Some
projects require that an
-<code>if</code> must always always have an accompanying
+<code>if</code> must always have an accompanying
brace.</p>
<pre>if (condition)
@@ -5467,18 +5279,12 @@
}
</pre>
-</div>
-
<h3 id="Loops_and_Switch_Statements">Loops and Switch Statements</h3>
-<div class="summary">
<p>Switch statements may use braces for blocks. Annotate
non-trivial fall-through between cases.
Braces are optional for single-statement loops.
-Empty loop bodies should use empty braces or <code>continue</code>.</p>
-</div>
-
-<div class="stylebody">
+Empty loop bodies should use either empty braces or <code>continue</code>.</p>
<p><code>case</code> blocks in <code>switch</code>
statements can have curly braces or not, depending on
@@ -5489,10 +5295,9 @@
statements should always have a <code>default</code> case
(in the case of an enumerated value, the compiler will
warn you if any values are not handled). If the default
-case should never execute, simply
-<code>assert</code>:</p>
+case should never execute, treat this as an error. For example:
-
+</p>
<div>
<pre>switch (var) {
@@ -5509,11 +5314,37 @@
}
}
</pre>
-</div>
+</div>
+<p>Fall-through from one case label to
+another must be annotated using the
+<code>ABSL_FALLTHROUGH_INTENDED;</code> macro (defined in
+<code>absl/base/macros.h</code>).
+<code>ABSL_FALLTHROUGH_INTENDED;</code> should be placed at a
+point of execution where a fall-through to the next case
+label occurs. A common exception is consecutive case
+labels without intervening code, in which case no
+annotation is needed.</p>
-
+<pre>switch (x) {
+ case 41: // No annotation needed here.
+ case 43:
+ if (dont_be_picky) {
+ // Use this instead of or along with annotations in comments.
+ ABSL_FALLTHROUGH_INTENDED;
+ } else {
+ CloseButNoCigar();
+ break;
+ }
+ case 42:
+ DoSomethingSpecial();
+ ABSL_FALLTHROUGH_INTENDED;
+ default:
+ DoSomethingGeneric();
+ break;
+}
+</pre>
<p> Braces are optional for single-statement loops.</p>
@@ -5526,8 +5357,8 @@
</pre>
-<p>Empty loop bodies should use an empty pair of braces or <code>continue</code>,
-but not a single semicolon.</p>
+<p>Empty loop bodies should use either an empty pair of braces or
+<code>continue</code> with no braces, rather than a single semicolon.</p>
<pre>while (condition) {
// Repeat test until it returns false.
@@ -5539,16 +5370,10 @@
<pre class="badcode">while (condition); // Bad - looks like part of do/while loop.
</pre>
-</div>
-
<h3 id="Pointer_and_Reference_Expressions">Pointer and Reference Expressions</h3>
-<div class="summary">
<p>No spaces around period or arrow. Pointer operators do not
have trailing spaces.</p>
-</div>
-
-<div class="stylebody">
<p>The following are examples of correctly-formatted
pointer and reference expressions:</p>
@@ -5575,13 +5400,18 @@
<pre>// These are fine, space preceding.
char *c;
-const string &str;
+const std::string &str;
// These are fine, space following.
char* c;
-const string& str;
+const std::string& str;
</pre>
+<p>You should do this consistently within a single
+file,
+so, when modifying an existing file, use the style in
+that file.</p>
+
It is allowed (if unusual) to declare multiple variables in the same
declaration, but it is disallowed if any of those have pointer or
reference decorations. Such declarations are easily misread.
@@ -5590,25 +5420,14 @@
</pre>
<pre class="badcode">int x, *y; // Disallowed - no & or * in multiple declaration
char * c; // Bad - spaces on both sides of *
-const string & str; // Bad - spaces on both sides of &
+const std::string & str; // Bad - spaces on both sides of &
</pre>
-<p>You should do this consistently within a single
-file,
-so, when modifying an existing file, use the style in
-that file.</p>
-
-</div>
-
<h3 id="Boolean_Expressions">Boolean Expressions</h3>
-<div class="summary">
<p>When you have a boolean expression that is longer than the
<a href="#Line_Length">standard line length</a>, be
consistent in how you break up the lines.</p>
-</div>
-
-<div class="stylebody">
<p>In this example, the logical AND operator is always at
the end of the lines:</p>
@@ -5633,16 +5452,10 @@
the word operators, such as <code>and</code> and
<code>compl</code>.</p>
-</div>
-
<h3 id="Return_Values">Return Values</h3>
-<div class="summary">
<p>Do not needlessly surround the <code>return</code>
expression with parentheses.</p>
-</div>
-
-<div class="stylebody">
<p>Use parentheses in <code>return expr;</code> only
where you would use them in <code>x = expr;</code>.</p>
@@ -5657,18 +5470,12 @@
return(result); // return is not a function!
</pre>
-</div>
-
<h3 id="Variable_and_Array_Initialization">Variable and Array Initialization</h3>
-<div class="summary">
<p>Your choice of <code>=</code>, <code>()</code>, or
<code>{}</code>.</p>
-</div>
-
-<div class="stylebody">
<p>You may choose between <code>=</code>,
<code>()</code>, and <code>{}</code>; the following are
@@ -5677,9 +5484,9 @@
<pre>int x = 3;
int x(3);
int x{3};
-string name = "Some Name";
-string name("Some Name");
-string name{"Some Name"};
+std::string name = "Some Name";
+std::string name("Some Name");
+std::string name{"Some Name"};
</pre>
<p>Be careful when using a braced initialization list <code>{...}</code>
@@ -5691,8 +5498,8 @@
non-<code>std::initializer_list</code> constructor, use parentheses
instead of braces.</p>
-<pre>std::vector<int> v(100, 1); // A vector of 100 1s.
-std::vector<int> v{100, 1}; // A vector of 100, 1.
+<pre>std::vector<int> v(100, 1); // A vector containing 100 items: All 1s.
+std::vector<int> v{100, 1}; // A vector containing 2 items: 100 and 1.
</pre>
<p>Also, the brace form prevents narrowing of integral
@@ -5703,16 +5510,10 @@
int pi{3.14}; // Compile error: narrowing conversion.
</pre>
-</div>
-
<h3 id="Preprocessor_Directives">Preprocessor Directives</h3>
-<div class="summary">
<p>The hash mark that starts a preprocessor directive should
always be at the beginning of the line.</p>
-</div>
-
-<div class="stylebody">
<p>Even when preprocessor directives are within the body
of indented code, the directives should start at the
@@ -5739,16 +5540,10 @@
}
</pre>
-</div>
-
<h3 id="Class_Format">Class Format</h3>
-<div class="summary">
<p>Sections in <code>public</code>, <code>protected</code> and
<code>private</code> order, each indented one space.</p>
-</div>
-
-<div class="stylebody">
<p>The basic format for a class definition (lacking the
comments, see <a href="#Class_Comments">Class
@@ -5802,16 +5597,10 @@
each of these sections.</li>
</ul>
-</div>
-
<h3 id="Constructor_Initializer_Lists">Constructor Initializer Lists</h3>
-<div class="summary">
<p>Constructor initializer lists can be all on one line or
with subsequent lines indented four spaces.</p>
-</div>
-
-<div class="stylebody">
<p>The acceptable formats for initializer lists are:</p>
@@ -5841,15 +5630,9 @@
: some_var_(var) {}
</pre>
-</div>
-
<h3 id="Namespace_Formatting">Namespace Formatting</h3>
-<div class="summary">
<p>The contents of namespaces are not indented.</p>
-</div>
-
-<div class="stylebody">
<p><a href="#Namespaces">Namespaces</a> do not add an
extra level of indentation. For example, use:</p>
@@ -5867,7 +5650,7 @@
<pre class="badcode">namespace {
- // Wrong. Indented when it should not be.
+ // Wrong! Indented when it should not be.
void foo() {
...
}
@@ -5882,18 +5665,12 @@
namespace bar {
</pre>
-</div>
-
<h3 id="Horizontal_Whitespace">Horizontal Whitespace</h3>
-<div class="summary">
<p>Use of horizontal whitespace depends on location. Never put
trailing whitespace at the end of a line.</p>
-</div>
-<div class="stylebody">
-
-<h4 class="stylepoint_subsection">General</h4>
+<h4>General</h4>
<pre>void f(bool b) { // Open braces should always have a space before them.
...
@@ -5918,11 +5695,11 @@
removing existing trailing whitespace. So: Don't
introduce trailing whitespace. Remove it if you're
already changing that line, or do it in a separate
-clean-up
+clean-up
operation (preferably when no-one
else is working on the file).</p>
-<h4 class="stylepoint_subsection">Loops and Conditionals</h4>
+<h4>Loops and Conditionals</h4>
<pre>if (b) { // Space after the keyword in conditions and loops.
} else { // Spaces around else.
@@ -5950,7 +5727,7 @@
case 2: break; // Use a space after a colon if there's code after it.
</pre>
-<h4 class="stylepoint_subsection">Operators</h4>
+<h4>Operators</h4>
<pre>// Assignment operators always have spaces around them.
x = 0;
@@ -5969,53 +5746,49 @@
...
</pre>
-<h4 class="stylepoint_subsection">Templates and Casts</h4>
+<h4>Templates and Casts</h4>
<pre>// No spaces inside the angle brackets (< and >), before
// <, or between >( in a cast
-std::vector<string> x;
+std::vector<std::string> x;
y = static_cast<char*>(x);
// Spaces between type and pointer are OK, but be consistent.
std::vector<char *> x;
</pre>
-</div>
-
<h3 id="Vertical_Whitespace">Vertical Whitespace</h3>
-<div class="summary">
<p>Minimize use of vertical whitespace.</p>
-</div>
-<div class="stylebody">
+<p>This is more a principle than a rule: don't use blank lines when
+you don't have to. In particular, don't put more than one or two blank
+lines between functions, resist starting functions with a blank line,
+don't end functions with a blank line, and be sparing with your use of
+blank lines. A blank line within a block of code serves like a
+paragraph break in prose: visually separating two thoughts.</p>
-<p>This is more a principle than a rule: don't use blank
-lines when you don't have to. In particular, don't put
-more than one or two blank lines between functions,
-resist starting functions with a blank line, don't end
-functions with a blank line, and be discriminating with
-your use of blank lines inside functions.</p>
-
-<p>The basic principle is: The more code that fits on one
-screen, the easier it is to follow and understand the
-control flow of the program. Of course, readability can
-suffer from code being too dense as well as too spread
-out, so use your judgement. But in general, minimize use
-of vertical whitespace.</p>
+<p>The basic principle is: The more code that fits on one screen, the
+easier it is to follow and understand the control flow of the
+program. Use whitespace purposefully to provide separation in that
+flow.</p>
<p>Some rules of thumb to help when blank lines may be
useful:</p>
<ul>
<li>Blank lines at the beginning or end of a function
- very rarely help readability.</li>
+ do not help readability.</li>
<li>Blank lines inside a chain of if-else blocks may
well help readability.</li>
-</ul>
-</div>
+ <li>A blank line before a comment line usually helps
+ readability — the introduction of a new comment suggests
+ the start of a new thought, and the blank line makes it clear
+ that the comment goes with the following thing instead of the
+ preceding.</li>
+</ul>
<h2 id="Exceptions_to_the_Rules">Exceptions to the Rules</h2>
@@ -6023,17 +5796,13 @@
However, like all good rules, these sometimes have exceptions,
which we discuss here.</p>
-
+
<div>
<h3 id="Existing_Non-conformant_Code">Existing Non-conformant Code</h3>
-<div class="summary">
<p>You may diverge from the rules when dealing with code that
does not conform to this style guide.</p>
-</div>
-
-<div class="stylebody">
<p>If you find yourself modifying code that was written
to specifications other than those presented by this
@@ -6044,23 +5813,19 @@
the code. Remember that <em>consistency</em> includes
local consistency, too.</p>
-</div>
-</div>
+</div>
-
+
<h3 id="Windows_Code">Windows Code</h3>
-<div class="summary">
<p> Windows
programmers have developed their own set of coding
conventions, mainly derived from the conventions in Windows
headers and other Microsoft code. We want to make it easy
for anyone to understand your code, so we have a single set
of guidelines for everyone writing C++ on any platform.</p>
-</div>
-<div class="stylebody">
<p>It is worth reiterating a few of the guidelines that
you might forget if you are used to the prevalent Windows
style:</p>
@@ -6104,7 +5869,7 @@
occasionally need to break on Windows:</p>
<ul>
- <li>Normally we <a href="#Multiple_Inheritance">forbid
+ <li>Normally we <a href="#Multiple_Inheritance">strongly discourage
the use of multiple implementation inheritance</a>;
however, it is required when using COM and some ATL/WTL
classes. You may use multiple implementation
@@ -6136,9 +5901,7 @@
need to conform to these style guidelines.</li>
</ul>
-</div>
-
-<h2 class="ignoreLink">Parting Words</h2>
+<h2 id="Parting_Words">Parting Words</h2>
<p>Use common sense and <em>BE CONSISTENT</em>.</p>
@@ -6163,8 +5926,6 @@
more interesting. Have fun!</p>
<hr>
-
-</div>
</div>
</body>
</html>
diff --git a/cpplint/cpplint.py b/cpplint/cpplint.py
index 53dbe81..d069b6d 100755
--- a/cpplint/cpplint.py
+++ b/cpplint/cpplint.py
@@ -51,6 +51,12 @@
import string
import sys
import unicodedata
+import sysconfig
+
+try:
+ xrange # Python 2
+except NameError:
+ xrange = range # Python 3
_USAGE = """
@@ -569,7 +575,7 @@
# Automatically append to extensions list so it does not have to be set 2 times
_valid_extensions.update(_hpp_headers)
except ValueError:
- PrintUsage('Header extensions must be comma seperated list.')
+ PrintUsage('Header extensions must be comma separated list.')
def IsHeaderExtension(file_extension):
return file_extension in _hpp_headers
@@ -1846,8 +1852,8 @@
PathSplitToList(_root))
if _root_debug:
- sys.stderr.write("_root lstrip (maybe_path=%s, file_path_from_root=%s," +
- " _root=%s)\n" %(maybe_path, file_path_from_root, _root))
+ sys.stderr.write(("_root lstrip (maybe_path=%s, file_path_from_root=%s," +
+ " _root=%s)\n") %(maybe_path, file_path_from_root, _root))
if maybe_path:
return os.path.join(*maybe_path)
@@ -1860,8 +1866,8 @@
PathSplitToList(root_abspath))
if _root_debug:
- sys.stderr.write("_root prepend (maybe_path=%s, full_path=%s, " +
- "root_abspath=%s)\n" %(maybe_path, full_path, root_abspath))
+ sys.stderr.write(("_root prepend (maybe_path=%s, full_path=%s, " +
+ "root_abspath=%s)\n") %(maybe_path, full_path, root_abspath))
if maybe_path:
return os.path.join(*maybe_path)
@@ -3277,8 +3283,8 @@
line = clean_lines.elided[linenum]
# You shouldn't have spaces before your brackets, except maybe after
- # 'delete []' or 'return []() {};'
- if Search(r'\w\s+\[', line) and not Search(r'(?:delete|return)\s+\[', line):
+ # 'delete []', 'return []() {};', or 'auto [abc, ...] = ...;'.
+ if Search(r'\w\s+\[', line) and not Search(r'(?:auto&?|delete|return)\s+\[', line):
error(filename, linenum, 'whitespace/braces', 5,
'Extra space before [')
@@ -4286,6 +4292,19 @@
if unicodedata.east_asian_width(uc) in ('W', 'F'):
width += 2
elif not unicodedata.combining(uc):
+ # Issue 337
+ # https://mail.python.org/pipermail/python-list/2012-August/628809.html
+ if (sys.version_info.major, sys.version_info.minor) <= (3, 2):
+ try:
+ # https://github.com/python/cpython/blob/2.7/Include/unicodeobject.h#L81
+ is_wide_build = sysconfig.get_config_var("Py_UNICODE_SIZE") >= 4
+ # https://github.com/python/cpython/blob/2.7/Objects/unicodeobject.c#L564
+ is_low_surrogate = 0xDC00 <= ord(uc) <= 0xDFFF
+ if not is_wide_build and is_low_surrogate:
+ width -= 1
+ except ImportError:
+ # Android prebuilt python ends up CHECK-failing here due to how it's compiled.
+ pass
width += 1
return width
else:
@@ -6188,7 +6207,7 @@
try:
_valid_extensions = set(val.split(','))
except ValueError:
- PrintUsage('Extensions must be comma seperated list.')
+ PrintUsage('Extensions must be comma separated list.')
elif opt == '--headers':
ProcessHppHeadersOption(val)
diff --git a/cpplint/cpplint_unittest.py b/cpplint/cpplint_unittest.py
index a07ffd8..6087d8f 100755
--- a/cpplint/cpplint_unittest.py
+++ b/cpplint/cpplint_unittest.py
@@ -43,6 +43,11 @@
import cpplint
+try:
+ xrange # Python 2
+except NameError:
+ xrange = range # Python 3
+
# This class works as an error collector and replaces cpplint.Error
# function for the unit tests. We also verify each category we see
@@ -316,6 +321,8 @@
self.assertEquals(0, cpplint.GetLineWidth(''))
self.assertEquals(10, cpplint.GetLineWidth(u'x' * 10))
self.assertEquals(16, cpplint.GetLineWidth(u'都|道|府|県|支庁'))
+ self.assertEquals(5 + 13 + 9, cpplint.GetLineWidth(
+ u'd𝐱/dt' + u'f : t ⨯ 𝐱 → ℝ' + u't ⨯ 𝐱 → ℝ'))
def testGetTextInside(self):
self.assertEquals('', cpplint._GetTextInside('fun()', r'fun\('))
@@ -4280,12 +4287,14 @@
# (note that CPPLINT.cfg root=setting is always made absolute)
this_files_path = os.path.dirname(os.path.abspath(__file__))
(styleguide_path, this_files_dir) = os.path.split(this_files_path)
- (styleguide_parent_path, _) = os.path.split(styleguide_path)
+ (styleguide_parent_path, styleguide_dir_name) = os.path.split(styleguide_path)
# parent dir of styleguide
cpplint._root = styleguide_parent_path
self.assertIsNotNone(styleguide_parent_path)
+ # do not hardcode the 'styleguide' repository name, it could be anything.
+ expected_prefix = re.sub(r'[^a-zA-Z0-9]', '_', styleguide_dir_name).upper() + '_'
# do not have 'styleguide' repo in '/'
- self.assertEquals('STYLEGUIDE_CPPLINT_CPPLINT_TEST_HEADER_H_',
+ self.assertEquals('%sCPPLINT_CPPLINT_TEST_HEADER_H_' %(expected_prefix),
cpplint.GetHeaderGuardCPPVariable(file_path))
# To run the 'relative path' tests, we must be in the directory of this test file.
@@ -4302,7 +4311,7 @@
styleguide_rel_path = os.path.relpath(styleguide_parent_path,
this_files_path) # '../..'
cpplint._root = styleguide_rel_path
- self.assertEquals('STYLEGUIDE_CPPLINT_CPPLINT_TEST_HEADER_H_',
+ self.assertEquals('%sCPPLINT_CPPLINT_TEST_HEADER_H_' %(expected_prefix),
cpplint.GetHeaderGuardCPPVariable(file_path))
cpplint._root = None
diff --git a/docguide/best_practices.md b/docguide/best_practices.md
index 8f02545..580b75b 100644
--- a/docguide/best_practices.md
+++ b/docguide/best_practices.md
@@ -57,7 +57,7 @@
## Prefer the good over the perfect
Your documentation should be as good as possible within a reasonable time frame.
-The standards for an documentation review are different from the
+The standards for a documentation review are different from the
standards for code reviews. Reviewers can and should ask for improvements, but
in general, the author should always be able to invoke the "Good Over Perfect
Rule". It's preferable to allow authors to quickly submit changes that improve
diff --git a/docguide/philosophy.md b/docguide/philosophy.md
index 0937c5b..5b3813a 100644
--- a/docguide/philosophy.md
+++ b/docguide/philosophy.md
@@ -18,7 +18,7 @@
* **Scalability and interoperability** are more important than a menagerie of
unessential features. Scale comes from simplicity, speed, and ease.
- Interoperability comes from unadorned, digestable content.
+ Interoperability comes from unadorned, digestible content.
* **Fewer distractions** make for better writing and more productive reading.
diff --git a/google-r-style.html b/google-r-style.html
index 21a73f6..6c945d1 100644
--- a/google-r-style.html
+++ b/google-r-style.html
@@ -1,9 +1,8 @@
<!DOCTYPE html>
<html>
<head>
- <meta charset="utf8">
- <meta http-equiv="content-type" content="text/html;charset=utf-8">
- <meta http-equiv="refresh" content="1; url=Rguide.xml">
+ <meta charset="utf-8">
+ <meta http-equiv="refresh" content="1; url=Rguide.html">
<title>Redirecting</title>
</head>
<!-- The BODY onLoad redirect is the best: it preserves #fragments and
@@ -12,7 +11,7 @@
and queries, takes a second, and pollutes the browser history.
If they both fail, we let the user manually click on the new link.
-->
- <body onload="location.replace(location.href.replace('google-r-style.html', 'Rguide.xml'))">
- Redirecting you to <a href="Rguide.xml">Rguide.xml</a>.
+<body onload="location.replace(location.href.replace('google-r-style.html', 'Rguide.html'))">
+ Redirecting you to <a href="Rguide.html">Rguide.html</a>.
</body>
</html>
diff --git a/htmlcssguide.html b/htmlcssguide.html
index 6fc7b39..58e6c12 100644
--- a/htmlcssguide.html
+++ b/htmlcssguide.html
@@ -13,45 +13,39 @@
<h1>Google HTML/CSS Style Guide</h1>
<h2 id="Background">1 Background</h2>
-<p></p>
-
<p>This document defines formatting and style rules for HTML and CSS. It aims at
improving collaboration, code quality, and enabling supporting infrastructure.
It applies to raw, working files that use HTML and CSS, including GSS files.
Tools are free to obfuscate, minify, and compile as long as the general code
quality is maintained.</p>
-<p></p>
-
-<p></p>
-
<h2 id="General">2 General</h2>
<h3 id="General_Style_Rules">2.1 General Style Rules</h3>
<h4 id="Protocol">2.1.1 Protocol</h4>
-<p>Use the HTTPS protocol for embedded resources where possible.</p>
+<p>Use HTTPS for embedded resources where possible.</p>
-<p>Always use the HTTPS protocol (<code>https:</code>) for images and other media
+<p>Always use HTTPS (<code>https:</code>) for images and other media
files, style sheets, and scripts, unless the respective files are not available
over HTTPS.</p>
<pre><code class="language-html prettyprint badcode"><!-- Not recommended: omits the protocol -->
-<script src="//ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js"></script>
+<script src="//ajax.googleapis.com/ajax/libs/jquery/3.4.0/jquery.min.js"></script>
-<!-- Not recommended: uses the HTTP protocol -->
-<script src="http://ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js"></script>
+<!-- Not recommended: uses HTTP -->
+<script src="http://ajax.googleapis.com/ajax/libs/jquery/3.4.0/jquery.min.js"></script>
</code></pre>
<pre><code class="language-html prettyprint"><!-- Recommended -->
-<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js"></script>
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.0/jquery.min.js"></script>
</code></pre>
<pre><code class="language-css prettyprint badcode">/* Not recommended: omits the protocol */
@import '//fonts.googleapis.com/css?family=Open+Sans';
-/* Not recommended: uses the HTTP protocol */
+/* Not recommended: uses HTTP */
@import 'http://fonts.googleapis.com/css?family=Open+Sans';
</code></pre>
@@ -59,14 +53,6 @@
@import 'https://fonts.googleapis.com/css?family=Open+Sans';
</code></pre>
-
-
-<p></p>
-
-<p></p>
-
-<p></p>
-
<h3 id="General_Formatting_Rules">2.2 General Formatting Rules</h3>
<h4 id="Indentation">2.2.1 Indentation</h4>
@@ -163,14 +149,10 @@
<p>Append action items after a colon as in <code>TODO: action item</code>.</p>
-<pre></pre>
-
<pre><code class="language-django prettyprint external">{# TODO(john.doe): revisit centering #}
<center>Test</center>
</code></pre>
-<p></p>
-
<pre><code class="language-html prettyprint"><!-- TODO: remove optional tags -->
<ul>
<li>Apples</li>
@@ -235,8 +217,6 @@
<p>Using HTML according to its purpose is important for accessibility, reuse, and
code efficiency reasons.</p>
-<p></p>
-
<pre><code class="language-html prettyprint badcode"><!-- Not recommended -->
<div onclick="goToRecommendations();">All recommendations</div>
</code></pre>
@@ -261,8 +241,6 @@
whose purpose is purely decorative which you cannot immediately use CSS for, use
no alternative text, as in <code>alt=""</code>.)</p>
-<p></p>
-
<pre><code class="language-html prettyprint badcode"><!-- Not recommended -->
<img src="spreadsheet.png">
</code></pre>
@@ -290,8 +268,6 @@
maintenance reasons. It is always more expensive to change HTML documents and
templates than it is to update style sheets and scripts.</p>
-<p></p>
-
<pre><code class="language-html prettyprint badcode"><!-- Not recommended -->
<!DOCTYPE html>
<title>HTML sucks</title>
@@ -340,7 +316,7 @@
<p>Omit optional tags (optional).</p>
<p>For file size optimization and scannability purposes, consider omitting optional
-tags. The <a href="https://whatwg.org/specs/web-apps/current-work/multipage/syntax.html#syntax-tag-omission">HTML5 specification</a>
+tags. The <a href="https://html.spec.whatwg.org/multipage/syntax.html#syntax-tag-omission">HTML5 specification</a>
defines what tags can be omitted.</p>
<p>(This approach may require a grace period to be established as a wider guideline
@@ -374,13 +350,13 @@
(unless not using JavaScript).</p>
<p>Specifying <code>type</code> attributes in these contexts is not necessary as HTML5 implies
-<a href="https://whatwg.org/specs/web-apps/current-work/multipage/semantics.html#attr-style-type"><code>text/css</code></a>
-and <a href="https://whatwg.org/specs/web-apps/current-work/multipage/scripting.html#attr-script-type"><code>text/javascript</code></a>
+<a href="https://html.spec.whatwg.org/multipage/obsolete.html#attr-style-type"><code>text/css</code></a>
+and <a href="https://html.spec.whatwg.org/multipage/scripting.html#attr-script-type"><code>text/javascript</code></a>
as defaults. This can be safely done even for older browsers.</p>
<pre><code class="language-html prettyprint badcode"><!-- Not recommended -->
<link rel="stylesheet" href="https://www.google.com/css/maia.css"
- type="text/css">
+ type="text/css">
</code></pre>
<pre><code class="language-html prettyprint"><!-- Recommended -->
@@ -389,7 +365,7 @@
<pre><code class="language-html prettyprint badcode"><!-- Not recommended -->
<script src="https://www.google.com/js/gweb/analytics/autotrack.js"
- type="text/javascript"></script>
+ type="text/javascript"></script>
</code></pre>
<pre><code class="language-html prettyprint"><!-- Recommended -->
@@ -437,7 +413,37 @@
</table>
</code></pre>
-<h4 id="HTML_Quotation_Marks">3.2.2 HTML Quotation Marks</h4>
+<h4 id="HTML_Line-Wrapping">3.2.2 HTML Line-Wrapping</h4>
+
+<p>Break long lines (optional).</p>
+
+<p>While there is no column limit recommendation for HTML, you may consider
+wrapping long lines if it significantly improves readability.</p>
+
+<p>When line-wrapping, each continuation line should be indented at least 4
+additional spaces from the original line.</p>
+
+<pre><code class="language-html prettyprint"><md-progress-circular md-mode="indeterminate" class="md-accent"
+ ng-show="ctrl.loading" md-diameter="35">
+</md-progress-circular>
+</code></pre>
+
+<pre><code class="language-html prettyprint"><md-progress-circular
+ md-mode="indeterminate"
+ class="md-accent"
+ ng-show="ctrl.loading"
+ md-diameter="35">
+</md-progress-circular>
+</code></pre>
+
+<pre><code class="language-html prettyprint"><md-progress-circular md-mode="indeterminate"
+ class="md-accent"
+ ng-show="ctrl.loading"
+ md-diameter="35">
+</md-progress-circular>
+</code></pre>
+
+<h4 id="HTML_Quotation_Marks">3.2.3 HTML Quotation Marks</h4>
<p>When quoting attributes values, use double quotation marks.</p>
@@ -588,7 +594,7 @@
<p>Omit leading “0”s in values.</p>
-<p>Do not use put <code>0</code>s in front of values or lengths between -1 and 1.</p>
+<p>Do not put <code>0</code>s in front of values or lengths between -1 and 1.</p>
<pre><code class="language-css prettyprint">font-size: .8em;
</code></pre>
@@ -616,10 +622,6 @@
external sites use prefixes (as namespaces) for ID and class names. Use short,
unique identifiers followed by a dash.</p>
-<p></p>
-
-<p></p>
-
<p>Using namespaces helps preventing naming conflicts and can make maintenance
easier, for example in search and replace operations.</p>
@@ -661,10 +663,6 @@
means using detection and hacks more frequently—and more frequently is too
frequently.</p>
-<p></p>
-
-<p></p>
-
<h3 id="CSS_Formatting_Rules">4.2 CSS Formatting Rules</h3>
<h4 id="Declaration_Order">4.2.1 Declaration Order</h4>
@@ -813,11 +811,10 @@
<h4 id="CSS_Quotation_Marks">4.2.8 CSS Quotation Marks</h4>
-<p>Use single quotation marks for attribute selectors and property values.</p>
-
<p>Use single (<code>''</code>) rather than double (<code>""</code>) quotation marks for attribute
-selectors or property values. Do not use quotation marks in URI values
-(<code>url()</code>).</p>
+selectors and property values.</p>
+
+<p>Do not use quotation marks in URI values (<code>url()</code>).</p>
<p>Exception: If you do need to use the <code>@charset</code> rule, use double quotation
marks—<a href="https://www.w3.org/TR/CSS21/syndata.html#charset">single quotation marks are not permitted</a>.</p>
@@ -860,28 +857,6 @@
.adw-gallery {}
</code></pre>
-
-
-<p></p>
-
-<p></p>
-
-
-
-<p></p>
-
-<p></p>
-
-<pre></pre>
-
-
-
-
-
-<p></p>
-
-<p></p>
-
<h2 id="Parting_Words">Parting Words</h2>
<p><em>Be consistent.</em></p>
diff --git a/javaguide.html b/javaguide.html
index b171426..bbdbc1c 100644
--- a/javaguide.html
+++ b/javaguide.html
@@ -459,7 +459,7 @@
<h4 id="s4.6.1-vertical-whitespace">4.6.1 Vertical Whitespace</h4>
-<p>A single blank line appears:</p>
+<p>A single blank line always appears:</p>
<ol>
<li><em>Between</em> consecutive members or initializers of a class: fields, constructors,
@@ -473,17 +473,17 @@
</ul>
</li>
- <li>Between statements, <em>as needed</em> to organize the code into logical subsections.
-
- </li><li><em>Optionally</em> before the first member or initializer, or after the last member or
- initializer of the class (neither encouraged nor discouraged).</li>
-
<li>As required by other sections of this document (such as Section 3,
<a href="#s3-source-file-structure">Source file structure</a>, and Section 3.3,
<a href="#s3.3-import-statements">Import statements</a>).</li>
</ol>
-<p><em>Multiple</em> consecutive blank lines are permitted, but never required (or encouraged).</p>
+<p>A single blank line may also appear anywhere it improves readability, for example between
+statements to organize the code into logical subsections. A blank line before the first member or
+initializer, or after the last member or initializer of the class, is neither encouraged nor
+discouraged.
+
+</p><p><em>Multiple</em> consecutive blank lines are permitted, but never required (or encouraged).</p>
<h4 id="s4.6.2-horizontal-whitespace">4.6.2 Horizontal whitespace</h4>
@@ -553,10 +553,13 @@
<code class="prettyprint lang-java">new int[] { 5, 6 }</code> are both valid</li>
</ul>
</li>
+
+ <li>Between a type annotation and <code class="prettyprint lang-java">[]</code> or
+ <code class="prettyprint lang-java">...</code>.</li>
</ol>
-This rule is never interpreted as requiring or forbidding additional space at the start or
-end of a line; it addresses only <em>interior</em> space.
+<p>This rule is never interpreted as requiring or forbidding additional space at the start or
+end of a line; it addresses only <em>interior</em> space.</p>
<h4 id="s4.6.3-horizontal-alignment">4.6.3 Horizontal alignment: never required</h4>
@@ -809,10 +812,9 @@
underscores. Thus each valid identifier name is matched by the regular expression
<code>\w+</code> .</p>
-<p>In Google Style special prefixes or
-suffixes, like those seen in the examples <code class="badcode">name_</code>,
-<code class="badcode">mName</code>, <code class="badcode">s_name</code> and
-<code class="badcode">kName</code>, are <strong>not</strong> used.</p>
+<p>In Google Style, special prefixes or suffixes are <strong>not</strong> used. For example, these
+names are not Google Style: <code class="badcode">name_</code>, <code class="badcode">mName</code>,
+<code class="badcode">s_name</code> and <code class="badcode">kName</code>.</p>
<h3 id="s5.2-specific-identifier-names">5.2 Rules by identifier type</h3>
diff --git a/jsguide.html b/jsguide.html
index c931a69..8e414af 100644
--- a/jsguide.html
+++ b/jsguide.html
@@ -89,36 +89,19 @@
<p>Tip: In the Unicode escape case, and occasionally even when actual Unicode
characters are used, an explanatory comment can be very helpful.</p>
-<table>
- <thead>
- <tr>
- <th>Example
- </th><th>Discussion
- </th></tr></thead><tbody>
- <tr>
- <td><code class="prettyprint lang-js">const units = 'μs';</code>
- </td><td>Best: perfectly clear even without a comment.
- </td></tr><tr>
- <td>
- <code class="prettyprint lang-js">const units = '\u03bcs'; // 'μs'
- </code>
- </td><td>Allowed, but there’s no reason to do this.
- </td></tr><tr>
- <td>
- <code class="prettyprint lang-js">const units = '\u03bcs'; // Greek letter mu, 's'
- </code>
- </td><td>Allowed, but awkward and prone to mistakes.
- </td></tr><tr>
- <td><code class="badcode">const units = '\u03bcs';</code>
- </td><td>Poor: the reader has no idea what this is.
- </td></tr><tr>
- <td>
- <code class="prettyprint lang-js">return '\ufeff' + content; // byte order mark
- </code>
- </td><td>
- Good: use escapes for non-printable characters, and comment if
- necessary.
-</td></tr></tbody></table>
+<pre><code class="language-js prettyprint">/* Best: perfectly clear even without a comment. */
+const units = 'μs';
+
+/* Allowed: but unncessary as μ is a printable character. */
+const units = '\u03bcs'; // 'μs'
+
+/* Good: use escapes for non-printable characters with a comment for clarity. */
+return '\ufeff' + content; // Prepend a byte order mark.
+</code></pre>
+
+<pre><code class="language-js prettyprint badcode">/* Poor: the reader has no idea what character this is. */
+const units = '\u03bcs';
+</code></pre>
<p>Tip: Never make your code less readable simply out of fear that some programs
might not handle non-ASCII characters properly. If that happens, those programs
@@ -126,13 +109,16 @@
<h2 id="source-file-structure">3 Source file structure</h2>
-<p>A source file consists of, <strong>in order</strong>:</p>
+<p>All new source files should either be a <code>goog.module</code> file (a file containing a
+<code>goog.module</code> call) or an ECMAScript (ES) module (uses <code>import</code> and <code>export</code>
+statements). Files consist of the following, <strong>in order</strong>:</p>
<ol>
<li>License or copyright information, if present</li>
<li><code>@fileoverview</code> JSDoc, if present</li>
-<li><code>goog.module</code> statement</li>
-<li><code>goog.require</code> statements</li>
+<li><code>goog.module</code> statement, if a <code>goog.module</code> file</li>
+<li>ES <code>import</code> statements, if an ES module</li>
+<li><code>goog.require</code> and <code>goog.requireType</code> statements</li>
<li>The file’s implementation</li>
</ol>
@@ -149,9 +135,9 @@
<h3 id="file-goog-module">3.3 <code>goog.module</code> statement</h3>
-<p>All files must declare exactly one <code>goog.module</code> name on a single line: lines
-containing a <code>goog.module</code> declaration must not be wrapped, and are therefore an
-exception to the 80-column limit.</p>
+<p>All <code>goog.module</code> files must declare exactly one <code>goog.module</code> name on a single
+line: lines containing a <code>goog.module</code> declaration must not be wrapped, and are
+therefore an exception to the 80-column limit.</p>
<p>The entire argument to goog.module is what defines a namespace. It is the
package name (an identifier that reflects the fragment of the directory
@@ -168,7 +154,7 @@
<p>Module namespaces may never be named as a <em>direct</em> child of another module's
namespace.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">goog.module('foo.bar'); // 'foo.bar.qux' would be fine, though
goog.module('foo.bar.baz');
@@ -179,12 +165,7 @@
implies that owners of “parent” namespace groups are necessarily aware of all
child namespaces, since they exist in the same directory.</p>
-<h4 id="file-set-test-only">3.3.2 <code>goog.setTestOnly</code></h4>
-
-<p>The single <code>goog.module</code> statement may optionally be followed by a call to
-goog.setTestOnly().</p>
-
-<h4 id="file-declare-legacy-namespace">3.3.3 <code>goog.module.declareLegacyNamespace</code></h4>
+<h4 id="file-declare-legacy-namespace">3.3.2 <code>goog.module.declareLegacyNamespace</code></h4>
<p>The single <code>goog.module</code> statement may optionally be followed by a call to
<code>goog.module.declareLegacyNamespace();</code>. Avoid
@@ -205,29 +186,415 @@
<code>goog.module('parent.child');</code> cannot both exist safely, nor can
<code>goog.module('parent');</code> and <code>goog.module('parent.child.grandchild');</code>).</p>
-<h4 id="file-es6-modules">3.3.4 ES6 Modules</h4>
+<h3 id="file-goog-module-exports">3.3.3 <code>goog.module</code> Exports</h3>
-<p>Do not use ES6 modules yet (i.e. the <code>export</code> and <code>import</code> keywords), as their
-semantics are not yet finalized. Note that this policy will be revisited once
-the semantics are fully-standard.</p>
+<p>Classes, enums, functions, constants, and other symbols are exported using the
+<code>exports</code> object. Exported symbols may be defined directly on the <code>exports</code>
+object, or else declared locally and exported separately. Symbols are only
+exported if they are meant to be used outside the module. Non-exported
+module-local symbols are not declared <code>@private</code> nor do their names end with an
+underscore. There is no prescribed ordering for exported and module-local
+symbols.</p>
-<h3 id="file-goog-require">3.4 <code>goog.require</code> statements</h3>
+<p>Examples:</p>
-<p>Imports are done with <code>goog.require</code> statements, grouped together immediately
-following the module declaration. Each <code>goog.require</code> is assigned to a single
-constant alias, or else destructured into several constant aliases. These
-aliases are the only acceptable way to refer to the <code>require</code>d dependency,
-whether in code or in type annotations: the fully qualified name is never used
-except as the argument to <code>goog.require</code>. Alias names should match the final
-dot-separated component of the imported module name when possible, though
-additional components may be included (with appropriate casing such that the
-alias' casing still correctly identifies its type) if necessary to
-disambiguate, or if it significantly improves readability. <code>goog.require</code>
-statements may not appear anywhere else in the file.</p>
+<pre><code class="language-js prettyprint">const /** !Array<number> */ exportedArray = [1, 2, 3];
-<p>If a module is imported only for its side effects, the assignment may be
-omitted, but the fully qualified name may not appear anywhere else in the file.
-A comment is required to explain why this is needed and suppress a compiler
+const /** !Array<number> */ moduleLocalArray = [4, 5, 6];
+
+/** @return {number} */
+function moduleLocalFunction() {
+ return moduleLocalArray.length;
+}
+
+/** @return {number} */
+function exportedFunction() {
+ return moduleLocalFunction() * 2;
+}
+
+exports = {exportedArray, exportedFunction};
+</code></pre>
+
+<pre><code class="language-js prettyprint">/** @const {number} */
+exports.CONSTANT_ONE = 1;
+
+/** @const {string} */
+exports.CONSTANT_TWO = 'Another constant';
+</code></pre>
+
+<p>Do not annotate the <code>exports</code> object as <code>@const</code> as it is already treated as a
+constant by the compiler.</p>
+
+<pre><code class="language-js badcode prettyprint">/** @const */
+exports = {exportedFunction};
+</code></pre>
+
+<p><span id="file-es6-modules"></span></p>
+
+<h3 id="file-es-modules">3.4 ES modules</h3>
+
+<p><span id="es6-module-imports"></span></p>
+
+<h4 id="es-module-imports">3.4.1 Imports</h4>
+
+<p>Import statements must not be line wrapped and are therefore an exception to the
+80-column limit.</p>
+
+<p><span id="es6-import-paths"></span></p>
+
+<h5 id="esm-import-paths">3.4.1.1 Import paths</h5>
+
+<p>ES module files must use the <code>import</code> statement to import other ES module
+files. Do not <code>goog.require</code> another ES module.</p>
+
+<pre><code class="language-js prettyprint external">import './sideeffects.js';
+
+import * as goog from '../closure/goog/goog.js';
+import * as parent from '../parent.js';
+
+import {name} from './sibling.js';
+</code></pre>
+
+<p><span id="es6-import-paths-file-extension"></span></p>
+
+<h6 id="esm-import-paths-file-extension">3.4.1.1.1 File extensions in import paths</h6>
+
+<p>The <code>.js</code> file extension is not optional in import paths and must always be
+included.</p>
+
+<pre><code class="language-js badcode prettyprint">import '../directory/file';
+</code></pre>
+
+<pre><code class="language-js good prettyprint">import '../directory/file.js';
+</code></pre>
+
+<h5 id="importing-the-same-file-multiple-times">3.4.1.2 Importing the same file multiple times</h5>
+
+<p>Do not import the same file multiple times. This can make it hard to determine
+the aggregate imports of a file.</p>
+
+<pre><code class="language-js badcode prettyprint">// Imports have the same path, but since it doesn't align it can be hard to see.
+import {short} from './long/path/to/a/file.js';
+import {aLongNameThatBreaksAlignment} from './long/path/to/a/file.js';
+</code></pre>
+
+<p><span id="naming-es6-imports"></span></p>
+
+<h5 id="naming-esm-imports">3.4.1.3 Naming imports</h5>
+
+<h6 id="naming-module-imports">3.4.1.3.1 Naming module imports</h6>
+
+<p>Module import names (<code>import * as name</code>) are <code>lowerCamelCase</code> names that are
+derived from the imported file name.</p>
+
+<pre><code class="language-js prettyprint">import * as fileOne from '../file-one.js';
+import * as fileTwo from '../file_two.js';
+import * as fileThree from '../filethree.js';
+</code></pre>
+
+<pre><code class="language-js prettyprint">import * as libString from './lib/string.js';
+import * as math from './math/math.js';
+import * as vectorMath from './vector/math.js';
+</code></pre>
+
+<h6 id="naming-default-imports">3.4.1.3.2 Naming default imports</h6>
+
+<p>Default import names are derived from the imported file name and follow the
+rules in <a href="#naming-rules-by-identifier-type">??</a>.</p>
+
+<pre><code class="language-js prettyprint">import MyClass from '../my-class.js';
+import myFunction from '../my_function.js';
+import SOME_CONSTANT from '../someconstant.js';
+</code></pre>
+
+<p>Note: In general this should not happen as default exports are banned by this
+style guide, see <a href="#named-vs-default-exports">??</a>. Default imports are only used
+to import modules that do not conform to this style guide.</p>
+
+<h6 id="naming-named-imports">3.4.1.3.3 Naming named imports</h6>
+
+<p>In general symbols imported via the named import (<code>import {name}</code>) should keep
+the same name. Avoid aliasing imports (<code>import {SomeThing as SomeOtherThing}</code>).
+Prefer fixing name collisions by using a module import (<code>import *</code>) or renaming
+the exports themselves.</p>
+
+<pre><code class="language-js prettyprint">import * as bigAnimals from './biganimals.js';
+import * as domesticatedAnimals from './domesticatedanimals.js';
+
+new bigAnimals.Cat();
+new domesticatedAnimals.Cat();
+</code></pre>
+
+<p>If renaming a named import is needed then use components of the imported
+module's file name or path in the resulting alias.</p>
+
+<pre><code class="language-js prettyprint">import {Cat as BigCat} from './biganimals.js';
+import {Cat as DomesticatedCat} from './domesticatedanimals.js';
+
+new BigCat();
+new DomesticatedCat();
+</code></pre>
+
+<p><span id="es6-module-exports"></span></p>
+
+<h4 id="es-module-exports">3.4.2 Exports</h4>
+
+<p>Symbols are only exported if they are meant to be used outside the module.
+Non-exported module-local symbols are not declared <code>@private</code> nor do their names
+end with an underscore. There is no prescribed ordering for exported and
+module-local symbols.</p>
+
+<h5 id="named-vs-default-exports">3.4.2.1 Named vs default exports</h5>
+
+<p>Use named exports in all code. You can apply the <code>export</code> keyword to a
+declaration, or use the <code>export {name};</code> syntax.</p>
+
+<p>Do not use default exports. Importing modules must give a name to these values,
+which can lead to inconsistencies in naming across modules.</p>
+
+<pre><code class="language-js badcode prettyprint">// Do not use default exports:
+export default class Foo { ... } // BAD!
+</code></pre>
+
+<pre><code class="language-js good prettyprint">// Use named exports:
+export class Foo { ... }
+</code></pre>
+
+<pre><code class="language-js good prettyprint">// Alternate style named exports:
+class Foo { ... }
+
+export {Foo};
+</code></pre>
+
+<h5 id="exporting-static-containers">3.4.2.2 Exporting static container classes and objects</h5>
+
+<p>Do not export container classes or objects with static methods or properties for
+the sake of namespacing.</p>
+
+<pre><code class="language-js badcode prettyprint">// container.js
+// Bad: Container is an exported class that has only static methods and fields.
+export class Container {
+ /** @return {number} */
+ static bar() {
+ return 1;
+ }
+}
+
+/** @const {number} */
+Container.FOO = 1;
+</code></pre>
+
+<p>Instead, export individual constants and functions:</p>
+
+<pre><code class="language-js good prettyprint">/** @return {number} */
+export function bar() {
+ return 1;
+}
+
+export const /** number */ FOO = 1;
+</code></pre>
+
+<p><span id="es6-exports-mutability"></span></p>
+
+<h5 id="esm-exports-mutability">3.4.2.3 Mutability of exports</h5>
+
+<p>Exported variables must not be mutated outside of module initialization.</p>
+
+<p>There are alternatives if mutation is needed, including exporting a constant
+reference to an object that has mutable fields or exporting accessor functions for
+mutable data.</p>
+
+<pre><code class="language-js badcode prettyprint">// Bad: both foo and mutateFoo are exported and mutated.
+export let /** number */ foo = 0;
+
+/**
+ * Mutates foo.
+ */
+export function mutateFoo() {
+ ++foo;
+}
+
+/**
+ * @param {function(number): number} newMutateFoo
+ */
+export function setMutateFoo(newMutateFoo) {
+ // Exported classes and functions can be mutated!
+ mutateFoo = () => {
+ foo = newMutateFoo(foo);
+ };
+}
+</code></pre>
+
+<pre><code class="language-js good prettyprint">// Good: Rather than export the mutable variables foo and mutateFoo directly,
+// instead make them module scoped and export a getter for foo and a wrapper for
+// mutateFooFunc.
+let /** number */ foo = 0;
+let /** function(number): number */ mutateFooFunc = foo => foo + 1;
+
+/** @return {number} */
+export function getFoo() {
+ return foo;
+}
+
+export function mutateFoo() {
+ foo = mutateFooFunc(foo);
+}
+
+/** @param {function(number): number} mutateFoo */
+export function setMutateFoo(mutateFoo) {
+ mutateFooFunc = mutateFoo;
+}
+</code></pre>
+
+<p><span id="es6-module-circular-dependencies"></span></p>
+
+<h5 id="es-module-export-from">3.4.2.4 export from</h5>
+
+<p><code>export from</code> statements must not be line wrapped and are therefore an
+exception to the 80-column limit. This applies to both <code>export from</code> flavors.</p>
+
+<pre><code class="language-js">export {specificName} from './other.js';
+export * from './another.js';
+</code></pre>
+
+<h4 id="es-module-circular-dependencies">3.4.3 Circular Dependencies in ES modules</h4>
+
+<p>Do not create cycles between ES modules, even though the ECMAScript
+specification allows this. Note that it is possible to create cycles with both
+the <code>import</code> and <code>export</code> statements.</p>
+
+<pre><code class="language-js badcode prettyprint">// a.js
+import './b.js';
+</code></pre>
+
+<pre><code class="language-js badcode prettyprint">// b.js
+import './a.js';
+
+// `export from` can cause circular dependencies too!
+export {x} from './c.js';
+</code></pre>
+
+<pre><code class="language-js badcode prettyprint">// c.js
+import './b.js';
+
+export let x;
+</code></pre>
+
+<p><span id="es6-module-closure-interop"></span></p>
+
+<h4 id="es-module-closure-interop">3.4.4 Interoperating with Closure</h4>
+
+<p><span id="es6-module-referencing-goog"></span></p>
+
+<h5 id="es-module-referencing-goog">3.4.4.1 Referencing goog</h5>
+
+<p>To reference the Closure <code>goog</code> namespace, import Closure's <code>goog.js</code>.</p>
+
+<pre><code class="language-js good prettyprint external">import * as goog from '../closure/goog/goog.js';
+
+const name = goog.require('a.name');
+
+export const CONSTANT = name.compute();
+</code></pre>
+
+<p><code>goog.js</code> exports only a subset of properties from the global <code>goog</code> that can be
+used in ES modules.</p>
+
+<p><span id="goog-require-in-es6-module"></span></p>
+
+<h5 id="goog-require-in-es-module">3.4.4.2 goog.require in ES modules</h5>
+
+<p><code>goog.require</code> in ES modules works as it does in <code>goog.module</code> files. You can
+require any Closure namespace symbol (i.e., symbols created by <code>goog.provide</code> or
+<code>goog.module</code>) and <code>goog.require</code> will return the value.</p>
+
+<pre><code class="language-js prettyprint external">import * as goog from '../closure/goog/goog.js';
+import * as anEsModule from './anEsModule.js';
+
+const GoogPromise = goog.require('goog.Promise');
+const myNamespace = goog.require('my.namespace');
+</code></pre>
+
+<p><span id="closure-module-id-in-es6-module"></span></p>
+
+<h5 id="closure-module-id-in-es-module">3.4.4.3 Declaring Closure Module IDs in ES modules</h5>
+
+<p><code>goog.declareModuleId</code> can be used within ES modules to declare a
+<code>goog.module</code>-like module ID. This means that this module ID can be
+<code>goog.require</code>d, <code>goog.module.get</code>d, <code>goog.forwardDeclare</code>'d, etc. as if it were
+a <code>goog.module</code> that did not call <code>goog.module.declareLegacyNamespace</code>. It does
+not create the module ID as a globally available JavaScript symbol.</p>
+
+<p>A <code>goog.require</code> (or <code>goog.module.get</code>) for a module ID from
+<code>goog.declareModuleId</code> will always return the module object (as if it was
+<code>import *</code>'d). As a result, the argument to <code>goog.declareModuleId</code> should always
+end with a <code>lowerCamelCaseName</code>.</p>
+
+<p>Note: It is an error to call <code>goog.module.declareLegacyNamespace</code> in an ES
+module, it can only be called from <code>goog.module</code> files. There is no direct way
+to associate a <q>legacy</q> namespace with an ES module.</p>
+
+<p><code>goog.declareModuleId</code> should only be used to upgrade Closure files to ES
+modules in place, where named exports are used.</p>
+
+<pre><code class="language-js prettyprint external">import * as goog from '../closure/goog.js';
+
+goog.declareModuleId('my.esm');
+
+export class Class {};
+</code></pre>
+
+<h3 id="file-set-test-only">3.5 <code>goog.setTestOnly</code></h3>
+
+<p>In a <code>goog.module</code> file the <code>goog.module</code> statement may optionally be followed
+by a call to <code>goog.setTestOnly()</code>.</p>
+
+<p>In an ES module the <code>import</code> statements may optionally be followed by a call to
+<code>goog.setTestOnly()</code>.</p>
+
+<h3 id="file-goog-require">3.6 <code>goog.require</code> and <code>goog.requireType</code> statements</h3>
+
+<p>Imports are done with <code>goog.require</code> and <code>goog.requireType</code> statements. The
+names imported by a <code>goog.require</code> statement may be used both in code and in
+type annotations, while those imported by a <code>goog.requireType</code> may be used
+in type annotations only.</p>
+
+<p>The <code>goog.require</code> and <code>goog.requireType</code> statements form a contiguous block
+with no empty lines. This block follows the <code>goog.module</code> declaration separated
+<a href="#source-file-structure">by a single empty line</a>. The entire argument to
+<code>goog.require</code> or <code>goog.requireType</code> is a namespace defined by a <code>goog.module</code>
+in a separate file. <code>goog.require</code> and <code>goog.requireType</code> statements may not
+appear anywhere else in the file.</p>
+
+<p>Each <code>goog.require</code> or <code>goog.requireType</code> is assigned to a single constant
+alias, or else destructured into several constant aliases. These aliases are the
+only acceptable way to refer to dependencies in type annotations or code. Fully
+qualified namespaces must not be used anywhere, except as an argument to
+<code>goog.require</code> or <code>goog.requireType</code>.</p>
+
+<p><strong>Exception</strong>: Types, variables, and functions declared in externs files have to
+use their fully qualified name in type annotations and code.</p>
+
+<p>Aliases must match the final dot-separated component of the imported module's
+namespace.</p>
+
+<p><strong>Exception</strong>: In certain cases, additional components of the namespace can be
+used to form a longer alias. The resulting alias must retain the original
+identifier's casing such that it still correctly identifies its type. Longer
+aliases may be used to disambiguate otherwise identical aliases, or if it
+significantly improves readability. In addition, a longer alias must be used to
+prevent masking native types such as <code>Element</code>, <code>Event</code>, <code>Error</code>, <code>Map</code>, and
+<code>Promise</code> (for a more complete list, see <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects">Standard Built-in Objects</a> and <a href="https://developer.mozilla.org/en-US/docs/Web/API">Web
+APIs</a> at MDN). When renaming destructured aliases, a space must follow the colon
+as required in <a href="#formatting-horizontal-whitespace">??</a>.</p>
+
+<p>A file should not contain both a <code>goog.require</code> and a <code>goog.requireType</code>
+statement for the same namespace. If the imported name is used both in code and
+in type annotations, it should be imported by a single <code>goog.require</code> statement.</p>
+
+<p>If a module is imported only for its side effects, the call must be a
+<code>goog.require</code> (not a <code>goog.requireType</code>) and assignment may be omitted. A
+comment is required to explain why this is needed and suppress a compiler
warning.</p>
@@ -235,51 +602,83 @@
<p>The lines are sorted according to the following rules: All requires with a name
on the left hand side come first, sorted alphabetically by those names. Then
destructuring requires, again sorted by the names on the left hand side.
-Finally, any <code>goog.require</code> calls that are standalone (generally these are for
-modules imported just for their side effects).</p>
+Finally, any require calls that are standalone (generally these are for modules
+imported just for their side effects).</p>
<p>Tip: There’s no need to memorize this order and enforce it manually. You can
rely on your IDE to report requires
that are not sorted correctly.</p>
<p>If a long alias or module name would cause a line to exceed the 80-column limit,
-it <strong>must not</strong> be wrapped: goog.require lines are an exception to the 80-column
+it <strong>must not</strong> be wrapped: require lines are an exception to the 80-column
limit.</p>
<p>Example:</p>
-<pre><code class="language-js prettyprint">const MyClass = goog.require('some.package.MyClass');
+<pre><code class="language-js prettyprint">// Standard alias style.
+const MyClass = goog.require('some.package.MyClass');
+const MyType = goog.requireType('some.package.MyType');
+// Namespace-based alias used to disambiguate.
const NsMyClass = goog.require('other.ns.MyClass');
-const googAsserts = goog.require('goog.asserts');
+// Namespace-based alias used to prevent masking native type.
+const RendererElement = goog.require('web.renderer.Element');
+// Out of sequence namespace-based aliases used to improve readability.
+// Also, require lines longer than 80 columns must not be wrapped.
+const SomeDataStructureModel = goog.requireType('identical.package.identifiers.models.SomeDataStructure');
+const SomeDataStructureProto = goog.require('proto.identical.package.identifiers.SomeDataStructure');
+// Standard alias style.
+const asserts = goog.require('goog.asserts');
+// Namespace-based alias used to disambiguate.
const testingAsserts = goog.require('goog.testing.asserts');
-const than80columns = goog.require('pretend.this.is.longer.than80columns');
-const {clear, forEach, map} = goog.require('goog.array');
+// Standard destructuring into aliases.
+const {clear, clone} = goog.require('goog.array');
+const {Rgb} = goog.require('goog.color');
+// Namespace-based destructuring into aliases in order to disambiguate.
+const {SomeType: FooSomeType} = goog.requireType('foo.types');
+const {clear: objectClear, clone: objectClone} = goog.require('goog.object');
+// goog.require without an alias in order to trigger side effects.
/** @suppress {extraRequire} Initializes MyFramework. */
goog.require('my.framework.initialization');
</code></pre>
-<p>Illegal:</p>
+<p>Discouraged:</p>
-<pre><code class="language-js badcode prettyprint">const randomName = goog.require('something.else'); // name must match
+<pre><code class="language-js badcode prettyprint">// If necessary to disambiguate, prefer PackageClass over SomeClass as it is
+// closer to the format of the module name.
+const SomeClass = goog.require('some.package.Class');
+</code></pre>
-const {clear, forEach, map} = // don't break lines
- goog.require('goog.array');
+<p>Disallowed:</p>
-function someFunction() {
- const alias = goog.require('my.long.name.alias'); // must be at top level
- // …
+<pre><code class="language-js badcode prettyprint">// Extra terms must come from the namespace.
+const MyClassForBizzing = goog.require('some.package.MyClass');
+// Alias must include the entire final namespace component.
+const MyClass = goog.require('some.package.MyClassForBizzing');
+// Alias must not mask native type (should be `const JspbMap` here).
+const Map = goog.require('jspb.Map');
+// Don't break goog.require lines over 80 columns.
+const SomeDataStructure =
+ goog.require('proto.identical.package.identifiers.SomeDataStructure');
+// Alias must be based on the namespace.
+const randomName = goog.require('something.else');
+// Missing a space after the colon.
+const {Foo:FooProto} = goog.require('some.package.proto.Foo');
+// goog.requireType without an alias.
+goog.requireType('some.package.with.a.Type');
+
+
+/**
+ * @param {!some.unimported.Dependency} param All external types used in JSDoc
+ * annotations must be goog.require'd, unless declared in externs.
+ */
+function someFunction(param) {
+ // goog.require lines must be at the top level before any other code.
+ const alias = goog.require('my.long.name.alias');
+ // ...
}
</code></pre>
-<h4 id="file-goog-forward-declare">3.4.1 <code>goog.forwardDeclare</code></h4>
-
-<p><code>goog.forwardDeclare</code> is not needed very often, but is a valuable tool to break
-circular dependencies or to reference late loaded code. These statements are
-grouped together and immediately follow any <code>goog.require</code> statements. A
-<code>goog.forwardDeclare</code> statement must follow the same style rules as a
-<code>goog.require</code> statement.</p>
-
-<h3 id="file-implementation">3.5 The file’s implementation</h3>
+<h3 id="file-implementation">3.7 The file’s implementation</h3>
<p>The actual implementation follows after all dependency information is declared
(separated by at least one blank line).</p>
@@ -308,7 +707,7 @@
<code>while</code>, as well as any others), even if the body contains only a single
statement. The first statement of a non-empty block must begin on its own line.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js badcode prettyprint">if (someVeryLongCondition())
doSomething();
@@ -321,7 +720,7 @@
braces when it improves readability. This is the only case in which a control
structure may omit braces and newlines.</p>
-<pre><code class="language-js prettyprint">if (shortCondition()) return;
+<pre><code class="language-js prettyprint">if (shortCondition()) foo();
</code></pre>
<h4 id="formatting-nonempty-blocks">4.1.2 Nonempty blocks: K&R style</h4>
@@ -370,7 +769,7 @@
<pre><code class="language-js prettyprint">function doNothing() {}
</code></pre>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">if (condition) {
// …
@@ -557,16 +956,25 @@
<p><strong>Exceptions:</strong></p>
<ol>
-<li>Lines where obeying the column limit is not possible (for example, a long URL
-in JSDoc or a shell command intended to be copied-and-pasted).</li>
-<li><code>goog.module</code> and <code>goog.require</code> statements (see <a href="#file-goog-module">??</a> and
-<a href="#file-goog-require">??</a>).</li>
+<li><code>goog.module</code>, <code>goog.require</code> and <code>goog.requireType</code> statements (see
+<a href="#file-goog-module">??</a> and <a href="#file-goog-require">??</a>).</li>
+<li>ES module <code>import</code> and <code>export from</code> statements (see
+<a href="#es-module-imports">??</a> and <a href="#es-module-export-from">??</a>).</li>
+<li>Lines where obeying the column limit is not possible or would hinder
+discoverability. Examples include:
+<ul>
+<li>A long URL which should be clickable in source.</li>
+<li>A shell command intended to be copied-and-pasted.</li>
+<li>A long string literal which may need to be copied or searched for wholly
+(e.g., a long file path).</li>
+</ul></li>
</ol>
<h3 id="formatting-line-wrapping">4.5 Line-wrapping</h3>
-<p><strong>Terminology Note</strong>: <em>Line-wrapping</em> is defined as breaking a single expression
-into multiple lines.</p>
+<p><strong>Terminology Note</strong>: <em>Line wrapping</em> is breaking a chunk of code into multiple
+lines to obey column limit, where the chunk could otherwise legally fit in a
+single line.</p>
<p>There is no comprehensive, deterministic formula showing <em>exactly</em> how to
line-wrap in every situation. Very often there are several valid ways to
@@ -588,13 +996,13 @@
<pre><code class="language-js prettyprint">currentEstimate =
calc(currentEstimate + x * currentEstimate) /
- 2.0f;
+ 2.0;
</code></pre>
<p>Discouraged:</p>
<pre><code class="language-js prettyprint badcode">currentEstimate = calc(currentEstimate + x *
- currentEstimate) / 2.0f;
+ currentEstimate) / 2.0;
</code></pre>
<p>In the preceding example, the syntactic levels from highest to lowest are as
@@ -669,26 +1077,28 @@
following places <strong>only</strong>.</p>
<ol>
-<li>Separating any reserved word (such as <code>if</code>, <code>for</code>, or <code>catch</code>) from an open
-parenthesis (<code>(</code>) that follows it on that line.</li>
+<li>Separating any reserved word (such as <code>if</code>, <code>for</code>, or <code>catch</code>) except for
+<code>function</code> and <code>super</code>, from an open parenthesis (<code>(</code>) that follows it on
+that line.</li>
<li>Separating any reserved word (such as <code>else</code> or <code>catch</code>) from a closing
curly brace (<code>}</code>) that precedes it on that line.</li>
<li>Before any open curly brace (<code>{</code>), with two exceptions:
<ol>
<li>Before an object literal that is the first argument of a function or the
first element in an array literal (e.g. <code>foo({a: [{c: d}]})</code>).</li>
-<li>In a template expansion, as it is forbidden by the language
-(e.g. <code>abc${1 + 2}def</code>).</li>
+<li>In a template expansion, as it is forbidden by the language (e.g. valid:
+<code>`ab${1 + 2}cd`</code>, invalid: <code class="badcode">`xy$ {3}z`</code>).</li>
</ol></li>
<li>On both sides of any binary or ternary operator.</li>
<li>After a comma (<code>,</code>) or semicolon (<code>;</code>). Note that spaces are <em>never</em> allowed
before these characters.</li>
<li>After the colon (<code>:</code>) in an object literal.</li>
-<li>On both sides of the double slash (<code>//</code>) that begins an end-of-line
-comment. Here, multiple spaces are allowed, but not required.</li>
-<li>After an open-JSDoc comment character and on both sides of close characters
-(e.g. for short-form type declarations or casts: <code>this.foo = /** @type
-{number} */ (bar);</code> or <code>function(/** string */ foo) {</code>).</li>
+<li>On both sides of the double slash (<code>//</code>) that begins an end-of-line comment.
+Here, multiple spaces are allowed, but not required.</li>
+<li>After an open-block comment character and on both sides of close characters
+(e.g. for short-form type declarations, casts, and parameter name comments:
+<code>this.foo = /** @type {number} */ (bar)</code>; or <code>function(/** string */ foo)
+{</code>; or <code>baz(/* buzz= */ true)</code>).</li>
</ol>
<h4 id="formatting-horizontal-alignment">4.6.3 Horizontal alignment: discouraged</h4>
@@ -778,9 +1188,7 @@
<p>Block comments are indented at the same level as the surrounding code. They may
be in <code>/* … */</code> or <code>//</code>-style. For multi-line <code>/* … */</code> comments, subsequent
lines must start with * aligned with the <code>*</code> on the previous line, to make
-comments obvious with no extra context. “Parameter name” comments should appear
-after values whenever the value and method name do not sufficiently convey the
-meaning.</p>
+comments obvious with no extra context.</p>
<pre><code class="language-js prettyprint">/*
* This is
@@ -791,13 +1199,27 @@
// is this.
/* This is fine, too. */
-
-someFunction(obviousParam, true /* shouldRender */, 'hello' /* name */);
</code></pre>
<p>Comments are not enclosed in boxes drawn with asterisks or other characters.</p>
-<p>Do not use JSDoc (<code>/** … */</code>) for any of the above implementation comments.</p>
+<p>Do not use JSDoc (<code>/** … */</code>) for implementation comments.</p>
+
+<h4 id="formatting-param-name-comments">4.8.2 Parameter Name Comments</h4>
+
+<p>“Parameter name” comments should be used whenever the value and method name do
+not sufficiently convey the meaning, and refactoring the method to be clearer is
+infeasible .
+Their preferred format is before the value with <q>=</q>:</p>
+
+<pre><code class="language-js prettyprint">someFunction(obviousParam, /* shouldRender= */ true, /* name= */ 'hello');
+</code></pre>
+
+<p>For consistency with surrounding code you may put them after the value without
+<q>=</q>:</p>
+
+<pre><code class="language-js prettyprint">someFunction(obviousParam, true /* shouldRender */, 'hello' /* name */);
+</code></pre>
<h2 id="language-features">5 Language features</h2>
@@ -827,16 +1249,26 @@
<h4 id="features-declare-types-as-needed">5.1.4 Declare types as needed</h4>
<p>JSDoc type annotations may be added either on the line above the declaration, or
-else inline before the variable name.</p>
+else inline before the variable name if no other JSDoc is present.</p>
<p>Example:</p>
<pre><code class="language-js prettyprint">const /** !Array<number> */ data = [];
-/** @type {!Array<number>} */
+/**
+ * Some description.
+ * @type {!Array<number>}
+ */
const data = [];
</code></pre>
+<p>Mixing inline and JSDoc styles is not allowed: the compiler will only process
+the first JsDoc and the inline annotations will be lost.</p>
+
+<pre><code class="language-js prettyprint badcode">/** Some description. */
+const /** !Array<number> */ data = [];
+</code></pre>
+
<p>Tip: There are many cases where the compiler can infer a templatized type but
not its parameters. This is particularly the case when the initializing literal
or constructor call does not include any values of the template parameter type
@@ -866,7 +1298,7 @@
<p>The constructor is error-prone if arguments are added or removed. Use a literal
instead.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">const a1 = new Array(x1, x2, x3);
const a2 = new Array(x1, x2);
@@ -915,14 +1347,14 @@
function optionalDestructuring([a = 4, b = 2] = []) { … };
</code></pre>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">function badDestructuring([a, b] = [4, 2]) { … };
</code></pre>
<p>Tip: For (un)packing multiple values into a function’s parameter or return,
prefer object destructuring to array destructuring when possible, as it allows
-naming the individual elements and specifying a different type for each.*</p>
+naming the individual elements and specifying a different type for each.</p>
<h4 id="features-arrays-spread-operator">5.2.5 Spread operator</h4>
@@ -956,11 +1388,33 @@
symbols) or <em>dicts</em> (with quoted and/or computed keys). Do not mix these key
types in a single object literal.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">{
- a: 42, // struct-style unquoted key
- 'b': 43, // dict-style quoted key
+ width: 42, // struct-style unquoted key
+ 'maxWidth': 43, // dict-style quoted key
+}
+</code></pre>
+
+<p>This also extends to passing the property name to functions, like
+<code>hasOwnProperty</code>. In particular, doing so will break in compiled code because
+the compiler cannot rename/obfuscate the string literal.</p>
+
+<p>Disallowed:</p>
+
+<pre><code class="language-js prettyprint badcode">/** @type {{width: number, maxWidth: (number|undefined)}} */
+const o = {width: 42};
+if (o.hasOwnProperty('maxWidth')) {
+ ...
+}
+</code></pre>
+
+<p>This is best implemented as:</p>
+
+<pre><code class="language-js prettyprint">/** @type {{width: number, maxWidth: (number|undefined)}} */
+const o = {width: 42};
+if (o.maxWidth != null) {
+ ...
}
</code></pre>
@@ -968,9 +1422,10 @@
<p>Computed property names (e.g., <code>{['key' + foo()]: 42}</code>) are allowed, and are
considered dict-style (quoted) keys (i.e., must not be mixed with non-quoted
-keys) unless the computed property is a symbol (e.g., <code>[Symbol.iterator]</code>).
-Enum values may also be used for computed keys, but should not be mixed with
-non-enum keys in the same literal.</p>
+keys) unless the computed property is a
+<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol">symbol</a>
+(e.g., <code>[Symbol.iterator]</code>). Enum values may also be used for computed keys, but
+should not be mixed with non-enum keys in the same literal.</p>
<h4 id="features-objects-method-shorthand">5.3.5 Method shorthand</h4>
@@ -1046,7 +1501,7 @@
function destructured(ordinary, {num, str = 'some default'} = {})
</code></pre>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">/** @param {{x: {num: (number|undefined), str: (string|undefined)}}} param1 */
function nestedTooDeeply({x: {num, str}}) {};
@@ -1093,17 +1548,18 @@
<h4 id="features-classes-constructors">5.4.1 Constructors</h4>
-<p>Constructors are optional for concrete classes. Subclass constructors must call
-<code>super()</code> before setting any fields or otherwise accessing <code>this</code>. Interfaces
-must not define a constructor.</p>
+<p>Constructors are optional. Subclass constructors must call <code>super()</code> before
+setting any fields or otherwise accessing <code>this</code>. Interfaces should declare
+non-method properties in the constructor.</p>
<h4 id="features-classes-fields">5.4.2 Fields</h4>
<p>Set all of a concrete object’s fields (i.e. all properties other than methods)
in the constructor. Annotate fields that are never reassigned with <code>@const</code>
-(these need not be deeply immutable). Private fields must be annotated with
-<code>@private</code> and their names must end with a trailing underscore. Fields are never
-set on a concrete class' <code>prototype</code>.</p>
+(these need not be deeply immutable). Annotate non-public fields with the proper
+visibility annotation (<code>@private</code>, <code>@protected</code>, <code>@package</code>), and end all
+<code>@private</code> fields' names with an underscore. Fields are never set on a concrete
+class' <code>prototype</code>.</p>
<p>Example:</p>
@@ -1111,6 +1567,9 @@
constructor() {
/** @private @const {!Bar} */
this.bar_ = computeBar();
+
+ /** @protected @const {!Baz} */
+ this.baz = computeBaz();
}
}
</code></pre>
@@ -1147,12 +1606,12 @@
<code>@nocollapse</code> if this is done), and must not be called directly on a subclass
that doesn’t define the method itself.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">class Base { /** @nocollapse */ static foo() {} }
class Sub extends Base {}
function callFoo(cls) { cls.foo(); } // discouraged: don't call static methods dynamically
-Sub.foo(); // illegal: don't call static methods on subclasses that don't define it themselves
+Sub.foo(); // Disallowed: don't call static methods on subclasses that don't define it themselves
</code></pre>
<h4 id="features-classes-old-style">5.4.5 Old-style class declarations</h4>
@@ -1228,31 +1687,28 @@
<p>The <code>class</code> keyword allows clearer and more readable class definitions than
defining <code>prototype</code> properties. Ordinary implementation code has no business
-manipulating these objects, though they are still useful for defining <code>@record</code>
-interfaces and classes as defined in <a href="#features-classes-old-style">??</a>. Mixins
-and modifying the prototypes of builtin objects are
-explicitly forbidden.</p>
+manipulating these objects, though they are still useful for defining classes as
+defined in <a href="#features-classes-old-style">??</a>. Mixins and modifying the
+prototypes of builtin objects are explicitly forbidden.</p>
<p><strong>Exception</strong>: Framework code (such as Polymer, or Angular) may need to use <code>prototype</code>s, and should not
resort to even-worse workarounds to avoid doing so.</p>
-<p><strong>Exception</strong>: Defining fields in interfaces (see <a href="#features-classes-interfaces">??</a>).</p>
-
<h4 id="features-classes-getters-and-setters">5.4.7 Getters and Setters</h4>
<p>Do not use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get">JavaScript getter and setter properties</a>. They are potentially
surprising and difficult to reason about, and have limited support in the
compiler. Provide ordinary methods instead.</p>
-<p><strong>Exception</strong>: when working with data binding frameworks (such as Angular and
-Polymer), getters and setters may be used sparingly. Note, however, that
-compiler support is limited. When they are used, they must be defined either
-with <code>get foo()</code> and <code>set foo(value)</code> in the class or object literal, or if that
-is not possible, with <code>Object.defineProperties</code>. Do not use
-<code>Object.defineProperty</code>, which interferes with property renaming. Getters
+<p><strong>Exception</strong>: there are situations where defining a getter or setter is
+unavoidable (e.g. data binding frameworks such as Angular and Polymer, or for
+compatibility with external APIs that cannot be adjusted). In these cases only,
+getters and setters may be used <em>with caution</em>, provided they are defined with
+the <code>get</code> and <code>set</code> shorthand method keywords or <code>Object.defineProperties</code> (not
+<code>Object.defineProperty</code>, which interferes with property renaming). Getters
<strong>must not</strong> change observable state.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">class Foo {
get next() { return this.nextId++; }
@@ -1273,8 +1729,8 @@
with <code>@record</code> can be explicitly (i.e. via <code>@implements</code>) or implicitly
implemented by a class or object literal.</p>
-<p>All non-static method bodies on an interface must be empty blocks. Fields must
-be defined after the interface body as stubs on the <code>prototype</code>.</p>
+<p>All non-static method bodies on an interface must be empty blocks. Fields must
+be declared as uninitialized members in the class constructor.</p>
<p>Example:</p>
@@ -1283,6 +1739,11 @@
* @record
*/
class Frobnicator {
+ constructor() {
+ /** @type {number} The number of attempts before giving up. */
+ this.attempts;
+ }
+
/**
* Performs the frobnication according to the given strategy.
* @param {!FrobnicationStrategy} strategy
@@ -1290,43 +1751,36 @@
frobnicate(strategy) {}
}
-/** @type {number} The number of attempts before giving up. */
-Frobnicator.prototype.attempts;
</code></pre>
+<h4 id="features-classes-abstract-classes">5.4.10 Abstract Classes</h4>
+
+<p>Use abstract classes when appropriate. Abstract classes and methods must be
+annotated with <code>@abstract</code>. Do not use <code>goog.abstractMethod</code>. See <a href="https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods">abstract
+classes and methods</a>.</p>
+
<h3 id="features-functions">5.5 Functions</h3>
<h4 id="features-functions-top-level-functions">5.5.1 Top-level functions</h4>
-<p>Exported functions may be defined directly on the <code>exports</code> object, or else
-declared locally and exported separately. Non-exported functions are encouraged
-and should not be declared <code>@private</code>.</p>
+<p>Top-level functions may be defined directly on the <code>exports</code> object, or else
+declared locally and optionally exported. See <a href="#file-goog-module-exports">??</a>
+for more on exports.</p>
<p>Examples:</p>
-<pre><code class="language-js prettyprint">/** @return {number} */
-function helperFunction() {
- return 42;
-}
-/** @return {number} */
-function exportedFunction() {
- return helperFunction() * 2;
-}
-/**
- * @param {string} arg
- * @return {number}
- */
-function anotherExportedFunction(arg) {
- return helperFunction() / arg.length;
-}
-/** @const */
-exports = {exportedFunction, anotherExportedFunction};
+<pre><code class="language-js prettyprint">/** @param {string} str */
+exports.processString = (str) => {
+ // Process the string.
+};
</code></pre>
-<pre><code class="language-js prettyprint">/** @param {string} arg */
-exports.foo = (arg) => {
- // do some stuff ...
+<pre><code class="language-js prettyprint">/** @param {string} str */
+const processString = (str) => {
+ // Process the string.
};
+
+exports = {processString};
</code></pre>
<h4 id="features-functions-nested-functions">5.5.2 Nested functions and closures</h4>
@@ -1336,22 +1790,73 @@
<h4 id="features-functions-arrow-functions">5.5.3 Arrow functions</h4>
-<p>Arrow functions provide a concise syntax and fix a number of difficulties with
-<code>this</code>. Prefer arrow functions over the <code>function</code> keyword, particularly for
-nested functions (but see <a href="#features-objects-method-shorthand">??</a>).</p>
+<p>Arrow functions provide a concise function syntax and simplify scoping <code>this</code>
+for nested functions. Prefer arrow functions over the <code>function</code> keyword,
+particularly for nested functions (but see
+<a href="#features-objects-method-shorthand">??</a>).</p>
-<p>Prefer using arrow functions over <code>f.bind(this)</code>, and especially over
-<code>goog.bind(f, this)</code>. Avoid writing <code>const self = this</code>. Arrow functions are
-particularly useful for callbacks, which sometimes pass unexpected additional
-arguments.</p>
+<p>Prefer arrow functions over other <code>this</code> scoping approaches such as
+<code>f.bind(this)</code>, <code>goog.bind(f, this)</code>, and <code>const self = this</code>. Arrow functions
+are particularly useful for calling into callbacks as they permit explicitly
+specifying which parameters to pass to the callback whereas binding will blindly
+pass along all parameters.</p>
-<p>The right-hand side of the arrow may be a single expression or a block.
-Parentheses around the arguments are optional if there is only a single
-non-destructured argument.</p>
+<p>The left-hand side of the arrow contains zero or more parameters. Parentheses
+around the parameters are optional if there is only a single non-destructured
+parameter. When parentheses are used, inline parameter types may be specified
+(see <a href="#jsdoc-method-and-function-comments">??</a>).</p>
-<p>Tip: It is a good practice to use parentheses even for single-argument arrows,
-since the code may still parse reasonably (but incorrectly) if the parentheses
-are forgotten when an additional argument is added.</p>
+<p>Tip: Always using parentheses even for single-parameter arrow functions can
+avoid situations where adding parameters, but forgetting to add parentheses, may
+result in parseable code which no longer works as intended.</p>
+
+<p>The right-hand side of the arrow contains the body of the function. By default
+the body is a block statement (zero or more statements surrounded by curly
+braces). The body may also be an implicitly returned single expression if
+either: the program logic requires returning a value, or the <code>void</code> operator
+precedes a single function or method call (using <code>void</code> ensures <code>undefined</code> is
+returned, prevents leaking values, and communicates intent). The single
+expression form is preferred if it improves readability (e.g., for short or
+simple expressions).</p>
+
+<p>Examples:</p>
+
+<pre><code class="language-js prettyprint">/**
+ * Arrow functions can be documented just like normal functions.
+ * @param {number} numParam A number to add.
+ * @param {string} strParam Another number to add that happens to be a string.
+ * @return {number} The sum of the two parameters.
+ */
+const moduleLocalFunc = (numParam, strParam) => numParam + Number(strParam);
+
+// Uses the single expression syntax with `void` because the program logic does
+// not require returning a value.
+getValue((result) => void alert(`Got ${result}`));
+
+class CallbackExample {
+ constructor() {
+ /** @private {number} */
+ this.cachedValue_ = 0;
+
+ // For inline callbacks, you can use inline typing for parameters.
+ // Uses a block statement because the value of the single expression should
+ // not be returned and the expression is not a single function call.
+ getNullableValue((/** ?number */ result) => {
+ this.cachedValue_ = result == null ? 0 : result;
+ });
+ }
+}
+</code></pre>
+
+<p>Disallowed:</p>
+
+<pre><code class="language-js prettyprint badcode">/**
+ * A function with no params and no returned value.
+ * This single expression body usage is illegal because the program logic does
+ * not require returning a value and we're missing the `void` operator.
+ */
+const moduleLocalFunc = () => anotherFunction();
+</code></pre>
<h4 id="features-functions-generators">5.5.4 Generators</h4>
@@ -1381,15 +1886,10 @@
}
</code></pre>
-<h4 id="features-functions-parameters">5.5.5 Parameters</h4>
+<h4 id="features-functions-parameter-return-types">5.5.5 Parameter and return types</h4>
-<p>Function parameters must be typed with JSDoc annotations in the JSDoc preceding
-the function’s definition, except in the case of same-signature <code>@override</code>s,
-where all types are omitted.</p>
-
-<p>Parameter types <em>may</em> be specified inline, immediately before the parameter name
-(as in <code>(/** number */ foo, /** string */ bar) => foo + bar</code>). Inline and
-<code>@param</code> type annotations <em>must not</em> be mixed in the same function definition.</p>
+<p>Function parameters and return types should usually be documented with JSDoc
+annotations. See <a href="#jsdoc-method-and-function-comments">??</a> for more information.</p>
<h5 id="features-functions-default-parameters">5.5.5.1 Default parameters</h5>
@@ -1398,8 +1898,9 @@
operator, be named exactly like required parameters (i.e., not prefixed with
<code>opt_</code>), use the <code>=</code> suffix in their JSDoc type, come after required parameters,
and not use initializers that produce observable side effects. All optional
-parameters must have a default value in the function declaration, even if that
-value is <code>undefined</code>.</p>
+parameters for concrete functions must have default values, even if that value
+is <code>undefined</code>. In contrast to concrete functions, abstract and interface
+methods must omit default parameter values.</p>
<p>Example:</p>
@@ -1409,6 +1910,15 @@
* @param {!Node=} node Another optional parameter.
*/
function maybeDoSomething(required, optional = '', node = undefined) {}
+
+/** @interface */
+class MyInterface {
+ /**
+ * Interface and abstract methods must omit default parameter values.
+ * @param {string=} optional
+ */
+ someMethod(optional) {}
+}
</code></pre>
<p>Use default parameters sparingly. Prefer destructuring (as in
@@ -1443,18 +1953,12 @@
function variadic(array, ...numbers) {}
</code></pre>
-<h4 id="features-functions-returns">5.5.6 Returns</h4>
-
-<p>Function return types must be specified in the JSDoc directly above the function
-definition, except in the case of same-signature <code>@override</code>s where all types
-are omitted.</p>
-
-<h4 id="features-functions-generics">5.5.7 Generics</h4>
+<h4 id="features-functions-generics">5.5.6 Generics</h4>
<p>Declare generic functions and methods when necessary with <code>@template TYPE</code> in
-the JSDoc above the class definition.</p>
+the JSDoc above the function or method definition.</p>
-<h4 id="features-functions-spread-operator">5.5.8 Spread operator</h4>
+<h4 id="features-functions-spread-operator">5.5.7 Spread operator</h4>
<p>Function calls may use the spread operator (<code>...</code>). Prefer the spread operator
to <code>Function.prototype.apply</code> when an array or iterable is unpacked into
@@ -1478,13 +1982,13 @@
<p>Ordinary string literals may not span multiple lines.</p>
-<h4 id="features-strings-template-strings">5.6.2 Template strings</h4>
+<h4 id="features-strings-template-strings">5.6.2 Template literals</h4>
-<p>Use template strings (delimited with <code>`</code>) over complex string
+<p>Use template literals (delimited with <code>`</code>) over complex string
concatenation, particularly if multiple string literals are involved. Template
-strings may span multiple lines.</p>
+literals may span multiple lines.</p>
-<p>If a template string spans multiple lines, it does not need to follow the
+<p>If a template literal spans multiple lines, it does not need to follow the
indentation of the enclosing block, though it may if the added whitespace does
not matter.</p>
@@ -1506,7 +2010,7 @@
ES5 allows this, it can lead to tricky errors if any trailing whitespace comes
after the slash, and is less obvious to readers.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">const longString = 'This is a very long string that far exceeds the 80 \
column limit. It unfortunately contains long stretches of spaces due \
@@ -1547,6 +2051,9 @@
throw string literals or other objects. Always use <code>new</code> when constructing an
<code>Error</code>.</p>
+<p>This treatment extends to <code>Promise</code> rejection values as <code>Promise.reject(obj)</code> is
+equivalent to <code>throw obj;</code> in async functions.</p>
+
<p>Custom exceptions provide a great way to convey additional error information
from functions. They should be defined and used wherever the native <code>Error</code>
type is insufficient.</p>
@@ -1569,13 +2076,13 @@
return handleTextResponse(response);
</code></pre>
-<p>Illegal:</p>
+<p>Disallowed:</p>
-<pre><code class="language-js prettyprint badcode"> try {
+<pre><code class="language-js prettyprint badcode"> try {
shouldFail();
fail('expected an error');
+ } catch (expected) {
}
- catch (expected) {}
</code></pre>
<p>Tip: Unlike in some other languages, patterns like the above simply don’t work
@@ -1612,36 +2119,51 @@
<h5 id="features-switch-default-case">5.8.3.2 The <code>default</code> case is present</h5>
<p>Each switch statement includes a <code>default</code> statement group, even if it contains
-no code.</p>
+no code. The <code>default</code> statement group must be last.</p>
<h3 id="features-this">5.9 this</h3>
-<p>Only use <code>this</code> in class constructors and methods, or in arrow functions defined
-within class constructors and methods. Any other uses of <code>this</code> must have an
-explicit <code>@this</code> declared in the immediately-enclosing function’s JSDoc.</p>
+<p>Only use <code>this</code> in class constructors and methods, in arrow functions defined
+within class constructors and methods, or in functions that have an explicit
+<code>@this</code> declared in the immediately-enclosing function’s JSDoc.</p>
<p>Never use <code>this</code> to refer to the global object, the context of an <code>eval</code>, the
target of an event, or unnecessarily <code>call()</code>ed or <code>apply()</code>ed functions.</p>
-<h3 id="disallowed-features">5.10 Disallowed features</h3>
+<h3 id="features-equality-checks">5.10 Equality Checks</h3>
-<h4 id="disallowed-features-with">5.10.1 with</h4>
+<p>Use identity operators (<code>===</code>/<code>!==</code>) except in the cases documented below.</p>
+
+<h4 id="features-equality-checks-exceptions">5.10.1 Exceptions Where Coercion is Desirable</h4>
+
+<p>Catching both <code>null</code> and <code>undefined</code> values:</p>
+
+<pre><code class="language-js prettyprint">if (someObjectOrPrimitive == null) {
+ // Checking for null catches both null and undefined for objects and
+ // primitives, but does not catch other falsy values like 0 or the empty
+ // string.
+}
+</code></pre>
+
+<h3 id="disallowed-features">5.11 Disallowed features</h3>
+
+<h4 id="disallowed-features-with">5.11.1 with</h4>
<p>Do not use the <code>with</code> keyword. It makes your code harder to understand and has
been banned in strict mode since ES5.</p>
-<h4 id="disallowed-features-dynamic-code-evaluation">5.10.2 Dynamic code evaluation</h4>
+<h4 id="disallowed-features-dynamic-code-evaluation">5.11.2 Dynamic code evaluation</h4>
<p>Do not use <code>eval</code> or the <code>Function(...string)</code> constructor (except for code
loaders). These features are potentially dangerous and simply do not work in
CSP environments.</p>
-<h4 id="disallowed-features-automatic-semicolon-insertion">5.10.3 Automatic semicolon insertion</h4>
+<h4 id="disallowed-features-automatic-semicolon-insertion">5.11.3 Automatic semicolon insertion</h4>
<p>Always terminate statements with semicolons (except function and class
declarations, as noted above).</p>
-<h4 id="disallowed-features-non-standard-features">5.10.4 Non-standard features</h4>
+<h4 id="disallowed-features-non-standard-features">5.11.4 Non-standard features</h4>
<p>Do not use non-standard features. This includes old features that have been
removed (e.g., <code>WeakMap.clear</code>), new features that are not yet standardized
@@ -1653,12 +2175,12 @@
language “extensions” (such as those provided by some external transpilers) are
forbidden.</p>
-<h4 id="disallowed-features-wrapper-objects">5.10.5 Wrapper objects for primitive types</h4>
+<h4 id="disallowed-features-wrapper-objects">5.11.5 Wrapper objects for primitive types</h4>
<p>Never use <code>new</code> on the primitive object wrappers (<code>Boolean</code>, <code>Number</code>, <code>String</code>,
<code>Symbol</code>), nor include them in type annotations.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">const /** Boolean */ x = new Boolean(false);
if (x) alert(typeof x); // alerts 'object' - WAT?
@@ -1673,7 +2195,7 @@
if (!x) alert(typeof x); // alerts 'boolean', as expected
</code></pre>
-<h4 id="disallowed-features-modifying-builtin-objects">5.10.6 Modifying builtin objects</h4>
+<h4 id="disallowed-features-modifying-builtin-objects">5.11.6 Modifying builtin objects</h4>
<p>Never modify builtin types, either by adding methods to their constructors or to
their prototypes. Avoid depending on libraries that do this. Note that the
@@ -1683,6 +2205,27 @@
<p>Do not add symbols to the global object unless absolutely necessary
(e.g. required by a third-party API).</p>
+<h4 id="disallowed-features-omitting-parents-with-new">5.11.7 Omitting <code>()</code> when invoking a constructor</h4>
+
+<p>Never invoke a constructor in a <code>new</code> statement without using parentheses <code>()</code>.</p>
+
+<p>Disallowed:</p>
+
+<pre><code class="language-js prettyprint badcode">new Foo;
+</code></pre>
+
+<p>Use instead:</p>
+
+<pre><code class="language-js prettyprint">new Foo();
+</code></pre>
+
+<p>Omitting parentheses can lead to subtle mistakes. These two lines are not
+equivalent:</p>
+
+<pre><code class="language-js prettyprint">new Foo().Bar();
+new Foo.Bar();
+</code></pre>
+
<h2 id="naming">6 Naming</h2>
<h3 id="naming-rules-common-to-all-identifiers">6.1 Rules common to all identifiers</h3>
@@ -1697,20 +2240,21 @@
unfamiliar to readers outside your project, and do not abbreviate by deleting
letters within a word.</p>
-<pre><code class="language-js prettyprint">priceCountReader // No abbreviation.
-numErrors // "num" is a widespread convention.
-numDnsConnections // Most people know what "DNS" stands for.
+<pre><code class="language-js prettyprint">errorCount // No abbreviation.
+dnsConnectionIndex // Most people know what "DNS" stands for.
+referrerUrl // Ditto for "URL".
+customerId // "Id" is both ubiquitous and unlikely to be misunderstood.
</code></pre>
-<p>Illegal:</p>
+<p>Disallowed:</p>
-<pre><code class="language-js prettyprint badcode">n // Meaningless.
-nErr // Ambiguous abbreviation.
-nCompConns // Ambiguous abbreviation.
-wgcConnections // Only your group knows what this stands for.
-pcReader // Lots of things can be abbreviated "pc".
-cstmrId // Deletes internal letters.
-kSecondsPerDay // Do not use Hungarian notation.
+<pre><code class="language-js prettyprint badcode">n // Meaningless.
+nErr // Ambiguous abbreviation.
+nCompConns // Ambiguous abbreviation.
+wgcConnections // Only your group knows what this stands for.
+pcReader // Lots of things can be abbreviated "pc".
+cstmrId // Deletes internal letters.
+kSecondsPerDay // Do not use Hungarian notation.
</code></pre>
<h3 id="naming-rules-by-identifier-type">6.2 Rules by identifier type</h3>
@@ -1732,8 +2276,8 @@
<h4 id="naming-method-names">6.2.3 Method names</h4>
-<p>Method names are written in <code>lowerCamelCase</code>. Private methods’ names must end
-with a trailing underscore.</p>
+<p>Method names are written in <code>lowerCamelCase</code>. Names for <code>@private</code> methods must
+end with a trailing underscore.</p>
<p>Method names are typically verbs or verb phrases. For example, <code>sendMessage</code> or
<code>stop_</code>. Getter and setter methods for properties are never required, but if
@@ -1741,9 +2285,9 @@
for booleans), or <code>setFoo(value)</code> for setters.</p>
<p>Underscores may also appear in JsUnit test method names to separate logical
-components of the name. One typical pattern is <code>test<MethodUnderTest>_<state></code>,
-for example <code>testPop_emptyStack</code>. There is no One Correct Way to name test
-methods.</p>
+components of the name. One typical pattern is
+<code>test<MethodUnderTest>_<state>_<expectedOutcome></code>, for example
+<code>testPop_emptyStack_throws</code>. There is no One Correct Way to name test methods.</p>
<h4 id="naming-enum-names">6.2.4 Enum names</h4>
@@ -1776,9 +2320,9 @@
// Not constants
let letVariable = 'non-const';
-class MyClass { constructor() { /** @const */ this.nonStatic = 'non-static'; } };
+class MyClass { constructor() { /** @const {string} */ this.nonStatic = 'non-static'; } };
/** @type {string} */ MyClass.staticButMutable = 'not @const, can be reassigned';
-const /** Set<String> */ mutableCollection = new Set();
+const /** Set<string> */ mutableCollection = new Set();
const /** ImmutableSet<SomeMutableType> */ mutableElements = ImmutableSet.of(mutable);
const Foo = goog.require('my.Foo'); // mirrors imported name
const logger = log.getLogger('loggers.are.not.immutable');
@@ -1786,7 +2330,7 @@
<p>Constants’ names are typically nouns or noun phrases.</p>
-<h5 id="naming-local-aliases">6.2.5.1 Local aliases</h5>
+<h5 id="naming-local-aliases">6.2.5.2 Local aliases</h5>
<p>Local aliases should be used whenever they improve readability over
fully-qualified names. Follow the same rules as <code>goog.require</code>s
@@ -1822,15 +2366,21 @@
<h4 id="naming-local-variable-names">6.2.8 Local variable names</h4>
<p>Local variable names are written in <code>lowerCamelCase</code>, except for module-local
-(top-level) constants, as described above. Constants in function scopes are
-still named in <code>lowerCamelCase</code>. Note that lowerCamelCase applies even if the
-variable holds a constructor.</p>
+(top-level) constants, as described above. Constants in function scopes are
+still named in <code>lowerCamelCase</code>. Note that <code>lowerCamelCase</code> is used
+even if the variable holds a constructor.</p>
<h4 id="naming-template-parameter-names">6.2.9 Template parameter names</h4>
<p>Template parameter names should be concise, single-word or single-letter
identifiers, and must be all-caps, such as <code>TYPE</code> or <code>THIS</code>.</p>
+<h4 id="naming-module-local-names">6.2.10 Module-local names</h4>
+
+<p>Module-local names that are not exported are implicitly private. They are not
+marked <code>@private</code> and do not end in an underscore. This applies to classes,
+functions, variables, constants, enums, and other module-local identifiers.</p>
+
<h3 id="naming-camel-case-defined">6.3 Camel case: defined</h3>
<p>Sometimes there is more than one reasonable way to convert an English phrase
@@ -1959,6 +2509,7 @@
<pre><code class="language-js prettyprint">/**
* Computes weight based on three factors:
+ *
* - items sent
* - items received
* - last timestamp
@@ -1971,7 +2522,7 @@
<a href="#appendices-jsdoc-tag-reference">??</a> for the complete list. Most tags must
occupy their own line, with the tag at the beginning of the line.</p>
-<p>Illegal:</p>
+<p>Disallowed:</p>
<pre><code class="language-js prettyprint badcode">/**
* The "param" tag must occupy its own line and may not be combined.
@@ -2029,7 +2580,7 @@
};
</code></pre>
-<p>Do not indent when wrapping a <code>@fileoverview</code> description.</p>
+<p>Do not indent when wrapping a <code>@desc</code> or <code>@fileoverview</code> description.</p>
<h3 id="jsdoc-top-file-level-comments">7.5 Top/file-level comments</h3>
@@ -2088,8 +2639,9 @@
<h3 id="jsdoc-enum-and-typedef-comments">7.7 Enum and typedef comments</h3>
-<p>Enums and typedefs must be documented. Public enums and typedefs must have a
-non-empty description. Individual enum items may be documented with a JSDoc
+<p>All enums and typedefs must be documented with appropriate JSDoc tags
+(<code>@typedef</code> or <code>@enum</code>) on the preceding line. Public enums and typedefs must
+also have a description. Individual enum items may be documented with a JSDoc
comment on the preceding line.</p>
<pre><code class="language-js prettyprint">/**
@@ -2120,16 +2672,25 @@
<h3 id="jsdoc-method-and-function-comments">7.8 Method and function comments</h3>
-<p>Parameter and return types must be documented. The <code>this</code> type should be
-documented when necessary. Method, parameter, and return descriptions (but not
-types) may be omitted if they are obvious from the rest of the method’s JSDoc or
-from its signature. Method descriptions should start with a sentence written in
-the third person declarative voice. If a method overrides a superclass method,
-it must include an <code>@override</code> annotation. Overridden methods must include all
-<code>@param</code> and <code>@return</code> annotations if any types are refined, but should omit
-them if the types are all the same.</p>
+<p>In methods and named functions, parameter and return types must be documented,
+except in the case of same-signature <code>@override</code>s, where all types are omitted.
+The <code>this</code> type should be documented when necessary. Return type may be omitted
+if the function has no non-empty <code>return</code> statements.</p>
-<pre><code class="language-js prettyprint">/** This is a class. */
+<p>Method, parameter, and return descriptions (but not types) may be omitted if
+they are obvious from the rest of the method’s JSDoc or from its signature.</p>
+
+<p>Method descriptions begin with a verb phrase that describes what the method
+does. This phrase is not an imperative sentence, but instead is written in the
+third person, as if there is an implied <q>This method ...</q> before it.</p>
+
+<p>If a method overrides a superclass method, it must include an <code>@override</code>
+annotation. Overridden methods inherit all JSDoc annotations from the super
+class method (including visibility annotations) and they should be omitted in
+the overridden method. However, if any type is refined in type annotations, all
+<code>@param</code> and <code>@return</code> annotations must be specified explicitly.</p>
+
+<pre><code class="language-js prettyprint">/** A class that does something. */
class SomeClass extends SomeBaseClass {
/**
* Operates on an instance of MyClass and returns something.
@@ -2154,38 +2715,63 @@
function makeArray(arg) { ... }
</code></pre>
+<p>If you only need to document the param and return types of a function, you may
+optionally use inline JSDocs in the function's signature. These inline JSDocs
+specify the return and param types without tags.</p>
+
+<pre><code class="language-js prettyprint">function /** string */ foo(/** number */ arg) {...}
+</code></pre>
+
+<p>If you need descriptions or tags, use a single JSDoc comment above the method.
+For example, methods which return values need a <code>@return</code> tag.</p>
+
+<pre><code class="language-js prettyprint">class MyClass {
+ /**
+ * @param {number} arg
+ * @return {string}
+ */
+ bar(arg) {...}
+}
+</code></pre>
+
+<pre><code class="language-js prettyprint badcode">// Illegal inline JSDocs.
+
+class MyClass {
+ /** @return {string} */ foo() {...}
+}
+
+/** Function description. */ bar() {...}
+</code></pre>
-<p>Anonymous functions do not require JSDoc, though parameter types may be specified inline if the automatic type inference is insufficient.</p>
+
+<p>In anonymous functions annotations are generally optional. If the automatic type
+inference is insufficient or explicit annotation improves readability, then
+annotate param and return types like this:</p>
<pre><code class="language-js prettyprint">promise.then(
- (/** !Array<number|string> */ items) => {
+ /** @return {string} */
+ (/** !Array<string> */ items) => {
doSomethingWith(items);
- return /** @type {string} */ (items[0]);
+ return items[0];
});
</code></pre>
+<p>For function type expressions, see <a href="#jsdoc-function-types">??</a>.</p>
+
<h3 id="jsdoc-property-comments">7.9 Property comments</h3>
<p>Property types must be documented. The description may be omitted for private
properties, if name and type provide enough documentation for understanding the
code.</p>
-<p>Publicly exported constants are commented the same way as properties. Explicit
-types may be omitted for <code>@const</code> properties initialized from an expression with
-an obviously known type.</p>
-
-<p>Tip: A <code>@const</code> property’s type can be considered “obviously known” if it is
-assigned directly from a constructor parameter with a declared type, or directly
-from a function call with a declared return type. Non-const properties and
-properties assigned from more complex expressions should have their types
-declared explicitly.</p>
+<p>Publicly exported constants are commented the same way as properties.</p>
<pre><code class="language-js prettyprint">/** My class. */
class MyClass {
/** @param {string=} someString */
constructor(someString = 'default string') {
- /** @private @const */
+ /** @private @const {string} */
this.someString_ = someString;
/** @private @const {!OtherType} */
@@ -2201,7 +2787,7 @@
/**
* The number of times we'll try before giving up.
- * @const
+ * @const {number}
*/
MyClass.RETRY_COUNT = 33;
</code></pre>
@@ -2215,20 +2801,55 @@
<h4 id="jsdoc-nullability">7.10.1 Nullability</h4>
<p>The type system defines modifiers <code>!</code> and <code>?</code> for non-null and nullable,
-respectively. Primitive types (<code>undefined</code>, <code>string</code>, <code>number</code>, <code>boolean</code>,
-<code>symbol</code>, and <code>function(...): ...</code>) and record literals (<code>{foo: string, bar:
-number}</code>) are non-null by default. Do not add an explicit <code>!</code> to these types.
-Object types (<code>Array</code>, <code>Element</code>, <code>MyClass</code>, etc) are nullable by default, but
-cannot be immediately distinguished from a name that is <code>@typedef</code>’d to a
-non-null-by-default type. As such, all types except primitives and record
-literals must be annotated explicitly with either <code>?</code> or <code>!</code> to indicate whether
-they are nullable or not.</p>
+respectively. These modifiers must precede the type.</p>
+
+<p>Nullability modifiers have different requirements for different types, which
+fall into two broad categories:</p>
+
+<ol>
+<li>Type annotations for primitives (<code>string</code>, <code>number</code>, <code>boolean</code>, <code>symbol</code>,
+<code>undefined</code>, <code>null</code>) and literals (<code>{function(...): ...}</code> and <code>{{foo:
+string...}}</code>) are always non-nullable by default. Use the <code>?</code> modifier to
+make it nullable, but omit the redundant <code>!</code>.</li>
+<li>Reference types (generally, anything in <code>UpperCamelCase</code>, including
+<code>some.namespace.ReferenceType</code>) refer to a class, enum, record, or typedef
+defined elsewhere. Since these types may or may not be nullable, it is
+impossible to tell from the name alone whether it is nullable or not. Always
+use explicit <code>?</code> and <code>!</code> modifiers for these types to prevent ambiguity at
+use sites.</li>
+</ol>
+
+<p>Bad:</p>
+
+<pre><code class="language-js prettyprint badcode">const /** MyObject */ myObject = null; // Non-primitive types must be annotated.
+const /** !number */ someNum = 5; // Primitives are non-nullable by default.
+const /** number? */ someNullableNum = null; // ? should precede the type.
+const /** !{foo: string, bar: number} */ record = ...; // Already non-nullable.
+const /** MyTypeDef */ def = ...; // Not sure if MyTypeDef is nullable.
+
+// Not sure if object (nullable), enum (non-nullable, unless otherwise
+// specified), or typedef (depends on definition).
+const /** SomeCamelCaseName */ n = ...;
+</code></pre>
+
+<p>Good:</p>
+
+<pre><code class="language-js prettyprint">const /** ?MyObject */ myObject = null;
+const /** number */ someNum = 5;
+const /** ?number */ someNullableNum = null;
+const /** {foo: string, bar: number} */ record = ...;
+const /** !MyTypeDef */ def = ...;
+const /** ?SomeCamelCaseName */ n = ...;
+</code></pre>
<h4 id="jsdoc-type-casts">7.10.2 Type Casts</h4>
-<p>In cases where type checking doesn't accurately infer the type of an expression,
-it is possible to tighten the type by adding a type annotation comment and
-enclosing the expression in parentheses. Note that the parentheses are required.</p>
+<p>In cases where the compiler doesn't accurately infer the type of an expression,
+and the assertion functions in
+<a href="https://google.github.io/closure-library/api/goog.asserts.html">goog.asserts</a>
+cannot remedy it , it is possible to
+tighten the type by adding a type annotation comment and enclosing the
+expression in parentheses. Note that the parentheses are required.</p>
<pre><code class="language-js prettyprint">/** @type {number} */ (x)
</code></pre>
@@ -2261,6 +2882,96 @@
<li><code>Object</code> is used for type hierarchy and not as map-like structure.</li>
</ul>
+<h4 id="jsdoc-function-types">7.10.4 Function type expressions</h4>
+
+<p><strong>Terminology Note</strong>: <em>function type expression</em> refers to a type annotation for
+function types with the keyword <code>function</code> in the annotation (see examples
+below).</p>
+
+<p>Where the function definition is given, do not use a function type expression.
+Specify parameter and return types with <code>@param</code> and <code>@return</code>, or with inline
+annotations (see <a href="#jsdoc-method-and-function-comments">??</a>). This includes
+anonymous functions and functions defined and assigned to a const (where the
+function jsdoc appears above the whole assignment expression).</p>
+
+<p>Function type expressions are needed, for example, inside <code>@typedef</code>, <code>@param</code>
+or <code>@return</code>. Use it also for variables or properties of function type, if they
+are not immediately initialized with the function definition.</p>
+
+<pre><code class="language-js prettyprint"> /** @private {function(string): string} */
+ this.idGenerator_ = googFunctions.identity;
+</code></pre>
+
+<p>When using a function type expression, always specify the return type
+explicitly. Otherwise the default return type is <q>unknown</q> (<code>?</code>), which leads to
+strange and unexpected behavior, and is rarely what is actually desired.</p>
+
+<p>Bad - type error, but no warning given:</p>
+
+<pre><code class="language-js prettyprint badcode">/** @param {function()} generateNumber */
+function foo(generateNumber) {
+ const /** number */ x = generateNumber(); // No compile-time type error here.
+}
+
+foo(() => 'clearly not a number');
+</code></pre>
+
+<p>Good:</p>
+
+<pre><code class="language-js prettyprint">/**
+ * @param {function(): *} inputFunction1 Can return any type.
+ * @param {function(): undefined} inputFunction2 Definitely doesn't return
+ * anything.
+ * NOTE: the return type of `foo` itself is safely implied to be {undefined}.
+ */
+function foo(inputFunction1, inputFunction2) {...}
+</code></pre>
+
+<h4 id="jsdoc-whitespace">7.10.5 Whitespace</h4>
+
+<p>Within a type annotation, a single space or line break is required after each
+comma or colon. Additional line breaks may be inserted to improve readability or
+avoid exceeding the column limit. These breaks should be chosen and indented
+following the applicable guidelines (e.g. <a href="#formatting-line-wrapping">??</a> and
+<a href="#formatting-block-indentation">??</a>). No other whitespace is allowed in type
+annotations.</p>
+
+<p>Good:</p>
+
+<pre><code class="language-js prettyprint">/** @type {function(string): number} */
+
+/** @type {{foo: number, bar: number}} */
+
+/** @type {number|string} */
+
+/** @type {!Object<string, string>} */
+
+/** @type {function(this: Object<string, string>, number): string} */
+
+/**
+ * @type {function(
+ * !SuperDuperReallyReallyLongTypedefThatForcesTheLineBreak,
+ * !OtherVeryLongTypedef): string}
+ */
+
+/**
+ * @type {!SuperDuperReallyReallyLongTypedefThatForcesTheLineBreak|
+ * !OtherVeryLongTypedef}
+ */
+</code></pre>
+
+<p>Bad:</p>
+
+<pre><code class="language-js prettyprint badcode">// Only put a space after the colon
+/** @type {function(string) : number} */
+
+// Put spaces after colons and commas
+/** @type {{foo:number,bar:number}} */
+
+// No space in union types
+/** @type {number | string} */
+</code></pre>
+
<h3 id="jsdoc-visibility-annotations">7.11 Visibility annotations</h3>
<p>Visibility annotations (<code>@private</code>, <code>@package</code>, <code>@protected</code>) may be specified
@@ -2398,151 +3109,222 @@
<p>In addition to the JSDoc described in <a href="https://github.com/google/closure-compiler/wiki/Annotating-JavaScript-for-the-Closure-Compiler">Annotating JavaScript for the Closure
Compiler</a> the following tags are common and well supported by various
-documentation generations tools (such as <a href="https://github.com/jleyba/js-dossier">JsDossier</a>) for purely documentation
-purposes.
-<table>
- <thead>
- <tr>
- <th>Tag
- </th><th>Template & Examples
- </th><th>Description
- </th></tr></thead><tbody>
- <tr>
- <td><code>@author</code> or <code>@owner</code>
- </td><td><code>@author username@google.com (First Last)</code>
- <p><em>For example:</em>
- </p><pre class="prettyprint lang-js">
-/**
+documentation generation tools (such as <a href="https://github.com/jleyba/js-dossier">JsDossier</a>) for purely documentation
+purposes.</p>
+
+<p>You may also see other types of JSDoc annotations in third-party code. These
+annotations appear in the <a href="http://code.google.com/p/jsdoc-toolkit/wiki/TagReference">JSDoc Toolkit Tag Reference</a> but are not considered
+part of valid Google style.</p>
+
+<section class="zippy">
+
+<h5>9.1.2.1 <code>@author</code> or <code>@owner</code> - <em>Not recommended.</em></h5>
+
+<p><strong>Not recommended.</strong></p>
+
+<p>Syntax: <code>@author username@google.com (First Last)</code></p>
+
+<pre><code class="language-js prettyprint">/**
* @fileoverview Utilities for handling textareas.
- * @author <a href="mailto:kuth@google.com">kuth@google.com</a> (Uthur Pendragon)
+ * @author kuth@google.com (Uthur Pendragon)
*/
- </pre>
- </td><td>Document the author of a file or the owner of a test, generally only
- used in the <code>@fileoverview</code> comment. The <code>@owner</code> tag is used by the
- unit test dashboard to determine who owns the test results.
- <p>Not recommended.
- </p></td></tr><tr>
- <td><code>@bug</code>
- </td><td><code>@bug bugnumber</code>
- <p><em>For example:</em>
- </p><pre class="prettyprint lang-js">
-/** @bug 1234567 */
+</code></pre>
+
+<p>Documents the author of a file or the owner of a test, generally only used in
+the <code>@fileoverview</code> comment. The <code>@owner</code> tag is used by the unit test dashboard
+to determine who owns the test results.</p>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.2.2 <code>@bug</code></h5>
+
+<p>Syntax: <code>@bug bugnumber</code></p>
+
+<pre><code class="language-js prettyprint">/** @bug 1234567 */
function testSomething() {
// …
}
-<p>/**
+/**
* @bug 1234568
* @bug 1234569
*/
function testTwoBugs() {
// …
}
-</p></pre>
- </td><td>Indicates what bugs the given test function regression tests.
- <p>Multiple bugs should each have their own <code>@bug</code> line, to make
- searching for regression tests as easy as possible.
- </p></td></tr><tr>
- <td><code>@code</code>
- </td><td><code>{@code ...}</code>
- <p><em>For example:</em>
- </p><pre class="prettyprint lang-js">
-/**
- * Moves to the next position in the selection.
- * Throws {@code goog.iter.StopIteration} when it
- * passes the end of the range.
- * @return {!Node} The node at the next position.
+</code></pre>
+
+<p>Indicates what bugs the given test function regression tests.</p>
+
+<p>Multiple bugs should each have their own <code>@bug</code> line, to make searching for
+regression tests as easy as possible.</p>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.2.3 <code>@code</code> - <em>Deprecated. Do not use.</em></h5>
+
+<p><strong>Deprecated. Do not use. Use Markdown backticks instead.</strong></p>
+
+<p>Syntax: <code>{@code ...}</code></p>
+
+<p>Historically, <code>`BatchItem`</code> was written as
+<code class="badcode">{@code BatchItem}</code>.</p>
+
+<pre><code class="language-js prettyprint">/** Processes pending `BatchItem` instances. */
+function processBatchItems() {}
+</code></pre>
+
+<p>Indicates that a term in a JSDoc description is code so it may be correctly
+formatted in generated documentation.</p>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.2.4 <code>@desc</code></h5>
+
+<p>Syntax: <code>@desc Message description</code></p>
+
+<pre><code class="language-js prettyprint">/** @desc Notifying a user that their account has been created. */
+exports.MSG_ACCOUNT_CREATED = goog.getMsg(
+ 'Your account has been successfully created.');
+</code></pre>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.2.5 <code>@link</code></h5>
+
+<p>Syntax: <code>{@link ...}</code></p>
+
+<p>This tag is used to generate cross-reference links within generated
+documentation.</p>
+
+<pre><code class="language-js prettyprint">/** Processes pending {@link BatchItem} instances. */
+function processBatchItems() {}
+</code></pre>
+
+<p><strong>Historical note:</strong> @link tags have also been used to create external links in
+generated documentation. For external links, always use Markdown's link syntax
+instead:</p>
+
+<pre><code class="language-js prettyprint">/**
+ * This class implements a useful subset of the
+ * [native Event interface](https://dom.spec.whatwg.org/#event).
*/
-goog.dom.RangeIterator.prototype.next = function() {
- // …
-};
-</pre>
- </td><td>Indicates that a term in a JSDoc description is code so it may be
- correctly formatted in generated documentation.
- </td></tr><tr>
- <td><code>@see</code>
- </td><td><code>@see Link</code>
- <p><em>For example:</em>
- </p><pre class="prettyprint lang-js">
-/**
+class ApplicationEvent {}
+</code></pre>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.2.6 <code>@see</code></h5>
+
+<p>Syntax: <code>@see Link</code></p>
+
+<pre><code class="language-js prettyprint">/**
* Adds a single item, recklessly.
* @see #addSafely
* @see goog.Collect
* @see goog.RecklessAdder#add
*/
- </pre>
- </td><td>Reference a lookup to another class function or method.
- </td></tr><tr>
- <td><code>@supported</code>
- </td><td><code>@supported Description</code>
- <p><em>For example:</em>
- </p><pre class="prettyprint lang-js">
-/**
+</code></pre>
+
+<p>Reference a lookup to another class function or method.</p>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.2.7 <code>@supported</code></h5>
+
+<p>Syntax: <code>@supported Description</code></p>
+
+<pre><code class="language-js prettyprint">/**
* @fileoverview Event Manager
- * Provides an abstracted interface to the
- * browsers' event systems.
+ * Provides an abstracted interface to the browsers' event systems.
* @supported IE10+, Chrome, Safari
*/
-</pre>
- </td><td>Used in a fileoverview to indicate what browsers are supported by
- the file.
- </td></tr><tr>
- <td><code>@desc</code>
- </td><td><code>@desc Message description</code>
- <p><em>For example:</em>
- </p><pre class="prettyprint lang-js">
-/** @desc Notifying a user that their account has been created. */
-exports.MSG_ACCOUNT_CREATED = goog.getMsg(
- 'Your account has been successfully created.');
- </pre>
- </td></tr></tbody></table></p>
+</code></pre>
-<p>You may also see other types of JSDoc annotations in third-party code. These
-annotations appear in the <a href="http://code.google.com/p/jsdoc-toolkit/wiki/TagReference">JSDoc Toolkit Tag Reference</a> but are not considered
-part of valid Google style.</p>
+<p>Used in a fileoverview to indicate what browsers are supported by the file.</p>
+
+</section>
<h4 id="appendices-framework-specific-annotations">9.1.3 Framework specific annotations</h4>
-<p>The following annotations are specific to a particular framework.
-<table>
- <thead>
- <tr>
- <th>Framework
- </th><th>Tag
- </th><th>Documentation
- </th></tr></thead><tbody>
- <tr>
- <td>Angular 1
- </td><td><code>@ngInject</code>
- </td></tr><tr>
- <td>Polymer
- </td><td><code>@polymerBehavior</code>
- </td><td>
-
- <a href="https://github.com/google/closure-compiler/wiki/Polymer-Pass">https://github.com/google/closure-compiler/wiki/Polymer-Pass</a>
-
- </td></tr></tbody></table></p>
+<p>The following annotations are specific to a particular framework.</p>
+
+<section class="zippy">
+
+<h5>9.1.3.1 <code>@ngInject</code> for Angular 1</h5>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.3.2 <code>@polymerBehavior</code> for Polymer</h5>
+
+
+
+<p><a href="https://github.com/google/closure-compiler/wiki/Polymer-Pass">https://github.com/google/closure-compiler/wiki/Polymer-Pass</a>
+</p>
+
+</section>
+
+<section class="zippy">
+
+</section>
<h4 id="appendices-notes-about-standard-closure-compiler-annotations">9.1.4 Notes about standard Closure Compiler annotations</h4>
-<p>The following tags used to be standard but are now deprecated.
-<table>
- <thead>
- <tr>
- <th>Tag
- </th><th>Template & Examples
- </th><th>Description
- </th></tr></thead><tbody>
- <tr>
- <td><code>@expose</code>
- </td><td><code>@expose</code>
- </td><td><strong>Deprecated. Do not use. Use <code>@export</code> and/or <code>@nocollapse</code>
- instead.</strong>
- </td></tr><tr>
- <td><code>@inheritDoc</code>
- </td><td><code>@inheritDoc</code>
- </td><td><strong>Deprecated. Do not use. Use <code>@override</code> instead.</strong>
-</td></tr></tbody></table></p>
+<p>The following tags used to be standard but are now deprecated.</p>
+
+<section class="zippy">
+
+<h5>9.1.4.1 <code>@expose</code> - <em>Deprecated. Do not use.</em></h5>
+
+<p><strong>Deprecated. Do not use. Use <code>@export</code> and/or <code>@nocollapse</code> instead.</strong></p>
+
+</section>
+
+<section class="zippy">
+
+<h5>9.1.4.2 <code>@inheritDoc</code> - <em>Deprecated. Do not use.</em></h5>
+
+<p><strong>Deprecated. Do not use. Use <code>@override</code> instead.</strong></p>
+
+</section>
+
+<section class="zippy">
+
+</section>
+
+<section class="zippy">
+
+</section>
+
+<section class="zippy">
+
+</section>
+
+<section class="zippy">
+
+</section>
+
+<section class="zippy">
+
+</section>
+
+<section class="zippy">
+
+</section>
<h3 id="appendices-commonly-misunderstood-style-rules">9.2 Commonly misunderstood style rules</h3>
@@ -2553,14 +3335,13 @@
<ul>
<li>Neither a copyright statement nor <code>@author</code> credit is required in a source
file. (Neither is explicitly recommended, either.)</li>
-<li>Aside from the constructor coming first
-(<a href="#features-classes-constructors">??</a>), there is no <q>hard and fast</q> rule
-governing how to order the members of a class (<a href="#features-classes">??</a>).</li>
+<li>There is no <q>hard and fast</q> rule governing how to order the members of a
+class (<a href="#features-classes">??</a>).</li>
<li>Empty blocks can usually be represented concisely as <code>{}</code>, as detailed in
(<a href="#formatting-empty-blocks">??</a>).</li>
<li>The prime directive of line-wrapping is: prefer to break at a higher
syntactic level (<a href="#formatting-where-to-break">??</a>).</li>
-<li>Non-ASCII characters are allowed in string literals, comments and Javadoc,
+<li>Non-ASCII characters are allowed in string literals, comments and JSDoc,
and in fact are recommended when they make the code easier to read than the
equivalent Unicode escape would (<a href="#non-ascii-characters">??</a>).</li>
</ul>
@@ -2579,7 +3360,9 @@
<p>This program reformats
JavaScript source code into Google Style, and also follows a number of
-non-required but frequently readability-enhancing formatting practices.</p>
+non-required but frequently readability-enhancing formatting practices.
+The output produced by <code>clang-format</code> is compliant with the style guide.
+</p>
<p><code>clang-format</code> is not required. Authors are allowed to change its output, and
reviewers are allowed to ask for such changes; disputes are worked out in the
@@ -2689,12 +3472,13 @@
<h4 id="appendices-legacy-exceptions-goog-provide">9.4.4 Dependency management with <code>goog.provide</code>/<code>goog.require</code></h4>
-<p><strong><code>goog.provide</code> is deprecated. All new files should use <code>goog.module</code>, even in
-projects with existing <code>goog.provide</code> usage. The following rules are for
-pre-existing goog.provide files, only.</strong></p>
-
<h5 id="appendices-legacy-exceptions-goog-provide-summary">9.4.4.1 Summary</h5>
+<p><strong>WARNING: <code>goog.provide</code> dependency management is deprecated.</strong> All new files,
+even in projects using <code>goog.provide</code> for older files, should use
+<a href="#source-file-structure"><code>goog.module</code></a>. The following rules are for
+pre-existing <code>goog.provide</code> files only.</p>
+
<ul>
<li>Place all <code>goog.provide</code>s first, <code>goog.require</code>s second. Separate provides
from requires with an empty line.</li>
@@ -2704,11 +3488,6 @@
<li>Only provide top-level symbols.</li>
</ul>
-<p>As of Oct 2016, <strong><code>goog.provide</code>/<code>goog.require</code> dependency management is
-deprecated</strong>. All new files, even in projects using <code>goog.provide</code> for older
-files, should use
-<a href="#source-file-structure"><code>goog.module</code></a>.</p>
-
<p><code>goog.provide</code> statements should be grouped together and placed first. All
<code>goog.require</code> statements should follow. The two lists should be separated with
an empty line.</p>
@@ -2758,8 +3537,8 @@
<h5 id="appendices-legacy-exceptions-goog-scope">9.4.4.2 Aliasing with <code>goog.scope</code></h5>
-<p><strong><code>goog.scope</code> is deprecated. New files should not use <code>goog.scope</code> even in
-projects with existing goog.scope usage.</strong></p>
+<p><strong>WARNING: <code>goog.scope</code> is deprecated.</strong> New files should not use <code>goog.scope</code>
+even in projects with existing <code>goog.scope</code> usage.</p>
<p><code>goog.scope</code> may be used to shorten references to namespaced symbols in
code using <code>goog.provide</code>/<code>goog.require</code> dependency management.</p>
@@ -2811,6 +3590,22 @@
}); // goog.scope
</code></pre>
+<h5 id="appendices-legacy-exceptions-forward-declare">9.4.4.3 <code>goog.forwardDeclare</code></h5>
+
+<p>Prefer to use <code>goog.requireType</code> instead of <code>goog.forwardDeclare</code> to break
+circular dependencies between files in the same library. Unlike <code>goog.require</code>,
+a <code>goog.requireType</code> statement is allowed to import a namespace before it is
+defined.</p>
+
+<p><code>goog.forwardDeclare</code> may still be used in legacy code to break circular
+references spanning across library boundaries, but newer code should be
+structured to avoid it.</p>
+
+<p><code>goog.forwardDeclare</code> statements must follow the same style rules as
+<code>goog.require</code> and <code>goog.requireType</code>. The entire block of
+<code>goog.forwardDeclare</code>, <code>goog.require</code> and <code>goog.requireType</code> statements is
+sorted alphabetically.</p>
+
</div>
</body>
</html>
diff --git a/objcguide.md b/objcguide.md
index 7d965ce..30891ce 100644
--- a/objcguide.md
+++ b/objcguide.md
@@ -102,11 +102,11 @@
+ (instancetype)fooWithBar:(Bar *)bar;
/**
- * Designated initializer.
+ * Initializes and returns a Foo object using the provided Bar instance.
*
* @param bar A string that represents a thing that does a thing.
*/
-- (instancetype)initWithBar:(Bar *)bar;
+- (instancetype)initWithBar:(Bar *)bar NS_DESIGNATED_INITIALIZER;
/**
* Does some work with @c blah.
@@ -163,320 +163,16 @@
@end
```
-## Spacing and Formatting
-
-### Spaces vs. Tabs
-
-Use only spaces, and indent 2 spaces at a time. We use spaces for indentation.
-Do not use tabs in your code.
-
-You should set your editor to emit spaces when you hit the tab key, and to trim
-trailing spaces on lines.
-
-### Line Length
-
-The maximum line length for Objective-C files is 100 columns.
-
-You can make violations easier to spot by enabling *Preferences > Text Editing >
-Page guide at column: 100* in Xcode.
-
-### Method Declarations and Definitions
-
-One space should be used between the `-` or `+` and the return type, and no
-spacing in the parameter list except between parameters.
-
-Methods should look like this:
-
-```objectivec
-// GOOD:
-
-- (void)doSomethingWithString:(NSString *)theString {
- ...
-}
-```
-
-The spacing before the asterisk is optional. When adding new code, be consistent
-with the surrounding file's style.
-
-If you have too many parameters to fit on one line, giving each its own line is
-preferred. If multiple lines are used, align each using the colon before the
-parameter.
-
-```objectivec
-// GOOD:
-
-- (void)doSomethingWithFoo:(GTMFoo *)theFoo
- rect:(NSRect)theRect
- interval:(float)theInterval {
- ...
-}
-```
-
-When the second or later parameter name is longer than the first, indent the
-second and later lines by at least four spaces, maintaining colon alignment:
-
-```objectivec
-// GOOD:
-
-- (void)short:(GTMFoo *)theFoo
- longKeyword:(NSRect)theRect
- evenLongerKeyword:(float)theInterval
- error:(NSError **)theError {
- ...
-}
-```
-
-### Conditionals
-
-Include a space after `if`, `while`, `for`, and `switch`, and around comparison
-operators.
-
-```objectivec
-// GOOD:
-
-for (int i = 0; i < 5; ++i) {
-}
-
-while (test) {};
-```
-
-Braces may be omitted when a loop body or conditional statement fits on a single
-line.
-
-```objectivec
-// GOOD:
-
-if (hasSillyName) LaughOutLoud();
-
-for (int i = 0; i < 10; i++) {
- BlowTheHorn();
-}
-```
-
-```objectivec
-// AVOID:
-
-if (hasSillyName)
- LaughOutLoud(); // AVOID.
-
-for (int i = 0; i < 10; i++)
- BlowTheHorn(); // AVOID.
-```
-
-If an `if` clause has an `else` clause, both clauses should use braces.
-
-```objectivec
-// GOOD:
-
-if (hasBaz) {
- foo();
-} else {
- bar();
-}
-```
-
-```objectivec
-// AVOID:
-
-if (hasBaz) foo();
-else bar(); // AVOID.
-
-if (hasBaz) {
- foo();
-} else bar(); // AVOID.
-```
-
-Intentional fall-through to the next case should be documented with a comment
-unless the case has no intervening code before the next case.
-
-```objectivec
-// GOOD:
-
-switch (i) {
- case 1:
- ...
- break;
- case 2:
- j++;
- // Falls through.
- case 3: {
- int k;
- ...
- break;
- }
- case 4:
- case 5:
- case 6: break;
-}
-```
-
-### Expressions
-
-Use a space around binary operators and assignments. Omit a space for a unary
-operator. Do not add spaces inside parentheses.
-
-```objectivec
-// GOOD:
-
-x = 0;
-v = w * x + y / z;
-v = -y * (x + z);
-```
-
-Factors in an expression may omit spaces.
-
-```objectivec
-// GOOD:
-
-v = w*x + y/z;
-```
-
-### Method Invocations
-
-Method invocations should be formatted much like method declarations.
-
-When there's a choice of formatting styles, follow the convention already used
-in a given source file. Invocations should have all arguments on one line:
-
-```objectivec
-// GOOD:
-
-[myObject doFooWith:arg1 name:arg2 error:arg3];
-```
-
-or have one argument per line, with colons aligned:
-
-```objectivec
-// GOOD:
-
-[myObject doFooWith:arg1
- name:arg2
- error:arg3];
-```
-
-Don't use any of these styles:
-
-```objectivec
-// AVOID:
-
-[myObject doFooWith:arg1 name:arg2 // some lines with >1 arg
- error:arg3];
-
-[myObject doFooWith:arg1
- name:arg2 error:arg3];
-
-[myObject doFooWith:arg1
- name:arg2 // aligning keywords instead of colons
- error:arg3];
-```
-
-As with declarations and definitions, when the first keyword is shorter than the
-others, indent the later lines by at least four spaces, maintaining colon
-alignment:
-
-```objectivec
-// GOOD:
-
-[myObj short:arg1
- longKeyword:arg2
- evenLongerKeyword:arg3
- error:arg4];
-```
-
-Invocations containing multiple inlined blocks may have their parameter names
-left-aligned at a four space indent.
-
-### Function Calls
-
-Function calls should include as many parameters as fit on each line, except
-where shorter lines are needed for clarity or documentation of the parameters.
-
-Continuation lines for function parameters may be indented to align with the
-opening parenthesis, or may have a four-space indent.
-
-```objectivec
-// GOOD:
-
-CFArrayRef array = CFArrayCreate(kCFAllocatorDefault, objects, numberOfObjects,
- &kCFTypeArrayCallBacks);
-
-NSString *string = NSLocalizedStringWithDefaultValue(@"FEET", @"DistanceTable",
- resourceBundle, @"%@ feet", @"Distance for multiple feet");
-
-UpdateTally(scores[x] * y + bases[x], // Score heuristic.
- x, y, z);
-
-TransformImage(image,
- x1, x2, x3,
- y1, y2, y3,
- z1, z2, z3);
-```
-
-Use local variables with descriptive names to shorten function calls and reduce
-nesting of calls.
-
-```objectivec
-// GOOD:
-
-double scoreHeuristic = scores[x] * y + bases[x];
-UpdateTally(scoreHeuristic, x, y, z);
-```
-
-### Exceptions
-
-Format exceptions with `@catch` and `@finally` labels on the same line as the
-preceding `}`. Add a space between the `@` label and the opening brace (`{`), as
-well as between the `@catch` and the caught object declaration. If you must use
-Objective-C exceptions, format them as follows. However, see Avoid Throwing
-Exceptions for reasons why you should not be using exceptions.
-
-```objectivec
-// GOOD:
-
-@try {
- foo();
-} @catch (NSException *ex) {
- bar(ex);
-} @finally {
- baz();
-}
-```
-
-### Function Length
-
-Prefer small and focused functions.
-
-Long functions and methods are occasionally appropriate, so no hard limit is
-placed on function length. If a function exceeds about 40 lines, think about
-whether it can be broken up without harming the structure of the program.
-
-Even if your long function works perfectly now, someone modifying it in a few
-months may add new behavior. This could result in bugs that are hard to find.
-Keeping your functions short and simple makes it easier for other people to read
-and modify your code.
-
-When updating legacy code, consider also breaking long functions into smaller
-and more manageable pieces.
-
-### Vertical Whitespace
-
-Use vertical whitespace sparingly.
-
-To allow more code to be easily viewed on a screen, avoid putting blank lines
-just inside the braces of functions.
-
-Limit blank lines to one or two between functions and between logical groups of
-code.
-
## Naming
Names should be as descriptive as possible, within reason. Follow standard
[Objective-C naming
rules](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/CodingGuidelines/CodingGuidelines.html).
-Avoid non-standard abbreviations. Don't worry about saving horizontal space as
-it is far more important to make your code immediately understandable by a new
-reader. For example:
+Avoid non-standard abbreviations (including non-standard acronyms and
+initialisms). Don't worry about saving horizontal space as it is far more
+important to make your code immediately understandable by a new reader. For
+example:
```objectivec
// GOOD:
@@ -529,32 +225,60 @@
Files containing code that may be shared across projects or used in a large
project should have a clearly unique name, typically including the project or
-class prefix.
+class [prefix](#prefixes).
File names for categories should include the name of the class being extended,
like GTMNSString+Utils.h or NSTextView+GTMAutocomplete.h
+### Prefixes
+
+Prefixes are commonly required in Objective-C to avoid naming collisions in a
+global namespace. Classes, protocols, global functions, and global constants
+should generally be named with a prefix that begins with a capital letter
+followed by one or more capital letters or numbers.
+
+WARNING: Apple reserves two-letter prefixes—see
+[Conventions in Programming with Objective-C](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html)—so
+prefixes with a minimum of three characters are considered best practice.
+
+```objectivec
+// GOOD:
+
+/** An example error domain. */
+extern NSString *GTMExampleErrorDomain;
+
+/** Gets the default time zone. */
+extern NSTimeZone *GTMGetDefaultTimeZone(void);
+
+/** An example delegate. */
+@protocol GTMExampleDelegate <NSObject>
+@end
+
+/** An example class. */
+@interface GTMExample : NSObject
+@end
+
+```
+
### Class Names
Class names (along with category and protocol names) should start as uppercase
and use mixed case to delimit words.
-When designing code to be shared across multiple applications, prefixes are
-acceptable and recommended (e.g. GTMSendMessage). Prefixes are also recommended
-for classes of large applications that depend on external libraries.
+Classes and protocols in code shared across multiple applications must have an
+appropriate [prefix](#prefixes) (e.g. GTMSendMessage). Prefixes are recommended,
+but not required, for other classes and protocols.
-### Category Names
+### Category Naming
-Category names should start with a 3 character prefix identifying the category
-as part of a project or open for general use.
+Category names should start with an appropriate [prefix](#prefixes) identifying
+the category as part of a project or open for general use.
-The category name should incorporate the name of the class it's extending. For
-example, if we want to create a category on `NSString` for parsing, we would put
-the category in a file named `NSString+GTMParsing.h`, and the category itself
-would be named `GTMNSStringParsingAdditions`. The file name and the category may
-not match, as this file could have many separate categories related to parsing.
-Methods in that category should share the prefix
-(`gtm_myCategoryMethodOnAString:`) in order to prevent collisions in
+Category source file names should begin with the class being extended followed
+by a plus sign and the name of the category, e.g., `NSString+GTMParsing.h`.
+Methods in a category should be prefixed with a lowercase version of the prefix
+used for the category name followed by an underscore (e.g.,
+`gtm_myCategoryMethodOnAString:`) in order to prevent collisions in
Objective-C's global namespace.
There should be a single space between the class name and the opening
@@ -563,9 +287,29 @@
```objectivec
// GOOD:
-/** A category that adds parsing functionality to NSString. */
-@interface NSString (GTMNSStringParsingAdditions)
-- (NSString *)gtm_parsedString;
+// UIViewController+GTMCrashReporting.h
+
+/** A category that adds metadata to include in crash reports to UIViewController. */
+@interface UIViewController (GTMCrashReporting)
+
+/** A unique identifier to represent the view controller in crash reports. */
+@property(nonatomic, setter=gtm_setUniqueIdentifier:) int gtm_uniqueIdentifier;
+
+/** Returns an encoded representation of the view controller's current state. */
+- (nullable NSData *)gtm_encodedState;
+
+@end
+```
+
+If a class is not shared with other projects, categories extending it may omit
+name prefixes and method name prefixes.
+
+```objectivec
+// GOOD:
+
+/** This category extends a class that is not shared with other projects. */
+@interface XYZDataObject (Storage)
+- (NSString *)storageIdentifier;
@end
```
@@ -672,26 +416,24 @@
### Function Names
-Regular functions have mixed case.
-
-Ordinarily, functions should start with a capital letter and have a capital
-letter for each new word (a.k.a. "[Camel
-Case](https://en.wikipedia.org/wiki/Camel_case)" or "Pascal case").
+Function names should start with a capital letter and have a capital letter for
+each new word (a.k.a. "[camel case](https://en.wikipedia.org/wiki/Camel_case)"
+or "Pascal case").
```objectivec
// GOOD:
static void AddTableEntry(NSString *tableEntry);
-static BOOL DeleteFile(char *filename);
+static BOOL DeleteFile(const char *filename);
```
Because Objective-C does not provide namespacing, non-static functions should
-have a prefix that minimizes the chance of a name collision.
+have a [prefix](#prefixes) that minimizes the chance of a name collision.
```objectivec
// GOOD:
-extern NSTimeZone *GTMGetDefaultTimeZone();
+extern NSTimeZone *GTMGetDefaultTimeZone(void);
extern NSString *GTMGetURLScheme(NSURL *URL);
```
@@ -735,7 +477,7 @@
Constant symbols (const global and static variables and constants created
with #define) should use mixed case to delimit words.
-Global and file scope constants should have an appropriate prefix.
+Global and file scope constants should have an appropriate [prefix](#prefixes).
```objectivec
// GOOD:
@@ -764,7 +506,8 @@
};
```
-Constants may use a lowercase k prefix when appropriate:
+A lowercase k can be used as a standalone prefix for constants of static storage
+duration declared within implementation files:
```objectivec
// GOOD:
@@ -773,8 +516,19 @@
static NSString *const kUserKey = @"kUserKey";
```
+NOTE: Previous convention was for public constant names to begin with a
+lowercase k followed by a project-specific [prefix](#prefixes). This practice is
+no longer recommended.
+
## Types and Declarations
+### Method Declarations
+
+As shown in the [example](#Example), the recommended order
+for declarations in an `@interface` declaration are: properties, class methods,
+initializers, and then finally instance methods. The class methods section
+should begin with any convenience constructors.
+
### Local Variables
Declare variables in the narrowest practical scopes, and close to their use.
@@ -804,9 +558,13 @@
}
```
-Under Automatic Reference Counting, pointers to Objective-C objects are by
-default initialized to `nil`, so explicit initialization to `nil` is not
-required.
+Under Automatic Reference Counting, strong and weak pointers to Objective-C
+objects are automatically initialized to `nil`, so explicit initialization to
+`nil` is not required for those common cases. However, automatic initialization
+does *not* occur for many Objective-C pointer types, including object pointers
+declared with the `__unsafe_unretained` ownership qualifier and CoreFoundation
+object pointer types. When in doubt, prefer to initialize all Objective-C
+local variables.
### Unsigned Integers
@@ -1145,8 +903,7 @@
specified.
Compilers support various extensions that are not part of standard C. Examples
-include compound statement expressions (e.g. `foo = ({ int x; Bar(&x); x }))`
-and variable-length arrays.
+include compound statement expressions (e.g. `foo = ({ int x; Bar(&x); x })`).
`__attribute__` is an approved exception, as it is used in Objective-C API
specifications.
@@ -1215,14 +972,11 @@
@end
```
-### Avoid +new
+### Do Not Use +new
Do not invoke the `NSObject` class method `new`, nor override it in a subclass.
-Instead, use `alloc` and `init` methods to instantiate retained objects.
-
-Modern Objective-C code explicitly calls `alloc` and an `init` method to create
-and retain an object. As the `new` class method is rarely used, it makes
-reviewing code for correct memory management more difficult.
+`+new` is rarely used and contrasts greatly with initializer usage. Instead, use
+`+alloc` and `-init` methods to instantiate retained objects.
### Keep the Public API Simple
@@ -1245,13 +999,10 @@
`#import` Objective-C and Objective-C++ headers, and `#include` C/C++ headers.
-Choose between `#import` and `#include` based on the language of the header that
-you are including.
-
-
-When including a header that uses Objective-C or Objective-C++, use `#import`.
-When including a standard C or C++ header, use `#include`.
-The header should provide its own `#define` guard.
+C/C++ headers include other C/C++ headers using `#include`. Using `#import`
+on C/C++ headers prevents future inclusions using `#include` and could result in
+unintended compilation behavior.
+C/C++ headers should provide their own `#define` guard.
### Order of Includes
@@ -1265,6 +1016,8 @@
A blank line may separate logically distinct groups of included headers.
+Within each group the includes should be ordered alphabetically.
+
Import headers using their path relative to the project's source directory.
```objectivec
@@ -1451,14 +1204,26 @@
### `nil` Checks
-Use `nil` checks for logic flow only.
-
-Use `nil` pointer checks for logic flow of the application, not for preventing
-crashes when sending messages. Sending a message to `nil` [reliably
+Avoid `nil` pointer checks that exist only to prevent sending messages to `nil`.
+Sending a message to `nil` [reliably
returns](http://www.sealiesoftware.com/blog/archive/2012/2/29/objc_explain_return_value_of_message_to_nil.html)
`nil` as a pointer, zero as an integer or floating-point value, structs
initialized to `0`, and `_Complex` values equal to `{0, 0}`.
+```objectivec
+// AVOID:
+
+if (dataSource) { // AVOID.
+ [dataSource moveItemAtIndex:1 toIndex:0];
+}
+```
+
+```objectivec
+// GOOD:
+
+[dataSource moveItemAtIndex:1 toIndex:0]; // GOOD.
+```
+
Note that this applies to `nil` as a message target, not as a parameter value.
Individual methods may or may not safely handle `nil` parameter values.
@@ -1467,6 +1232,54 @@
application to crash. You still need to make sure you do not dereference a
`NULL` pointer.
+### Nullability
+
+Interfaces can be decorated with nullability annotations to describe how the
+interface should be used and how it behaves. Use of nullability regions (e.g.,
+`NS_ASSUME_NONNULL_BEGIN` and `NS_ASSUME_NONNULL_END`) and explicit nullability
+annotations are both accepted. Prefer using the `_Nullable` and `_Nonnull`
+keywords over the `__nullable` and `__nonnull` keywords. For Objective-C methods
+and properties prefer using the context-sensitive, non-underscored keywords,
+e.g., `nonnull` and `nullable`.
+
+```objectivec
+// GOOD:
+
+/** A class representing an owned book. */
+@interface GTMBook : NSObject
+
+/** The title of the book. */
+@property(readonly, copy, nonnull) NSString *title;
+
+/** The author of the book, if one exists. */
+@property(readonly, copy, nullable) NSString *author;
+
+/** The owner of the book. Setting nil resets to the default owner. */
+@property(copy, null_resettable) NSString *owner;
+
+/** Initializes a book with a title and an optional author. */
+- (nonnull instancetype)initWithTitle:(nonnull NSString *)title
+ author:(nullable NSString *)author
+ NS_DESIGNATED_INITIALIZER;
+
+/** Returns nil because a book is expected to have a title. */
+- (nullable instancetype)init;
+
+@end
+
+/** Loads books from the file specified by the given path. */
+NSArray<GTMBook *> *_Nullable GTMLoadBooksFromFile(NSString *_Nonnull path);
+```
+
+```objectivec
+// AVOID:
+
+NSArray<GTMBook *> *__nullable GTMLoadBooksFromTitle(NSString *__nonnull path);
+```
+
+Be careful assuming that a pointer is not null based on a non-null qualifier
+because the compiler may not guarantee that the pointer is not null.
+
### BOOL Pitfalls
Be careful when converting general integral values to `BOOL`. Avoid comparing
@@ -1479,7 +1292,7 @@
Common mistakes include casting or converting an array's size, a pointer value,
or the result of a bitwise logic operation to a `BOOL` that could, depending on
the value of the last byte of the integer value, still result in a `NO` value.
-When converting a general integral value to a `BOOL` use ternary operators to
+When converting a general integral value to a `BOOL`, use ternary operators to
return a `YES` or `NO` value.
You can safely interchange and convert `BOOL`, `_Bool` and `bool` (see C++ Std
@@ -1610,7 +1423,7 @@
// file: mac_implementation.mm
#include "cross_platform_header.h"
-// A typical Objective-C class, using Objective-C naming.
+/** A typical Objective-C class, using Objective-C naming. */
@interface MyDelegate : NSObject {
@private
int _instanceVar;
@@ -1632,8 +1445,7 @@
@end
-// The platform-specific implementation of the C++ class, using
-// C++ naming.
+/** The platform-specific implementation of the C++ class, using C++ naming. */
int CrossPlatformAPI::DoSomethingPlatformSpecific() {
NSString* temp_string = [NSString stringWithFormat:@"%d", an_instance_var_];
NSLog(@"%@", temp_string);
@@ -1644,6 +1456,356 @@
Projects may opt to use an 80 column line length limit for consistency with
Google's C++ style guide.
+## Spacing and Formatting
+
+### Spaces vs. Tabs
+
+Use only spaces, and indent 2 spaces at a time. We use spaces for indentation.
+Do not use tabs in your code.
+
+You should set your editor to emit spaces when you hit the tab key, and to trim
+trailing spaces on lines.
+
+### Line Length
+
+The maximum line length for Objective-C files is 100 columns.
+
+You can make violations easier to spot by enabling *Preferences > Text Editing >
+Page guide at column: 100* in Xcode.
+
+### Method Declarations and Definitions
+
+One space should be used between the `-` or `+` and the return type, and no
+spacing in the parameter list except between parameters.
+
+Methods should look like this:
+
+```objectivec
+// GOOD:
+
+- (void)doSomethingWithString:(NSString *)theString {
+ ...
+}
+```
+
+The spacing before the asterisk is optional. When adding new code, be consistent
+with the surrounding file's style.
+
+If a method declaration does not fit on a single line, put each parameter on its
+own line. All lines except the first should be indented at least four spaces.
+Colons before parameters should be aligned on all lines. If the colon before the
+parameter on the first line of a method declaration is positioned such that
+colon alignment would cause indentation on a subsequent line to be less than
+four spaces, then colon alignment is only required for all lines except the
+first.
+
+```objectivec
+// GOOD:
+
+- (void)doSomethingWithFoo:(GTMFoo *)theFoo
+ rect:(NSRect)theRect
+ interval:(float)theInterval {
+ ...
+}
+
+- (void)shortKeyword:(GTMFoo *)theFoo
+ longerKeyword:(NSRect)theRect
+ someEvenLongerKeyword:(float)theInterval
+ error:(NSError **)theError {
+ ...
+}
+
+- (id<UIAdaptivePresentationControllerDelegate>)
+ adaptivePresentationControllerDelegateForViewController:(UIViewController *)viewController;
+
+- (void)presentWithAdaptivePresentationControllerDelegate:
+ (id<UIAdaptivePresentationControllerDelegate>)delegate;
+```
+
+### Function Declarations and Definitions
+
+Prefer putting the return type on the same line as the function name and append
+all parameters on the same line if they will fit. Wrap parameter lists which do
+not fit on a single line as you would wrap arguments in a [function
+call](#Function_Calls).
+
+```objectivec
+// GOOD:
+
+NSString *GTMVersionString(int majorVersion, minorVersion) {
+ ...
+}
+
+void GTMSerializeDictionaryToFileOnDispatchQueue(
+ NSDictionary<NSString *, NSString *> *dictionary,
+ NSString *filename,
+ dispatch_queue_t queue) {
+ ...
+}
+```
+
+Function declarations and definitions should also satisfy the following
+conditions:
+
+* The opening parenthesis must always be on the same line as the function
+ name.
+* If you cannot fit the return type and the function name on a single line,
+ break between them and do not indent the function name.
+* There should never be a space before the opening parenthesis.
+* There should never be a space between function parentheses and parameters.
+* The open curly brace is always on the end of the last line of the function
+ declaration, not the start of the next line.
+* The close curly brace is either on the last line by itself or on the same
+ line as the open curly brace.
+* There should be a space between the close parenthesis and the open curly
+ brace.
+* All parameters should be aligned if possible.
+* Function scopes should be indented 2 spaces.
+* Wrapped parameters should have a 4 space indent.
+
+### Conditionals
+
+Include a space after `if`, `while`, `for`, and `switch`, and around comparison
+operators.
+
+```objectivec
+// GOOD:
+
+for (int i = 0; i < 5; ++i) {
+}
+
+while (test) {};
+```
+
+Braces may be omitted when a loop body or conditional statement fits on a single
+line.
+
+```objectivec
+// GOOD:
+
+if (hasSillyName) LaughOutLoud();
+
+for (int i = 0; i < 10; i++) {
+ BlowTheHorn();
+}
+```
+
+```objectivec
+// AVOID:
+
+if (hasSillyName)
+ LaughOutLoud(); // AVOID.
+
+for (int i = 0; i < 10; i++)
+ BlowTheHorn(); // AVOID.
+```
+
+If an `if` clause has an `else` clause, both clauses should use braces.
+
+```objectivec
+// GOOD:
+
+if (hasBaz) {
+ foo();
+} else { // The else goes on the same line as the closing brace.
+ bar();
+}
+```
+
+```objectivec
+// AVOID:
+
+if (hasBaz) foo();
+else bar(); // AVOID.
+
+if (hasBaz) {
+ foo();
+} else bar(); // AVOID.
+```
+
+Intentional fall-through to the next case should be documented with a comment
+unless the case has no intervening code before the next case.
+
+```objectivec
+// GOOD:
+
+switch (i) {
+ case 1:
+ ...
+ break;
+ case 2:
+ j++;
+ // Falls through.
+ case 3: {
+ int k;
+ ...
+ break;
+ }
+ case 4:
+ case 5:
+ case 6: break;
+}
+```
+
+### Expressions
+
+Use a space around binary operators and assignments. Omit a space for a unary
+operator. Do not add spaces inside parentheses.
+
+```objectivec
+// GOOD:
+
+x = 0;
+v = w * x + y / z;
+v = -y * (x + z);
+```
+
+Factors in an expression may omit spaces.
+
+```objectivec
+// GOOD:
+
+v = w*x + y/z;
+```
+
+### Method Invocations
+
+Method invocations should be formatted much like method declarations.
+
+When there's a choice of formatting styles, follow the convention already used
+in a given source file. Invocations should have all arguments on one line:
+
+```objectivec
+// GOOD:
+
+[myObject doFooWith:arg1 name:arg2 error:arg3];
+```
+
+or have one argument per line, with colons aligned:
+
+```objectivec
+// GOOD:
+
+[myObject doFooWith:arg1
+ name:arg2
+ error:arg3];
+```
+
+Don't use any of these styles:
+
+```objectivec
+// AVOID:
+
+[myObject doFooWith:arg1 name:arg2 // some lines with >1 arg
+ error:arg3];
+
+[myObject doFooWith:arg1
+ name:arg2 error:arg3];
+
+[myObject doFooWith:arg1
+ name:arg2 // aligning keywords instead of colons
+ error:arg3];
+```
+
+As with declarations and definitions, when the first keyword is shorter than the
+others, indent the later lines by at least four spaces, maintaining colon
+alignment:
+
+```objectivec
+// GOOD:
+
+[myObj short:arg1
+ longKeyword:arg2
+ evenLongerKeyword:arg3
+ error:arg4];
+```
+
+Invocations containing multiple inlined blocks may have their parameter names
+left-aligned at a four space indent.
+
+### Function Calls
+
+Function calls should include as many parameters as fit on each line, except
+where shorter lines are needed for clarity or documentation of the parameters.
+
+Continuation lines for function parameters may be indented to align with the
+opening parenthesis, or may have a four-space indent.
+
+```objectivec
+// GOOD:
+
+CFArrayRef array = CFArrayCreate(kCFAllocatorDefault, objects, numberOfObjects,
+ &kCFTypeArrayCallBacks);
+
+NSString *string = NSLocalizedStringWithDefaultValue(@"FEET", @"DistanceTable",
+ resourceBundle, @"%@ feet", @"Distance for multiple feet");
+
+UpdateTally(scores[x] * y + bases[x], // Score heuristic.
+ x, y, z);
+
+TransformImage(image,
+ x1, x2, x3,
+ y1, y2, y3,
+ z1, z2, z3);
+```
+
+Use local variables with descriptive names to shorten function calls and reduce
+nesting of calls.
+
+```objectivec
+// GOOD:
+
+double scoreHeuristic = scores[x] * y + bases[x];
+UpdateTally(scoreHeuristic, x, y, z);
+```
+
+### Exceptions
+
+Format exceptions with `@catch` and `@finally` labels on the same line as the
+preceding `}`. Add a space between the `@` label and the opening brace (`{`), as
+well as between the `@catch` and the caught object declaration. If you must use
+Objective-C exceptions, format them as follows. However, see [Avoid Throwing
+Exceptions](#Avoid_Throwing_Exceptions) for reasons why you should not be using
+exceptions.
+
+```objectivec
+// GOOD:
+
+@try {
+ foo();
+} @catch (NSException *ex) {
+ bar(ex);
+} @finally {
+ baz();
+}
+```
+
+### Function Length
+
+Prefer small and focused functions.
+
+Long functions and methods are occasionally appropriate, so no hard limit is
+placed on function length. If a function exceeds about 40 lines, think about
+whether it can be broken up without harming the structure of the program.
+
+Even if your long function works perfectly now, someone modifying it in a few
+months may add new behavior. This could result in bugs that are hard to find.
+Keeping your functions short and simple makes it easier for other people to read
+and modify your code.
+
+When updating legacy code, consider also breaking long functions into smaller
+and more manageable pieces.
+
+### Vertical Whitespace
+
+Use vertical whitespace sparingly.
+
+To allow more code to be easily viewed on a screen, avoid putting blank lines
+just inside the braces of functions.
+
+Limit blank lines to one or two between functions and between logical groups of
+code.
+
## Objective-C Style Exceptions
### Indicating style exceptions
diff --git a/pyguide.html b/pyguide.html
deleted file mode 100644
index 6987f2b..0000000
--- a/pyguide.html
+++ /dev/null
@@ -1,2310 +0,0 @@
-<HTML xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcq="http://purl.org/dc/qualifiers/1.0/" xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:fn="http://www.w3.org/2005/xpath-functions">
-<HEAD>
-<TITLE>Google Python Style Guide</TITLE>
-<META http-equiv="Content-Type" content="text/html; charset=utf-8">
-<LINK HREF="https://www.google.com/favicon.ico" type="image/x-icon" rel="shortcut icon">
-<LINK HREF="styleguide.css" type="text/css" rel="stylesheet">
-<SCRIPT language="javascript" type="text/javascript">
-
- function GetElementsByName(name) {
- // Workaround a bug on old versions of opera.
- if (document.getElementsByName) {
- return document.getElementsByName(name);
- } else {
- return [document.getElementById(name)];
- }
- }
-
- /**
- * @param {string} namePrefix The prefix of the body name.
- * @param {function(boolean): boolean} getVisibility Computes the new
- * visibility state, given the current one.
- */
- function ChangeVisibility(namePrefix, getVisibility) {
- var bodyName = namePrefix + '__body';
- var buttonName = namePrefix + '__button';
- var bodyElements = GetElementsByName(bodyName);
- var linkElement = GetElementsByName('link-' + buttonName)[0];
- if (bodyElements.length != 1) {
- throw Error('ShowHideByName() got the wrong number of bodyElements: ' +
- bodyElements.length);
- } else {
- var bodyElement = bodyElements[0];
- var buttonElement = GetElementsByName(buttonName)[0];
- var isVisible = bodyElement.style.display != "none";
- if (getVisibility(isVisible)) {
- bodyElement.style.display = "inline";
- linkElement.style.display = "block";
- buttonElement.innerHTML = '▽';
- } else {
- bodyElement.style.display = "none";
- linkElement.style.display = "none";
- buttonElement.innerHTML = '▶';
- }
- }
- }
-
- function ShowHideByName(namePrefix) {
- ChangeVisibility(namePrefix, function(old) { return !old; });
- }
-
- function ShowByName(namePrefix) {
- ChangeVisibility(namePrefix, function() { return true; });
- }
-
- function ShowHideAll() {
- var allButton = GetElementsByName("show_hide_all_button")[0];
- if (allButton.innerHTML == '▽') {
- allButton.innerHTML = '▶';
- SetHiddenState(document.getElementsByTagName("body")[0].childNodes, "none", '▶');
- } else {
- allButton.innerHTML = '▽';
- SetHiddenState(document.getElementsByTagName("body")[0].childNodes, "inline", '▽');
- }
- }
-
- // Recursively sets state of all children
- // of a particular node.
- function SetHiddenState(root, newState, newButton) {
- for (var i = 0; i != root.length; i++) {
- SetHiddenState(root[i].childNodes, newState, newButton);
- if (root[i].className == 'showhide_button') {
- root[i].innerHTML = newButton;
- }
- if (root[i].className == 'stylepoint_body' ||
- root[i].className == 'link_button') {
- root[i].style.display = newState;
- }
- }
- }
-
-
- function EndsWith(str, suffix) {
- var l = str.length - suffix.length;
- return l >= 0 && str.indexOf(suffix, l) == l;
- }
-
- function RefreshVisibilityFromHashParam() {
- var hashRegexp = new RegExp('#([^&#]*)$');
- var hashMatch = hashRegexp.exec(window.location.href);
- var anchor = hashMatch && GetElementsByName(hashMatch[1])[0];
- var node = anchor;
- var suffix = '__body';
- while (node) {
- var id = node.id;
- var matched = id && EndsWith(id, suffix);
- if (matched) {
- var len = id.length - suffix.length;
- ShowByName(id.substring(0, len));
- if (anchor.scrollIntoView) {
- anchor.scrollIntoView();
- }
-
- return;
- }
- node = node.parentNode;
- }
- }
-
- window.onhashchange = RefreshVisibilityFromHashParam;
-
- window.onload = function() {
- // if the URL contains "?showall=y", expand the details of all children
- var showHideAllRegex = new RegExp("[\\?&](showall)=([^&#]*)");
- var showHideAllValue = showHideAllRegex.exec(window.location.href);
- if (showHideAllValue != null) {
- if (showHideAllValue[2] == "y") {
- SetHiddenState(document.getElementsByTagName("body")[0].childNodes,
- "inline", '▽');
- } else {
- SetHiddenState(document.getElementsByTagName("body")[0].childNodes,
- "none", '▶');
- }
- }
- var showOneRegex = new RegExp("[\\?&](showone)=([^&#]*)");
- var showOneValue = showOneRegex.exec(window.location.href);
- if (showOneValue) {
- ShowHideByName(showOneValue[2]);
- }
-
-
- RefreshVisibilityFromHashParam();
- }
- </SCRIPT>
-</HEAD>
-<BODY>
-<H1>Google Python Style Guide</H1>
- <p align="right">
-
- Revision 2.59
- </p>
-
- <address>
- Amit Patel<br>
- Antoine Picard<br>
- Eugene Jhong<br>
- Jeremy Hylton<br>
- Matt Smart<br>
- Mike Shields<br>
- </address>
- <DIV style="margin-left: 50%; font-size: 75%;">
-<P>
- Each style point has a summary for which additional information is available
- by toggling the accompanying arrow button that looks this way:
- <SPAN class="showhide_button" style="margin-left: 0; float: none">▶</SPAN>.
- You may toggle all summaries with the big arrow button:
- </P>
-<DIV style=" font-size: larger; margin-left: +2em;">
-<SPAN class="showhide_button" style="font-size: 180%; float: none" onclick="javascript:ShowHideAll()" name="show_hide_all_button" id="show_hide_all_button">▶</SPAN>
- Toggle all summaries
- </DIV>
-</DIV>
-<DIV class="toc">
-<DIV class="toc_title">Table of Contents</DIV>
-<TABLE>
-<TR valign="top" class="">
-<TD><DIV class="toc_category"><A href="#Python_Language_Rules">Python Language Rules</A></DIV></TD>
-<TD><DIV class="toc_stylepoint">
-<SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Lint">Lint</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Imports">Imports</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Packages">Packages</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Exceptions">Exceptions</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Global_variables">Global variables</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Nested/Local/Inner_Classes_and_Functions">Nested/Local/Inner Classes and Functions</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#List_Comprehensions">List Comprehensions</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Default_Iterators_and_Operators">Default Iterators and Operators</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Generators">Generators</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Lambda_Functions">Lambda Functions</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Conditional_Expressions">Conditional Expressions</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Default_Argument_Values">Default Argument Values</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Properties">Properties</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#True/False_evaluations">True/False evaluations</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Deprecated_Language_Features">Deprecated Language Features</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Lexical_Scoping">Lexical Scoping</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Function_and_Method_Decorators">Function and Method Decorators</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Threading">Threading</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Power_Features">Power Features</A></SPAN> </DIV></TD>
-</TR>
-<TR valign="top" class="">
-<TD><DIV class="toc_category"><A href="#Python_Style_Rules">Python Style Rules</A></DIV></TD>
-<TD><DIV class="toc_stylepoint">
-<SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Semicolons">Semicolons</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Line_length">Line length</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Parentheses">Parentheses</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Indentation">Indentation</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Blank_Lines">Blank Lines</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Whitespace">Whitespace</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Shebang_Line">Shebang Line</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Comments">Comments</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Classes">Classes</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Strings">Strings</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Files_and_Sockets">Files and Sockets</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#TODO_Comments">TODO Comments</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Imports_formatting">Imports formatting</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Statements">Statements</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Access_Control">Access Control</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Naming">Naming</A></SPAN> <SPAN style="padding-right: 1em; white-space:nowrap;" class=""><A href="#Main">Main</A></SPAN> </DIV></TD>
-</TR>
-</TABLE>
-</DIV>
- <DIV class="">
-<H2 name="Important_Note" id="Important_Note">Important Note</H2>
- <DIV class="">
-<H3><A name="Displaying_Hidden_Details_in_this_Guide" id="Displaying_Hidden_Details_in_this_Guide">Displaying Hidden Details in this Guide</A></H3>
-<SPAN class="link_button" id="link-Displaying_Hidden_Details_in_this_Guide__button" name="link-Displaying_Hidden_Details_in_this_Guide__button"><A href="?showone=Displaying_Hidden_Details_in_this_Guide#Displaying_Hidden_Details_in_this_Guide">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Displaying_Hidden_Details_in_this_Guide')" name="Displaying_Hidden_Details_in_this_Guide__button" id="Displaying_Hidden_Details_in_this_Guide__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- This style guide contains many details that are initially
- hidden from view. They are marked by the triangle icon, which you
- see here on your left. Click it now.
- You should see "Hooray" appear below.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Displaying_Hidden_Details_in_this_Guide__body" id="Displaying_Hidden_Details_in_this_Guide__body" style="display: none">
- <p>
- Hooray! Now you know you can expand points to get more
- details. Alternatively, there's a "toggle all" at the
- top of this document.
- </p>
- </DIV></DIV>
- </DIV>
- </DIV>
- <DIV class="">
-<H2 name="Background" id="Background">Background</H2>
- <p>
- Python is the main scripting language used at Google. This
- style guide is a list of <em>do</em>s and <em>don't</em>s for Python
- programs.
- </p>
-
- <p>
- To help you format code correctly, we've created a <a href="google_python_style.vim">settings
- file for Vim</a>. For Emacs, the default settings should be fine.
- </p>
-
-
- </DIV>
-
- <DIV class="">
-<H2 name="Python_Language_Rules" id="Python_Language_Rules">Python Language Rules</H2>
- <DIV class="">
-<H3><A name="Lint" id="Lint">Lint</A></H3>
-<SPAN class="link_button" id="link-Lint__button" name="link-Lint__button"><A href="?showone=Lint#Lint">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Lint')" name="Lint__button" id="Lint__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Run <code>pylint</code> over your code.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Lint__body" id="Lint__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- pylint
- is a tool for finding bugs and style problems in Python source
- code. It finds
- problems that are typically caught by a compiler for less dynamic
- languages like C and C++.
-
- Because of the
- dynamic nature of Python, some warnings may be incorrect; however,
- spurious warnings should be fairly infrequent.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Catches easy-to-miss errors like typos, using-vars-before-assignment, etc.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- <code>pylint</code>
- isn't perfect. To take advantage of it, we'll need to sometimes:
- a) Write around it b) Suppress its warnings or c) Improve it.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Make sure you run <code>pylint</code> on your code.
- Suppress warnings if they are inappropriate so that other issues are
- not hidden.
- </P>
-
- <p>
- To suppress warnings, you can set a line-level comment:
- </p>
-
- <DIV class=""><PRE>
-<span class="external"></span>dict = 'something awful' # Bad Idea... pylint: disable=redefined-builtin</PRE></DIV>
- <p>
- pylint
- warnings are each identified by a alphanumeric code
- (<code>C0112</code>) and a symbolic name
- (<code>empty-docstring</code>). Prefer the symbolic
- names in new code or when updating existing code.
-
- </p>
- <p>
- If the reason for the suppression is not clear from the symbolic name,
- add an explanation.
- </p>
- <p>
- Suppressing in this way has the advantage that we can easily search
- for suppressions and revisit them.
- </p>
- <p>
- You can get a list of
- pylint
- warnings by doing
- <code>pylint --list-msgs</code>.
- To get more information on a particular message, use
- <code>pylint --help-msg=C6409</code>.
- </p>
- <p>
- Prefer <code>pylint: disable</code> to the deprecated older form
- <code>pylint: disable-msg</code>.
- </p>
- <p>
- Unused argument warnings can be suppressed by using `_' as the
- identifier for the unused argument or prefixing the argument name with
- `unused_'. In situations where changing the argument names is
- infeasible, you can mention them at the beginning of the function.
- For example:
- </p>
- <DIV class=""><PRE>
-<span class="external"></span>def foo(a, unused_b, unused_c, d=None, e=None):
- <span class="external"> </span>_ = d, e
- <span class="external"> </span>return a
-<span class="external"></span>
-</PRE></DIV>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Imports" id="Imports">Imports</A></H3>
-<SPAN class="link_button" id="link-Imports__button" name="link-Imports__button"><A href="?showone=Imports#Imports">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Imports')" name="Imports__button" id="Imports__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use <code>import</code>s for packages and modules only.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Imports__body" id="Imports__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Reusability mechanism for sharing code from one module to another.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- The namespace management convention is simple. The source of each
- identifier is indicated in a consistent way; <code>x.Obj</code> says
- that object <code>Obj</code> is defined in module <code>x</code>.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN> Module names can still collide. Some module names are
- inconveniently long.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Use <code>import x</code> for importing packages and modules.
- <br>
- Use <code>from x import y</code> where <code>x</code> is
- the package prefix and <code>y</code> is the module name with no
- prefix.
- <br>
- Use <code>from x import y as z</code> if two modules named
- <code>y</code> are to be imported or if <code>y</code> is an
- inconveniently long name.
- </P>
- For example the module
- <code>sound.effects.echo</code> may be imported as follows:
- <DIV class=""><PRE>
-<span class="external"></span>from sound.effects import echo
-<span class="external"></span>...
-<span class="external"></span>echo.EchoFilter(input, output, delay=0.7, atten=4)
-<span class="external"></span>
-</PRE></DIV>
- <p>
- Do not use relative names in imports. Even if the module is in the
- same package, use the full package name. This helps prevent
- unintentionally importing a package twice.
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Packages" id="Packages">Packages</A></H3>
-<SPAN class="link_button" id="link-Packages__button" name="link-Packages__button"><A href="?showone=Packages#Packages">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Packages')" name="Packages__button" id="Packages__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Import each module using the full pathname location of the module.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Packages__body" id="Packages__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Avoids conflicts in module names. Makes it easier to find modules.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- Makes it harder to deploy code because you have to replicate the
- package hierarchy.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- All new code should import each module by its full package name.
- </P>
- <p>
- Imports should be as follows:
- </p>
-
- <DIV class=""><PRE># Reference in code with complete name.
-import sound.effects.echo
-
-# Reference in code with just module name (preferred).
-from sound.effects import echo
-</PRE></DIV>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Exceptions" id="Exceptions">Exceptions</A></H3>
-<SPAN class="link_button" id="link-Exceptions__button" name="link-Exceptions__button"><A href="?showone=Exceptions#Exceptions">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Exceptions')" name="Exceptions__button" id="Exceptions__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Exceptions are allowed but must be used carefully.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Exceptions__body" id="Exceptions__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Exceptions are a means of breaking out of the normal flow of control
- of a code block to handle errors or other exceptional conditions.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- The control flow of normal operation code is not cluttered by
- error-handling code. It also allows the control flow to skip multiple
- frames when a certain condition occurs, e.g., returning from N
- nested functions in one step instead of having to carry-through
- error codes.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- May cause the control flow to be confusing. Easy to miss error
- cases when making library calls.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
-
-
- Exceptions must follow certain conditions:
-
- <ul>
- <li>Raise exceptions like this: <code>raise MyException('Error
- message')</code> or <code>raise MyException</code>. Do not
- use the two-argument form (<code>raise MyException, 'Error
- message'</code>) or deprecated string-based exceptions
- (<code>raise 'Error message'</code>).</li>
- <li>Modules or packages should define their own domain-specific
- base exception class, which should inherit from the built-in
- Exception class. The base exception for a module should be called
- <code>Error</code>.
- <DIV class=""><PRE>
-<span class="external"></span>class Error(Exception):
- <span class="external"> </span>pass</PRE></DIV>
-</li>
- <li>Never use catch-all <code>except:</code> statements, or
- catch <code>Exception</code> or <code>StandardError</code>,
- unless you are re-raising the exception or in the outermost
- block in your thread (and printing an error message). Python
- is very tolerant in this regard and <code>except:</code> will
- really catch everything including misspelled names, sys.exit()
- calls, Ctrl+C interrupts, unittest failures and all kinds of
- other exceptions that you simply don't want to catch.</li>
- <li>Minimize the amount of code in a
- <code>try</code>/<code>except</code> block. The larger the
- body of the <code>try</code>, the more likely that an
- exception will be raised by a line of code that you didn't
- expect to raise an exception. In those cases,
- the <code>try</code>/<code>except</code> block hides a real
- error.</li>
- <li>Use the <code>finally</code> clause to execute code whether
- or not an exception is raised in the <code>try</code> block.
- This is often useful for cleanup, i.e., closing a file.</li>
- <li>When capturing an exception, use <code>as</code> rather than
- a comma. For example:
- <DIV class=""><PRE>
-<span class="external"></span>try:
- <span class="external"> </span>raise Error
-<span class="external"></span>except Error as error:
- <span class="external"> </span>pass</PRE></DIV>
-</li>
- </ul>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Global_variables" id="Global_variables">Global variables</A></H3>
-<SPAN class="link_button" id="link-Global_variables__button" name="link-Global_variables__button"><A href="?showone=Global_variables#Global_variables">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Global_variables')" name="Global_variables__button" id="Global_variables__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Avoid global variables.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Global_variables__body" id="Global_variables__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Variables that are declared at the module level.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Occasionally useful.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- Has the potential to change module behavior during the import,
- because assignments to module-level variables are done when the
- module is imported.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Avoid global variables in favor of class variables. Some
- exceptions are:
- <ul>
- <li>Default options for scripts.</li>
- <li>Module-level constants. For example: <code>PI = 3.14159</code>.
- Constants should be named using all caps with underscores;
- see <a HREF="#Naming">Naming</a> below.</li>
- <li>It is sometimes useful for globals to cache values needed
- or returned by functions.</li>
- <li>If needed, globals should be made internal to the module
- and accessed through public module level functions;
- see <a HREF="#Naming">Naming</a> below.</li>
- </ul>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Nested/Local/Inner_Classes_and_Functions" id="Nested/Local/Inner_Classes_and_Functions">Nested/Local/Inner Classes and Functions</A></H3>
-<SPAN class="link_button" id="link-Nested/Local/Inner_Classes_and_Functions__button" name="link-Nested/Local/Inner_Classes_and_Functions__button"><A href="?showone=Nested/Local/Inner_Classes_and_Functions#Nested/Local/Inner_Classes_and_Functions">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Nested/Local/Inner_Classes_and_Functions')" name="Nested/Local/Inner_Classes_and_Functions__button" id="Nested/Local/Inner_Classes_and_Functions__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Nested/local/inner classes and functions are fine.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Nested/Local/Inner_Classes_and_Functions__body" id="Nested/Local/Inner_Classes_and_Functions__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- A class can be defined inside of a method, function, or class. A
- function can be defined inside a method or function. Nested functions
- have read-only access to variables defined in enclosing scopes.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Allows definition of utility classes and functions that are only
- used inside of a very limited scope. Very <a HREF="https://en.wikipedia.org/wiki/Abstract_data_type">ADT</a>-y.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- Instances of nested or local classes cannot be pickled.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- They are fine.
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="List_Comprehensions" id="List_Comprehensions">List Comprehensions</A></H3>
-<SPAN class="link_button" id="link-List_Comprehensions__button" name="link-List_Comprehensions__button"><A href="?showone=List_Comprehensions#List_Comprehensions">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('List_Comprehensions')" name="List_Comprehensions__button" id="List_Comprehensions__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Okay to use for simple cases.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="List_Comprehensions__body" id="List_Comprehensions__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- List comprehensions and generator expressions provide a concise
- and efficient way to create lists and iterators without
- resorting to the use of <code>map()</code>,
- <code>filter()</code>, or <code>lambda</code>.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Simple list comprehensions can be clearer and simpler than
- other list creation techniques. Generator expressions can be
- very efficient, since they avoid the creation of a list
- entirely.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- Complicated list comprehensions or generator expressions can be
- hard to read.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Okay to use for simple cases. Each portion must fit on one line:
- mapping expression, <code>for</code> clause, filter expression.
- Multiple <code>for</code> clauses or filter expressions are not
- permitted. Use loops instead when things get more complicated.
- </P>
-
-<DIV class=""><PRE>Ye<span class="external"></span>s:
- <span class="external"></span>result = []
- <span class="external"></span>for x in range(10):
- <span class="external"> </span>for y in range(5):
- <span class="external"> </span>if x * y > 10:
- <span class="external"> </span>result.append((x, y))
-
- <span class="external"></span>for x in xrange(5):
- <span class="external"> </span>for y in xrange(5):
- <span class="external"> </span>if x != y:
- <span class="external"> </span>for z in xrange(5):
- <span class="external"> </span>if y != z:
- <span class="external"> </span>yield (x, y, z)
-
- <span class="external"></span>return ((x, complicated_transform(x))
- <span class="external"></span> for x in long_generator_function(parameter)
- <span class="external"></span> if x is not None)
-
- <span class="external"></span>squares = [x * x for x in range(10)]
-
- <span class="external"></span>eat(jelly_bean for jelly_bean in jelly_beans
- <span class="external"></span> if jelly_bean.color == 'black')</PRE></DIV>
-<DIV class=""><PRE class="badcode">No<span class="external"></span>:
- <span class="external"></span>result = [(x, y) for x in range(10) for y in range(5) if x * y > 10]
-
- <span class="external"></span>return ((x, y, z)
- <span class="external"></span> for x in xrange(5)
- <span class="external"></span> for y in xrange(5)
- <span class="external"></span> if x != y
- <span class="external"></span> for z in xrange(5)
- <span class="external"></span> if y != z)</PRE></DIV>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Default_Iterators_and_Operators" id="Default_Iterators_and_Operators">Default Iterators and Operators</A></H3>
-<SPAN class="link_button" id="link-Default_Iterators_and_Operators__button" name="link-Default_Iterators_and_Operators__button"><A href="?showone=Default_Iterators_and_Operators#Default_Iterators_and_Operators">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Default_Iterators_and_Operators')" name="Default_Iterators_and_Operators__button" id="Default_Iterators_and_Operators__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use default iterators and operators for types that support them,
- like lists, dictionaries, and files.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Default_Iterators_and_Operators__body" id="Default_Iterators_and_Operators__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Container types, like dictionaries and lists, define default
- iterators and membership test operators ("in" and "not in").
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- The default iterators and operators are simple and efficient.
- They express the operation directly, without extra method calls.
- A function that uses default operators is generic. It can be
- used with any type that supports the operation.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- You can't tell the type of objects by reading the method names
- (e.g. has_key() means a dictionary). This is also an advantage.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN> Use default iterators and operators for types
- that support them, like lists, dictionaries, and files. The
- built-in types define iterator methods, too. Prefer these
- methods to methods that return lists, except that you should not
- mutate a container while iterating over it.
-
-<DIV class=""><PRE>Yes: <span class="external"></span>for key in adict: ...
- <span class="external"></span>if key not in adict: ...
- <span class="external"></span>if obj in alist: ...
- <span class="external"></span>for line in afile: ...
- <span class="external"></span>for k, v in dict.iteritems(): ...</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>for key in adict.keys(): ...
- <span class="external"></span>if not adict.has_key(key): ...
- <span class="external"></span>for line in afile.readlines(): ...</PRE></DIV>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Generators" id="Generators">Generators</A></H3>
-<SPAN class="link_button" id="link-Generators__button" name="link-Generators__button"><A href="?showone=Generators#Generators">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Generators')" name="Generators__button" id="Generators__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use generators as needed.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Generators__body" id="Generators__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- A generator function returns an iterator that yields a value each
- time it executes a yield statement. After it yields a value, the
- runtime state of the generator function is suspended until the
- next value is needed.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Simpler code, because the state of local variables and control flow
- are preserved for each call. A generator uses less memory than a
- function that creates an entire list of values at once.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- None.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Fine. Use "Yields:" rather than "Returns:" in the
- doc string for generator functions.
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Lambda_Functions" id="Lambda_Functions">Lambda Functions</A></H3>
-<SPAN class="link_button" id="link-Lambda_Functions__button" name="link-Lambda_Functions__button"><A href="?showone=Lambda_Functions#Lambda_Functions">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Lambda_Functions')" name="Lambda_Functions__button" id="Lambda_Functions__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Okay for one-liners.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Lambda_Functions__body" id="Lambda_Functions__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Lambdas define anonymous functions in an expression, as
- opposed to a statement. They are often used to define callbacks or
- operators for higher-order functions like <code>map()</code> and
- <code>filter()</code>.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Convenient.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN> Harder to read and debug than local functions. The
- lack of names means stack traces are more difficult to
- understand. Expressiveness is limited because the function may
- only contain an expression.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Okay to use them for one-liners. If the code inside the lambda
- function is any longer than 60–80 chars, it's probably better to
- define it as a regular (nested) function.
- <p>
- For common operations like multiplication, use the functions from the
- <code>operator</code> module instead of lambda functions. For
- example, prefer <code>operator.mul</code> to <code>lambda
- x, y: x * y</code>.
- </p>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Conditional_Expressions" id="Conditional_Expressions">Conditional Expressions</A></H3>
-<SPAN class="link_button" id="link-Conditional_Expressions__button" name="link-Conditional_Expressions__button"><A href="?showone=Conditional_Expressions#Conditional_Expressions">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Conditional_Expressions')" name="Conditional_Expressions__button" id="Conditional_Expressions__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Okay for one-liners.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Conditional_Expressions__body" id="Conditional_Expressions__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Conditional expressions are mechanisms that provide a shorter syntax
- for if statements. For example:
- <code>x = 1 if cond else 2</code>.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Shorter and more convenient than an if statement.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- May be harder to read than an if statement. The condition may be difficult
- to locate if the expression is long.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Okay to use for one-liners. In other cases prefer to use a complete if
- statement.
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Default_Argument_Values" id="Default_Argument_Values">Default Argument Values</A></H3>
-<SPAN class="link_button" id="link-Default_Argument_Values__button" name="link-Default_Argument_Values__button"><A href="?showone=Default_Argument_Values#Default_Argument_Values">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Default_Argument_Values')" name="Default_Argument_Values__button" id="Default_Argument_Values__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Okay in most cases.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Default_Argument_Values__body" id="Default_Argument_Values__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- You can specify values for variables at the end of a function's
- parameter list, e.g., <code>def foo(a, b=0):</code>. If
- <code>foo</code> is called with only one argument,
- <code>b</code> is set to 0. If it is called with two arguments,
- <code>b</code> has the value of the second argument.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Often you have a function that uses lots of default values,
- but—rarely—you want to override the
- defaults. Default argument values provide an easy way to do this,
- without having to define lots of functions for the rare
- exceptions. Also, Python does not support overloaded
- methods/functions and default arguments are an easy way of
- "faking" the overloading behavior.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- Default arguments are evaluated once at module load
- time. This may cause problems if the argument is a mutable
- object such as a list or a dictionary. If the function modifies
- the object (e.g., by appending an item to a list), the default
- value is modified.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Okay to use with the following caveat:
- <p>
- Do not use mutable objects as default values in the function or method
- definition.
- </p>
-<DIV class=""><PRE>Yes: <span class="external"></span>def foo(a, b=None):
- <span class="external"> </span>if b is None:
- <span class="external"> </span>b = []</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>def foo(a, b=[]):
- <span class="external"> </span>...
-No: <span class="external"></span>def foo(a, b=time.time()): # The time the module was loaded???
- <span class="external"> </span>...
-No: <span class="external"></span>def foo(a, b=FLAGS.my_thing): # sys.argv has not yet been parsed...
- <span class="external"> </span>...</PRE></DIV>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Properties" id="Properties">Properties</A></H3>
-<SPAN class="link_button" id="link-Properties__button" name="link-Properties__button"><A href="?showone=Properties#Properties">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Properties')" name="Properties__button" id="Properties__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use properties for accessing or setting data where you would
- normally have used simple, lightweight accessor or setter methods.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Properties__body" id="Properties__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN> A way to wrap method calls for getting and
- setting an attribute as a standard attribute access when the
- computation is lightweight.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN> Readability is increased by eliminating explicit
- get and set method calls for simple attribute access. Allows
- calculations to be lazy. Considered the Pythonic way to
- maintain the interface of a class. In terms of performance,
- allowing properties bypasses needing trivial accessor methods
- when a direct variable access is reasonable. This also allows
- accessor methods to be added in the future without breaking the
- interface.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN> Properties are specified after the getter and
- setter methods are declared, requiring one to notice they are
- used for properties farther down in the code (except for readonly
- properties created with the <code>@property</code> decorator - see
- below). Must inherit from
- <code>object</code>. Can hide side-effects much like operator
- overloading. Can be confusing for subclasses.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN> Use properties in new code to access or
- set data where you would normally have used simple, lightweight
- accessor or setter methods. Read-only properties should be created
- with the <code>@property</code>
- <a HREF="#Function_and_Method_Decorators">decorator</a>.
-
- <p><a id="properties-template-dp">
- Inheritance with properties can be non-obvious if the property itself is
- not overridden. Thus one must make sure that accessor methods are
- called indirectly to ensure methods overridden in subclasses are called
- by the property (using the Template Method DP).
- </a></p>
-
- <DIV class=""><PRE>Yes: <span class="external"></span>import math
-
- <span class="external"></span>class Square(object):
- <span class="external"> </span>"""A square with two properties: a writable area and a read-only perimeter.
-
- <span class="external"> </span>To use:
- <span class="external"> </span>>>> sq = Square(3)
- <span class="external"> </span>>>> sq.area
- <span class="external"> </span>9
- <span class="external"> </span>>>> sq.perimeter
- <span class="external"> </span>12
- <span class="external"> </span>>>> sq.area = 16
- <span class="external"> </span>>>> sq.side
- <span class="external"> </span>4
- <span class="external"> </span>>>> sq.perimeter
- <span class="external"> </span>16
- <span class="external"> </span>"""
-
- <span class="external"> </span>def __init__(self, side):
- <span class="external"> </span>self.side = side
-
- <span class="external"> </span>def __get_area(self):
- <span class="external"> </span>"""Calculates the 'area' property."""
- <span class="external"> </span>return self.side ** 2
-
- <span class="external"> </span>def ___get_area(self):
- <span class="external"> </span>"""Indirect accessor for 'area' property."""
- <span class="external"> </span>return self.__get_area()
-
- <span class="external"> </span>def __set_area(self, area):
- <span class="external"> </span>"""Sets the 'area' property."""
- <span class="external"> </span>self.side = math.sqrt(area)
-
- <span class="external"> </span>def ___set_area(self, area):
- <span class="external"> </span>"""Indirect setter for 'area' property."""
- <span class="external"> </span>self.__set_area(area)
-
- <span class="external"> </span>area = property(___get_area, ___set_area,
- <span class="external"> </span> doc="""Gets or sets the area of the square.""")
-
- <span class="external"> </span>@property
- <span class="external"> </span>def perimeter(self):
- <span class="external"> </span>return self.side * 4
-<span class="external"></span>
-</PRE></DIV>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="True/False_evaluations" id="True/False_evaluations">True/False evaluations</A></H3>
-<SPAN class="link_button" id="link-True/False_evaluations__button" name="link-True/False_evaluations__button"><A href="?showone=True/False_evaluations#True/False_evaluations">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('True/False_evaluations')" name="True/False_evaluations__button" id="True/False_evaluations__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use the "implicit" false if at all possible.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="True/False_evaluations__body" id="True/False_evaluations__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN> Python evaluates certain values as <code>false</code>
- when in a boolean context. A quick "rule of thumb" is that all
- "empty" values are considered <code>false</code> so <code>0, None, [], {},
- ''</code> all evaluate as <code>false</code> in a boolean context.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN> Conditions using Python booleans are easier to read
- and less error-prone. In most cases, they're also faster.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- May look strange to C/C++ developers.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Use the "implicit" false if at all possible, e.g., <code>if
- foo:</code> rather than <code>if foo != []:</code>. There are a
- few caveats that you should keep in mind though:
- <ul>
- <li>
- Never use <code>==</code> or <code>!=</code> to compare
- singletons like <code>None</code>. Use <code>is</code>
- or <code>is not</code>.</li>
-
- <li>Beware of writing <code>if x:</code> when you really mean
- <code>if x is not None:</code>—e.g., when testing whether
- a variable or argument that defaults to <code>None</code> was
- set to some other value. The other value might be a value
- that's false in a boolean context!</li>
-
- <li>
- Never compare a boolean variable to <code>False</code> using
- <code>==</code>. Use <code>if not x:</code> instead. If
- you need to distinguish <code>False</code> from
- <code>None</code> then chain the expressions,
- such as <code>if not x and x is not None:</code>.
- </li>
-
- <li>
- For sequences (strings, lists, tuples), use the fact that
- empty sequences are false, so <code>if not seq:</code> or
- <code>if seq:</code> is preferable to <code>if
- len(seq):</code> or <code>if not
- len(seq):</code>.</li>
-
- <li>
- When handling integers, implicit false may involve more risk than
- benefit (i.e., accidentally handling <code>None</code> as 0). You may
- compare a value which is known to be an integer (and is not the
- result of <code>len()</code>) against the integer 0.
-<DIV class=""><PRE>Yes: <span class="external"></span>if not users:
- <span class="external"> </span>print 'no users'
-
- <span class="external"></span>if foo == 0:
- <span class="external"> </span>self.handle_zero()
-
- <span class="external"></span>if i % 10 == 0:
- <span class="external"> </span>self.handle_multiple_of_ten()</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>if len(users) == 0:
- <span class="external"> </span>print 'no users'
-
- <span class="external"></span>if foo is not None and not foo:
- <span class="external"> </span>self.handle_zero()
-
- <span class="external"></span>if not i % 10:
- <span class="external"> </span>self.handle_multiple_of_ten()</PRE></DIV>
-</li>
-
- <li>
- Note that <code>'0'</code> (i.e., <code>0</code> as string)
- evaluates to true.</li>
- </ul>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Deprecated_Language_Features" id="Deprecated_Language_Features">Deprecated Language Features</A></H3>
-<SPAN class="link_button" id="link-Deprecated_Language_Features__button" name="link-Deprecated_Language_Features__button"><A href="?showone=Deprecated_Language_Features#Deprecated_Language_Features">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Deprecated_Language_Features')" name="Deprecated_Language_Features__button" id="Deprecated_Language_Features__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use string methods instead of the <code>string</code> module
- where possible. Use function call syntax instead
- of <code>apply</code>. Use list comprehensions
- and <code>for</code> loops instead of <code>filter</code> and
- <code>map</code> when the function argument would have been an
- inlined lambda anyway. Use <code>for</code> loops instead of
- <code>reduce</code>.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Deprecated_Language_Features__body" id="Deprecated_Language_Features__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- Current versions of Python provide alternative constructs
- that people find generally preferable.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- We do not use any Python version which does not support
- these features, so there is no reason not to use the new
- styles.
-<DIV class=""><PRE>Yes: <span class="external"></span>words = foo.split(':')
-
- <span class="external"></span>[x[1] for x in my_list if x[2] == 5]
-
- <span class="external"></span>map(math.sqrt, data) # Ok. No inlined lambda expression.
-
- <span class="external"></span>fn(*args, **kwargs)</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>words = string.split(foo, ':')
-
- <span class="external"></span>map(lambda x: x[1], filter(lambda x: x[2] == 5, my_list))
-
- <span class="external"></span>apply(fn, args, kwargs)</PRE></DIV>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Lexical_Scoping" id="Lexical_Scoping">Lexical Scoping</A></H3>
-<SPAN class="link_button" id="link-Lexical_Scoping__button" name="link-Lexical_Scoping__button"><A href="?showone=Lexical_Scoping#Lexical_Scoping">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Lexical_Scoping')" name="Lexical_Scoping__button" id="Lexical_Scoping__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Okay to use.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Lexical_Scoping__body" id="Lexical_Scoping__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
- A nested Python function can refer to variables defined in
- enclosing functions, but can not assign to them. Variable
- bindings are resolved using lexical scoping, that is, based on
- the static program text. Any assignment to a name in a block
- will cause Python to treat all references to that name as a
- local variable, even if the use precedes the assignment. If a
- global declaration occurs, the name is treated as a global
- variable.
-
- <p>
- An example of the use of this feature is:
- </p>
-
- <DIV class=""><PRE>
-<span class="external"></span>def get_adder(summand1):
- <span class="external"> </span>"""Returns a function that adds numbers to a given number."""
- <span class="external"> </span>def adder(summand2):
- <span class="external"> </span>return summand1 + summand2
-
- <span class="external"> </span>return adder
-<span class="external"></span>
-</PRE></DIV>
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN>
- Often results in clearer, more elegant code. Especially comforting
- to experienced Lisp and Scheme (and Haskell and ML and …)
- programmers.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN>
- Can lead to confusing bugs. Such as this example based on
- <a HREF="https://www.python.org/dev/peps/pep-0227/">PEP-0227</a>:
-<DIV class=""><PRE class="badcode">
-<span class="external"></span>i = 4
-<span class="external"></span>def foo(x):
- <span class="external"> </span>def bar():
- <span class="external"> </span>print i,
- <span class="external"> </span># ...
- <span class="external"> </span># A bunch of code here
- <span class="external"> </span># ...
- <span class="external"> </span>for i in x: # Ah, i *is* local to Foo, so this is what Bar sees
- <span class="external"> </span>print i,
- <span class="external"> </span>bar()</PRE></DIV>
- <p>
- So <code>foo([1, 2, 3])</code> will print <code>1 2 3 3</code>, not
- <code>1 2 3 4</code>.
- </p>
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Okay to use.
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Function_and_Method_Decorators" id="Function_and_Method_Decorators">Function and Method Decorators</A></H3>
-<SPAN class="link_button" id="link-Function_and_Method_Decorators__button" name="link-Function_and_Method_Decorators__button"><A href="?showone=Function_and_Method_Decorators#Function_and_Method_Decorators">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Function_and_Method_Decorators')" name="Function_and_Method_Decorators__button" id="Function_and_Method_Decorators__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use decorators judiciously when there is a clear advantage.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Function_and_Method_Decorators__body" id="Function_and_Method_Decorators__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN>
-
- <a HREF="https://www.python.org/dev/peps/pep-0318">Decorators
- for Functions and Methods</a>
- (a.k.a "the <code>@</code> notation").
- The most common decorators are <code>@classmethod</code> and
- <code>@staticmethod</code>, for converting ordinary methods to class or
- static methods. However, the decorator syntax allows for
- user-defined decorators as well. Specifically, for some function
- <code>my_decorator</code>, this:
- <DIV class=""><PRE>
-<span class="external"></span>class C(object):
- <span class="external"> </span>@my_decorator
- <span class="external"> </span>def method(self):
- <span class="external"> </span># method body ...
-<span class="external"></span>
-</PRE></DIV>
-
- is equivalent to:
- <DIV class=""><PRE>
-<span class="external"></span>class C(object):
- <span class="external"> </span>def method(self):
- <span class="external"> </span># method body ...
- <span class="external"> </span>method = my_decorator(method)
-<span class="external"></span>
-</PRE></DIV>
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN> Elegantly specifies some transformation on a method; the
- transformation might eliminate some repetitive code, enforce invariants,
- etc.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN> Decorators can perform arbitrary operations on a
- function's arguments or return values, resulting in surprising
- implicit behavior.
- Additionally, decorators execute at import time. Failures in decorator
- code are pretty much impossible to recover from.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN> Use decorators judiciously when there is a clear
- advantage. Decorators should follow the same import and naming
- guidelines as functions. Decorator pydoc should clearly state that the
- function is a decorator. Write unit tests for decorators.
-
- <p>
- Avoid external dependencies in the decorator itself (e.g. don't rely on
- files, sockets, database connections, etc.), since they might not be
- available when the decorator runs (at import time, perhaps from
- <code>pydoc</code> or other tools). A decorator that is
- called with valid parameters should (as much as possible) be guaranteed
- to succeed in all cases.
- </p>
- <p>
- Decorators are a special case of "top level code" - see
- <a HREF="#Main">main</a> for more discussion.
- </p>
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Threading" id="Threading">Threading</A></H3>
-<SPAN class="link_button" id="link-Threading__button" name="link-Threading__button"><A href="?showone=Threading#Threading">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Threading')" name="Threading__button" id="Threading__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Do not rely on the atomicity of built-in types.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Threading__body" id="Threading__body" style="display: none">
- <p>
- While Python's built-in data types such as dictionaries appear
- to have atomic operations, there are corner cases where they
- aren't atomic (e.g. if <code>__hash__</code> or
- <code>__eq__</code> are implemented as Python methods) and their
- atomicity should not be relied upon. Neither should you rely on
- atomic variable assignment (since this in turn depends on
- dictionaries).
- </p>
-
- <p>
- Use the Queue module's <code>Queue</code> data type as the preferred
- way to
- communicate data between threads. Otherwise, use the threading
- module and its locking primitives. Learn about the proper use
- of condition variables so you can use
- <code>threading.Condition</code> instead of using lower-level
- locks.
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Power_Features" id="Power_Features">Power Features</A></H3>
-<SPAN class="link_button" id="link-Power_Features__button" name="link-Power_Features__button"><A href="?showone=Power_Features#Power_Features">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Power_Features')" name="Power_Features__button" id="Power_Features__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Avoid these features.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Power_Features__body" id="Power_Features__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_section">Definition: </SPAN> Python is an extremely flexible language and
- gives you many fancy features such as metaclasses, access to bytecode,
- on-the-fly compilation, dynamic inheritance, object reparenting,
- import hacks, reflection, modification of system internals,
- etc.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Pros: </SPAN> These are powerful language features. They can
- make your code more compact.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Cons: </SPAN> It's very tempting to use these "cool" features
- when they're not absolutely necessary. It's harder to read,
- understand, and debug code that's using unusual features
- underneath. It doesn't seem that way at first (to the original
- author), but when revisiting the code, it tends to be more
- difficult than code that is longer but is straightforward.
- </P>
- <P class="">
-<SPAN class="stylepoint_section">Decision: </SPAN>
- Avoid these features in
- your code.
- </P>
- </DIV></DIV>
- </DIV>
- </DIV>
- <DIV class="">
-<H2 name="Python_Style_Rules" id="Python_Style_Rules">Python Style Rules</H2>
- <DIV class="">
-<H3><A name="Semicolons" id="Semicolons">Semicolons</A></H3>
-<SPAN class="link_button" id="link-Semicolons__button" name="link-Semicolons__button"><A href="?showone=Semicolons#Semicolons">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Semicolons')" name="Semicolons__button" id="Semicolons__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Do not terminate your lines with semi-colons and do not use
- semi-colons to put two commands on the same line.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Semicolons__body" id="Semicolons__body" style="display: none">
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Line_length" id="Line_length">Line length</A></H3>
-<SPAN class="link_button" id="link-Line_length__button" name="link-Line_length__button"><A href="?showone=Line_length#Line_length">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Line_length')" name="Line_length__button" id="Line_length__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Maximum line length is <em>80 characters</em>.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Line_length__body" id="Line_length__body" style="display: none">
- <p>
- Exceptions:
- <ul>
- <li>Long import statements.</li>
- <li>URLs in comments.</li>
-
- </ul>
- </p>
-
- <p>
- Do not use backslash line continuation.
- </p>
-
- <p>
- Make use of Python's
-
- <a HREF="https://docs.python.org/reference/lexical_analysis.html#implicit-line-joining">implicit
- line joining inside parentheses, brackets and braces</a>.
- If necessary, you can add an extra pair of parentheses around an
- expression.
- </p>
-
-
- <DIV class=""><PRE>Yes: foo_bar(self, width, height, color='black', design=None, x='foo',
- emphasis=None, highlight=0)
-
- if (width == 0 and height == 0 and
- color == 'red' and emphasis == 'strong'):</PRE></DIV>
-
-
- <p>
- When a literal string won't fit on a single line, use parentheses for
- implicit line joining.
- </p>
-
- <DIV class=""><PRE>
-<span class="external"></span>x = ('This will build a very long long '
-<span class="external"></span> 'long long long long long long string')</PRE></DIV>
-
- <p>
- Within comments, put long URLs on their own line if necessary.
- </p>
-
- <DIV class=""><PRE>Yes: <span class="external"></span># See details at
- <span class="external"></span># https://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html</PRE></DIV>
-
- <DIV class=""><PRE class="badcode">No: <span class="external"></span># See details at
- <span class="external"></span># https://www.example.com/us/developer/documentation/api/content/\
- <span class="external"></span># v2.0/csv_file_name_extension_full_specification.html</PRE></DIV>
-
- <p>
- Make note of the indentation of the elements in the line
- continuation examples above; see the
- <a HREF="#Indentation">indentation</a>
- section for explanation.
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Parentheses" id="Parentheses">Parentheses</A></H3>
-<SPAN class="link_button" id="link-Parentheses__button" name="link-Parentheses__button"><A href="?showone=Parentheses#Parentheses">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Parentheses')" name="Parentheses__button" id="Parentheses__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use parentheses sparingly.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Parentheses__body" id="Parentheses__body" style="display: none">
- <p>
- Do not use them in return statements or conditional statements unless
- using parentheses for implied line continuation. (See above.)
- It is however fine to use parentheses around tuples.
- </p>
-
-<DIV class=""><PRE>Yes: <span class="external"></span>if foo:
- <span class="external"> </span>bar()
- <span class="external"></span>while x:
- <span class="external"> </span>x = bar()
- <span class="external"></span>if x and y:
- <span class="external"> </span>bar()
- <span class="external"></span>if not x:
- <span class="external"> </span>bar()
- <span class="external"></span>return foo
- <span class="external"></span>for (x, y) in dict.items(): ...</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>if (x):
- <span class="external"> </span>bar()
- <span class="external"></span>if not(x):
- <span class="external"> </span>bar()
- <span class="external"></span>return (foo)</PRE></DIV>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Indentation" id="Indentation">Indentation</A></H3>
-<SPAN class="link_button" id="link-Indentation__button" name="link-Indentation__button"><A href="?showone=Indentation#Indentation">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Indentation')" name="Indentation__button" id="Indentation__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Indent your code blocks with <em>4 spaces</em>.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Indentation__body" id="Indentation__body" style="display: none">
- <p>
- Never use tabs or mix tabs and spaces.
- In cases of implied line continuation, you should align wrapped elements
- either vertically, as per the examples in the
- <a HREF="#Line_length">line length</a> section; or using a hanging
- indent of 4 spaces, in which case there should be no argument on
- the first line.
- </p>
-
-
-<DIV class=""><PRE>Yes: # Aligned with opening delimiter
- foo = long_function_name(var_one, var_two,
- var_three, var_four)
-
- # Aligned with opening delimiter in a dictionary
- foo = {
- long_dictionary_key: value1 +
- value2,
- ...
- }
-
- # 4-space hanging indent; nothing on first line
- foo = long_function_name(
- var_one, var_two, var_three,
- var_four)
-
- # 4-space hanging indent in a dictionary
- foo = {
- long_dictionary_key:
- long_dictionary_value,
- ...
- }</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span># Stuff on first line forbidden
- <span class="external"></span>foo = long_function_name(var_one, var_two,
- <span class="external"></span> var_three, var_four)
-
- <span class="external"></span># 2-space hanging indent forbidden
- <span class="external"></span>foo = long_function_name(
- <span class="external"></span> var_one, var_two, var_three,
- <span class="external"></span> var_four)
-
- <span class="external"></span># No hanging indent in a dictionary
- <span class="external"></span>foo = {
- <span class="external"></span> long_dictionary_key:
- <span class="external"> </span>long_dictionary_value,
- <span class="external"> </span>...
- <span class="external"></span>}</PRE></DIV>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Blank_Lines" id="Blank_Lines">Blank Lines</A></H3>
-<SPAN class="link_button" id="link-Blank_Lines__button" name="link-Blank_Lines__button"><A href="?showone=Blank_Lines#Blank_Lines">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Blank_Lines')" name="Blank_Lines__button" id="Blank_Lines__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Two blank lines between top-level definitions, one blank line
- between method definitions.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Blank_Lines__body" id="Blank_Lines__body" style="display: none">
- <p>
- Two blank lines between top-level definitions, be they function
- or class definitions. One blank line between method definitions
- and between the <code>class</code> line and the first method.
- Use single blank lines as you judge appropriate within functions or
- methods.
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Whitespace" id="Whitespace">Whitespace</A></H3>
-<SPAN class="link_button" id="link-Whitespace__button" name="link-Whitespace__button"><A href="?showone=Whitespace#Whitespace">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Whitespace')" name="Whitespace__button" id="Whitespace__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Follow standard typographic rules for the use of spaces around
- punctuation.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Whitespace__body" id="Whitespace__body" style="display: none">
- <p>
- No whitespace inside parentheses, brackets or braces.
- </p>
-<DIV class=""><PRE>Yes: <span class="external"></span>spam(ham[1], {eggs: 2}, [])</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>spam( ham[ 1 ], { eggs: 2 }, [ ] )</PRE></DIV>
- <p>
- No whitespace before a comma, semicolon, or colon. Do use
- whitespace after a comma, semicolon, or colon except at the end
- of the line.
- </p>
-<DIV class=""><PRE>Yes: <span class="external"></span>if x == 4:
- <span class="external"> </span>print x, y
- <span class="external"></span>x, y = y, x</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>if x == 4 :
- <span class="external"> </span>print x , y
- <span class="external"></span>x , y = y , x</PRE></DIV>
- <p>
- No whitespace before the open paren/bracket that starts an argument list,
- indexing or slicing.
- </p>
- <DIV class=""><PRE>Yes: <span class="external"></span>spam(1)</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>spam (1)</PRE></DIV>
-<DIV class=""><PRE>Yes: <span class="external"></span>dict['key'] = list[index]</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>dict ['key'] = list [index]</PRE></DIV>
-
- <p>
- Surround binary operators with a single space on either side for
- assignment (<code>=</code>), comparisons (<code>==, <, >, !=,
- <>, <=, >=, in, not in, is, is not</code>), and Booleans
- (<code>and, or, not</code>). Use your better judgment for the
- insertion of spaces around arithmetic operators but always be
- consistent about whitespace on either side of a binary operator.
- </p>
-<DIV class=""><PRE>Yes: <span class="external"></span>x == 1</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>x<1</PRE></DIV>
- <p>
- Don't use spaces around the '=' sign when used to indicate a
- keyword argument or a default parameter value.
- </p>
-<DIV class=""><PRE>Yes: <span class="external"></span>def complex(real, imag=0.0): return magic(r=real, i=imag)</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>def complex(real, imag = 0.0): return magic(r = real, i = imag)</PRE></DIV>
-
- <p>
- Don't use spaces to vertically align tokens on consecutive lines, since it
- becomes a maintenance burden (applies to <code>:</code>, <code>#</code>,
- <code>=</code>, etc.):
- </p>
-<DIV class=""><PRE>Yes:
- foo = 1000 # comment
- long_name = 2 # comment that should not be aligned
-
- dictionary = {
- 'foo': 1,
- 'long_name': 2,
- }</PRE></DIV>
-<DIV class=""><PRE class="badcode">No:
- foo = 1000 # comment
- long_name = 2 # comment that should not be aligned
-
- dictionary = {
- 'foo' : 1,
- 'long_name': 2,
- }</PRE></DIV>
-
-
- </DIV></DIV>
- </DIV>
-
- <a name="Python_Interpreter"></a>
- <DIV class="">
-<H3><A name="Shebang_Line" id="Shebang_Line">Shebang Line</A></H3>
-<SPAN class="link_button" id="link-Shebang_Line__button" name="link-Shebang_Line__button"><A href="?showone=Shebang_Line#Shebang_Line">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Shebang_Line')" name="Shebang_Line__button" id="Shebang_Line__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Most <code>.py</code> files do not need to start with a
- <code>#!</code> line. Start the main file of a
- program with
- <code>#!/usr/bin/env python</code> with an optional single digit
- <code>2</code> or <code>3</code> suffix.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Shebang_Line__body" id="Shebang_Line__body" style="display: none">
-
- <p>
- This line is used by the kernel to find the Python interpreter, but is
- ignored by Python when importing modules. It is only necessary on a
- file that will be executed directly.
- </p>
- </DIV></DIV>
- </DIV>
-
- <DIV class="">
-<H3><A name="Comments" id="Comments">Comments</A></H3>
-<SPAN class="link_button" id="link-Comments__button" name="link-Comments__button"><A href="?showone=Comments#Comments">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Comments')" name="Comments__button" id="Comments__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Be sure to use the right style for module, function, method and in-line
- comments.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Comments__body" id="Comments__body" style="display: none">
-
- <P class="">
-<SPAN class="stylepoint_subsection">Doc Strings</SPAN>
-
- <p>
- Python has a unique commenting style using doc strings. A doc
- string is a string that is the first statement in a package,
- module, class or function. These strings can be extracted
- automatically through the <code>__doc__</code> member of the
- object and are used by <code>pydoc</code>. (Try running
- <code>pydoc</code> on your module to see how it looks.) We
- always use the three double-quote <code>"""</code> format for doc strings
- (per <a href="https://www.python.org/dev/peps/pep-0257/">PEP 257</a>).
- A doc string should be organized as a
- summary line (one physical line) terminated by a period,
- question mark, or exclamation point, followed by a blank line,
- followed by the rest of the doc string starting at the same
- cursor position as the first quote of the first line. There are
- more formatting guidelines for doc strings below.
- </p>
-
- </P>
- <P class="">
-<SPAN class="stylepoint_subsection">Modules</SPAN>
-
-
-
- <p>
- Every file should contain license boilerplate.
- Choose the appropriate boilerplate for the license used by the project
- (for example, Apache 2.0, BSD, LGPL, GPL)
- </p>
- </P>
- <P class="">
-<SPAN class="stylepoint_subsection">Functions and Methods</SPAN>
-
- <p>
- As used in this section "function" applies to methods, function, and
- generators.
- </p>
-
- <p>
- A function must have a docstring, unless it meets all of the following
- criteria:
- <ul>
- <li>not externally visible</li>
- <li>very short</li>
- <li>obvious</li>
- </ul>
- </p>
-
- <p>
- A docstring should give enough information to write a call to the function
- without reading the function's code. A docstring should describe the
- function's calling syntax and its semantics, not its implementation. For
- tricky code, comments alongside the code are more appropriate than using
- docstrings.
- </p>
-
- <p>
- Certain aspects of a function should be documented in special sections,
- listed below. Each section begins with a heading line, which ends with a
- colon. Sections should be indented two spaces, except for the heading.
- </p>
-
- <dl>
- <dt>Args:</dt>
- <dd>
- List each parameter by name. A description should follow the name, and
- be separated by a colon and a space. If the description is too long to
- fit on a single 80-character line, use a hanging indent of 2 or 4 spaces
- (be consistent with the rest of the file).
-
- <p>
- The description should mention required type(s) and the meaning of
- the argument.
- </p>
-
- <p>
- If a function accepts *foo (variable length argument lists) and/or
- **bar (arbitrary keyword arguments), they should be listed as *foo and
- **bar.
- </p>
- </dd>
-
- <dt>Returns: (or Yields: for generators)</dt>
- <dd>
- Describe the type and semantics of the return value. If the function
- only returns None, this section is not required.
- </dd>
-
- <dt>Raises:</dt>
- <dd>
- List all exceptions that are relevant to the interface.
- </dd>
- </dl>
-
- <DIV class=""><PRE>
-<span class="external"></span>def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
- <span class="external"> </span>"""Fetches rows from a Bigtable.
-
- <span class="external"> </span>Retrieves rows pertaining to the given keys from the Table instance
- <span class="external"> </span>represented by big_table. Silly things may happen if
- <span class="external"> </span>other_silly_variable is not None.
-
- <span class="external"> </span>Args:
- <span class="external"> </span>big_table: An open Bigtable Table instance.
- <span class="external"> </span>keys: A sequence of strings representing the key of each table row
- <span class="external"> </span> to fetch.
- <span class="external"> </span>other_silly_variable: Another optional variable, that has a much
- <span class="external"> </span> longer name than the other args, and which does nothing.
-
- <span class="external"> </span>Returns:
- <span class="external"> </span>A dict mapping keys to the corresponding table row data
- <span class="external"> </span>fetched. Each row is represented as a tuple of strings. For
- <span class="external"> </span>example:
-
- <span class="external"> </span>{'Serak': ('Rigel VII', 'Preparer'),
- <span class="external"> </span> 'Zim': ('Irk', 'Invader'),
- <span class="external"> </span> 'Lrrr': ('Omicron Persei 8', 'Emperor')}
-
- <span class="external"> </span>If a key from the keys argument is missing from the dictionary,
- <span class="external"> </span>then that row was not found in the table.
-
- <span class="external"> </span>Raises:
- <span class="external"> </span>IOError: An error occurred accessing the bigtable.Table object.
- <span class="external"> </span>"""
- <span class="external"> </span>pass
-<span class="external"></span>
-</PRE></DIV>
- </P>
- <P class="">
-<SPAN class="stylepoint_subsection">Classes</SPAN>
-
- <p>
- Classes should have a doc string below the class definition describing
- the class. If your class has public attributes, they should be documented
- here in an Attributes section and follow the same formatting as a
- function's Args section.
- </p>
-
- <DIV class=""><PRE>
-<span class="external"></span>class SampleClass(object):
- <span class="external"> </span>"""Summary of class here.
-
- <span class="external"> </span>Longer class information....
- <span class="external"> </span>Longer class information....
-
- <span class="external"> </span>Attributes:
- <span class="external"> </span>likes_spam: A boolean indicating if we like SPAM or not.
- <span class="external"> </span>eggs: An integer count of the eggs we have laid.
- <span class="external"> </span>"""
-
- <span class="external"> </span>def __init__(self, likes_spam=False):
- <span class="external"> </span>"""Inits SampleClass with blah."""
- <span class="external"> </span>self.likes_spam = likes_spam
- <span class="external"> </span>self.eggs = 0
-
- <span class="external"> </span>def public_method(self):
- <span class="external"> </span>"""Performs operation blah."""
-<span class="external"></span>
-</PRE></DIV>
-
- </P>
- <P class="">
-<SPAN class="stylepoint_subsection">Block and Inline Comments</SPAN>
-
- <p>
- The final place to have comments is in tricky parts of the
- code. If you're going to have to explain it at the next
- <a HREF="https://en.wikipedia.org/wiki/Code_review">code review</a>,
- you should comment it now. Complicated operations get a few lines of
- comments before the operations
- commence. Non-obvious ones get comments at the end of the line.
- </p>
-
- <DIV class=""><PRE>
-<span class="external"></span># We use a weighted dictionary search to find out where i is in
-<span class="external"></span># the array. We extrapolate position based on the largest num
-<span class="external"></span># in the array and the array size and then do binary search to
-<span class="external"></span># get the exact number.
-
-<span class="external"></span>if i & (i-1) == 0: # true iff i is a power of 2
-<span class="external"></span>
-</PRE></DIV>
-
- <p>
- To improve legibility, these comments should be at least 2 spaces away
- from the code.
- </p>
-
- <p>
- On the other hand, never describe the code. Assume the person
- reading the code knows Python (though not what you're trying to
- do) better than you do.
- </p>
-
- <DIV class=""><PRE class="badcode">
-<span class="external"></span># BAD COMMENT: Now go through the b array and make sure whenever i occurs
-<span class="external"></span># the next element is i+1
-<span class="external"></span>
-</PRE></DIV>
-
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Classes" id="Classes">Classes</A></H3>
-<SPAN class="link_button" id="link-Classes__button" name="link-Classes__button"><A href="?showone=Classes#Classes">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Classes')" name="Classes__button" id="Classes__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- If a class inherits from no other base classes, explicitly inherit
- from <code>object</code>. This also applies to nested classes.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Classes__body" id="Classes__body" style="display: none">
- <DIV class=""><PRE>Yes: <span class="external"></span>class SampleClass(object):
- <span class="external"> </span>pass
-
-
- <span class="external"></span>class OuterClass(object):
-
- <span class="external"> </span>class InnerClass(object):
- <span class="external"> </span>pass
-
-
- <span class="external"></span>class ChildClass(ParentClass):
- <span class="external"> </span>"""Explicitly inherits from another class already."""
-<span class="external"></span>
-</PRE></DIV>
- <DIV class=""><PRE class="badcode">No: <span class="external"></span>class SampleClass:
- <span class="external"> </span>pass
-
-
- <span class="external"></span>class OuterClass:
-
- <span class="external"> </span>class InnerClass:
- <span class="external"> </span>pass
-<span class="external"></span>
-</PRE></DIV>
- <p>Inheriting from <code>object</code> is needed to make properties work
- properly, and it will protect your code from one particular potential
- incompatibility with Python 3000. It also defines
- special methods that implement the default semantics of objects including
- <code>__new__</code>, <code>__init__</code>, <code>__delattr__</code>,
- <code>__getattribute__</code>, <code>__setattr__</code>,
- <code>__hash__</code>, <code>__repr__</code>, and <code>__str__</code>.
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Strings" id="Strings">Strings</A></H3>
-<SPAN class="link_button" id="link-Strings__button" name="link-Strings__button"><A href="?showone=Strings#Strings">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Strings')" name="Strings__button" id="Strings__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use the <code>format</code> method or the <code>%</code> operator for
- formatting strings, even when the parameters are all strings. Use your
- best judgement to decide between <code>+</code> and <code>%</code>
- (or <code>format</code>) though.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Strings__body" id="Strings__body" style="display: none">
-
-<DIV class=""><PRE>Yes: <span class="external"></span>x = a + b
- <span class="external"></span>x = '%s, %s!' % (imperative, expletive)
- <span class="external"></span>x = '{}, {}!'.format(imperative, expletive)
- <span class="external"></span>x = 'name: %s; score: %d' % (name, n)
- <span class="external"></span>x = 'name: {}; score: {}'.format(name, n)</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>x = '%s%s' % (a, b) # use + in this case
- <span class="external"></span>x = '{}{}'.format(a, b) # use + in this case
- <span class="external"></span>x = imperative + ', ' + expletive + '!'
- <span class="external"></span>x = 'name: ' + name + '; score: ' + str(n)</PRE></DIV>
-
- <p>
- Avoid using the <code>+</code> and <code>+=</code> operators to
- accumulate a string within a loop. Since strings are immutable, this
- creates unnecessary temporary objects and results in quadratic rather
- than linear running time. Instead, add each substring to a list
- and <code>''.join</code> the list after the loop terminates (or, write
- each substring to a <code>io.BytesIO</code> buffer).
- </p>
-
-<DIV class=""><PRE>Yes: <span class="external"></span>items = ['<table>']
- <span class="external"></span>for last_name, first_name in employee_list:
- <span class="external"> </span>items.append('<tr><td>%s, %s</td></tr>' % (last_name, first_name))
- <span class="external"></span>items.append('</table>')
- <span class="external"></span>employee_table = ''.join(items)</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>employee_table = '<table>'
- <span class="external"></span>for last_name, first_name in employee_list:
- <span class="external"> </span>employee_table += '<tr><td>%s, %s</td></tr>' % (last_name, first_name)
- <span class="external"></span>employee_table += '</table>'</PRE></DIV>
-
- <p>
- Be consistent with your choice of string quote character within a file.
- Pick <code>'</code> or <code>"</code> and stick with it.
- It is okay to use the other quote character on a string to avoid the
- need to <code>\</code> escape within the string.
- GPyLint enforces this.
- </p>
-
-<DIV class=""><PRE>Ye<span class="external"></span>s:
- <span class="external"></span>Python('Why are you hiding your eyes?')
- <span class="external"></span>Gollum("I'm scared of lint errors.")
- <span class="external"></span>Narrator('"Good!" thought a happy Python reviewer.')</PRE></DIV>
-<DIV class=""><PRE class="badcode">No<span class="external"></span>:
- <span class="external"></span>Python("Why are you hiding your eyes?")
- <span class="external"></span>Gollum('The lint. It burns. It burns us.')
- <span class="external"></span>Gollum("Always the great lint. Watching. Watching.")</PRE></DIV>
-
- <p>
- Prefer <code>"""</code> for multi-line strings rather than
- <code>'''</code>. Projects may choose to use <code>'''</code> for
- all non-docstring multi-line strings if and only if they also use
- <code>'</code> for regular strings.
- Doc strings must use <code>"""</code> regardless.
- Note that it is often cleaner to
- use implicit line joining since multi-line strings do
- not flow with the indentation of the rest of the program:
- </p>
-
-<DIV class=""><PRE>Ye<span class="external"></span>s:
- <span class="external"></span>print ("This is much nicer.\n"
- <span class="external"></span> "Do it this way.\n")</PRE></DIV>
-<DIV class=""><PRE class="badcode"> No<span class="external"></span>:
- <span class="external"></span>print """This is pretty ugly.
-Don'<span class="external"></span>t do this.
-"""<span class="external"></span>
-</PRE></DIV>
-
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Files_and_Sockets" id="Files_and_Sockets">Files and Sockets</A></H3>
-<SPAN class="link_button" id="link-Files_and_Sockets__button" name="link-Files_and_Sockets__button"><A href="?showone=Files_and_Sockets#Files_and_Sockets">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Files_and_Sockets')" name="Files_and_Sockets__button" id="Files_and_Sockets__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Explicitly close files and sockets when done with them.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Files_and_Sockets__body" id="Files_and_Sockets__body" style="display: none">
- <p>
- Leaving files, sockets or other file-like objects open unnecessarily
- has many downsides, including:
-
- <ul>
- <li>They may consume limited system resources, such as file
- descriptors. Code that deals with many such objects may exhaust
- those resources unnecessarily if they're not returned to the
- system promptly after use.</li>
- <li>Holding files open may prevent other actions being performed on
- them, such as moves or deletion.</li>
- <li>Files and sockets that are shared throughout a program may
- inadvertantly be read from or written to after logically being
- closed. If they are actually closed, attempts to read or write
- from them will throw exceptions, making the problem known
- sooner.</li>
- </ul>
- </p>
-
- <p>
- Furthermore, while files and sockets are automatically closed when the
- file object is destructed, tying the life-time of the file object to
- the state of the file is poor practice, for several reasons:
-
- <ul>
- <li>There are no guarantees as to when the runtime will actually run
- the file's destructor. Different Python implementations use
- different memory management techniques, such as delayed Garbage
- Collection, which may increase the object's lifetime arbitrarily
- and indefinitely.</li>
- <li>Unexpected references to the file may keep it around longer than
- intended (e.g. in tracebacks of exceptions, inside globals,
- etc).</li>
- </ul>
- </p>
-
- <p>
- The preferred way to manage files is using the <a HREF="https://docs.python.org/reference/compound_stmts.html#the-with-statement">
- "with" statement</a>:
- </p>
-
-<DIV class=""><PRE>
-<span class="external"></span>with open("hello.txt") as hello_file:
- <span class="external"> </span>for line in hello_file:
- <span class="external"> </span>print line</PRE></DIV>
-
- <p>
- For file-like objects that do not support the "with" statement, use
- contextlib.closing():
- </p>
-
-<DIV class=""><PRE>
-<span class="external"></span>import contextlib
-
-<span class="external"></span>with contextlib.closing(urllib.urlopen("https://www.python.org/")) as front_page:
- <span class="external"> </span>for line in front_page:
- <span class="external"> </span>print line</PRE></DIV>
-
- <p>
- Legacy AppEngine code using Python 2.5 may enable the "with" statement
- using "from __future__ import with_statement".
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="TODO_Comments" id="TODO_Comments">TODO Comments</A></H3>
-<SPAN class="link_button" id="link-TODO_Comments__button" name="link-TODO_Comments__button"><A href="?showone=TODO_Comments#TODO_Comments">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('TODO_Comments')" name="TODO_Comments__button" id="TODO_Comments__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Use <code>TODO</code> comments for code that is temporary, a
- short-term solution, or good-enough but not perfect.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="TODO_Comments__body" id="TODO_Comments__body" style="display: none">
- <p>
- <code>TODO</code>s should include the string <code>TODO</code> in
- all caps, followed by the
-
- name, e-mail address, or other
- identifier
- of the person who can best provide context about the problem
- referenced by the <code>TODO</code>,
- in parentheses. A colon is optional. A comment explaining what there
- is to do is required. The main purpose is to have
- a consistent <code>TODO</code> format that can be searched to find the
- person who can provide more details upon request. A
- <code>TODO</code> is not a commitment that the person referenced
- will fix the problem. Thus when you create a <code>TODO</code>, it is
- almost always your
-
- name
- that is given.
- </p>
-
- <DIV class=""><PRE># TODO(kl@gmail.com): Use a "*" here for string repetition.
-# TODO(Zeke) Change this to use relations.</PRE></DIV>
- <p>
- If your <code>TODO</code> is of the form "At a future date do
- something" make sure that you either include a very specific
- date ("Fix by November 2009") or a very specific event
- ("Remove this code when all clients can handle XML responses.").
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Imports_formatting" id="Imports_formatting">Imports formatting</A></H3>
-<SPAN class="link_button" id="link-Imports_formatting__button" name="link-Imports_formatting__button"><A href="?showone=Imports_formatting#Imports_formatting">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Imports_formatting')" name="Imports_formatting__button" id="Imports_formatting__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Imports should be on separate lines.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Imports_formatting__body" id="Imports_formatting__body" style="display: none">
- <p>
- E.g.:
- </p>
-
-<DIV class=""><PRE>Yes: <span class="external"></span>import os
- <span class="external"></span>import sys</PRE></DIV>
-<DIV class=""><PRE class="badcode">No: <span class="external"></span>import os, sys</PRE></DIV>
- <p>
- Imports are always put at the top of the file, just after any
- module comments and doc strings and before module globals and
- constants. Imports should be grouped with the order being most generic
- to least generic:
- </p>
- <ul>
- <li>standard library imports</li>
- <li>third-party imports</li>
-
- <li>application-specific imports</li>
- </ul>
- <p>
- Within each grouping, imports should be sorted lexicographically,
- ignoring case, according to each module's full package path.
- </p>
- <DIV class=""><PRE>
-<span class="external"></span>import foo
-<span class="external"></span>from foo import bar
-<span class="external"></span>from foo.bar import baz
-<span class="external"></span>from foo.bar import Quux
-<span class="external"></span>from Foob import ar</PRE></DIV>
-
-
-
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Statements" id="Statements">Statements</A></H3>
-<SPAN class="link_button" id="link-Statements__button" name="link-Statements__button"><A href="?showone=Statements#Statements">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Statements')" name="Statements__button" id="Statements__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Generally only one statement per line.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Statements__body" id="Statements__body" style="display: none">
- <p>
- However, you may put the
- result of a test on the same line as the test only if the entire
- statement fits on one line. In particular, you can never do so
- with <code>try</code>/<code>except</code> since the
- <code>try</code> and <code>except</code> can't both fit on the
- same line, and you can only do so with an <code>if</code> if
- there is no <code>else</code>.
- </p>
-
- <DIV class=""><PRE>Ye<span class="external"></span>s:
-
- <span class="external"></span>if foo: bar(foo)</PRE></DIV>
-<DIV class=""><PRE class="badcode">No<span class="external"></span>:
-
- <span class="external"></span>if foo: bar(foo)
- <span class="external"></span>else: baz(foo)
-
- <span class="external"></span>try: bar(foo)
- <span class="external"></span>except ValueError: baz(foo)
-
- <span class="external"></span>try:
- <span class="external"> </span>bar(foo)
- <span class="external"></span>except ValueError: baz(foo)
-<span class="external"></span>
-</PRE></DIV>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Access_Control" id="Access_Control">Access Control</A></H3>
-<SPAN class="link_button" id="link-Access_Control__button" name="link-Access_Control__button"><A href="?showone=Access_Control#Access_Control">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Access_Control')" name="Access_Control__button" id="Access_Control__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- If an accessor function would be trivial you should use public variables
- instead of accessor functions to avoid the extra cost of function
- calls in Python. When more functionality is added you can use
- <code>property</code> to keep the syntax consistent.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Access_Control__body" id="Access_Control__body" style="display: none">
- <p>
- On the other hand, if access is more complex, or the cost of accessing
- the variable is significant, you should use function calls (following the
- <a HREF="#naming">Naming</a> guidelines) such as <code>get_foo()</code>
- and <code>set_foo()</code>. If the past behavior allowed access through a
- property, do not bind the new accessor functions to the property. Any
- code still attempting to access the variable by the old method should
- break visibly so they are made aware of the change in complexity.
- </p>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Naming" id="Naming">Naming</A></H3>
-<SPAN class="link_button" id="link-Naming__button" name="link-Naming__button"><A href="?showone=Naming#Naming">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Naming')" name="Naming__button" id="Naming__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- <code>module_name, package_name, ClassName,
- method_name, ExceptionName,
- function_name, GLOBAL_CONSTANT_NAME,
- global_var_name, instance_var_name, function_parameter_name,
- local_var_name.</code>
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Naming__body" id="Naming__body" style="display: none">
- <P class="">
-<SPAN class="stylepoint_subsection">Names to Avoid</SPAN>
-
- <ul>
- <li>single character names except for counters or iterators</li>
- <li>dashes (<code>-</code>) in any package/module name</li>
- <li>
-<code>__double_leading_and_trailing_underscore__</code> names
- (reserved by Python)</li>
- </ul>
-
- </P>
- <P class="">
-<SPAN class="stylepoint_subsection">Naming Convention</SPAN>
-
- <ul>
- <li>
- "Internal" means internal to a module or protected
- or private within a class.</li>
- <li>
- Prepending a single underscore (<code>_</code>) has some
- support for protecting module variables and functions (not included
- with <code>import * from</code>). Prepending a double underscore
- (<code>__</code>) to an instance variable or method
- effectively serves to make the variable or method private to its class
- (using name mangling).</li>
- <li>
- Place related classes and top-level functions together in a
- module. Unlike Java,
- there is no need to limit yourself to one class per module.</li>
- <li>
- Use CapWords for class names, but lower_with_under.py for module names.
- Although there are many existing modules named CapWords.py, this is now
- discouraged because it's confusing when the module happens to be
- named after a class. ("wait -- did I write
- <code>import StringIO</code> or <code>from StringIO import
- StringIO</code>?")</li>
- </ul>
-
- </P>
- <P class="">
-<SPAN class="stylepoint_subsection">Guidelines derived from Guido's Recommendations</SPAN>
-
- <table rules="all" border="1" cellspacing="2" cellpadding="2">
-
- <tr>
- <th>Type</th>
- <th>Public</th>
- <th>Internal</th>
- </tr>
-
-
-
- <tr>
- <td>Packages</td>
- <td><code>lower_with_under</code></td>
- <td></td>
- </tr>
-
- <tr>
- <td>Modules</td>
- <td><code>lower_with_under</code></td>
- <td><code>_lower_with_under</code></td>
- </tr>
-
- <tr>
- <td>Classes</td>
- <td><code>CapWords</code></td>
- <td><code>_CapWords</code></td>
- </tr>
-
- <tr>
- <td>Exceptions</td>
- <td><code>CapWords</code></td>
- <td></td>
- </tr>
-
-
-
- <tr>
- <td>Functions</td>
- <td><code>lower_with_under()</code></td>
- <td><code>_lower_with_under()</code></td>
- </tr>
-
- <tr>
- <td>Global/Class Constants</td>
- <td><code>CAPS_WITH_UNDER</code></td>
- <td><code>_CAPS_WITH_UNDER</code></td>
- </tr>
-
- <tr>
- <td>Global/Class Variables</td>
- <td><code>lower_with_under</code></td>
- <td><code>_lower_with_under</code></td>
- </tr>
-
- <tr>
- <td>Instance Variables</td>
- <td><code>lower_with_under</code></td>
- <td><code>_lower_with_under (protected) or __lower_with_under (private)</code></td>
- </tr>
-
-
-
- <tr>
- <td>Method Names</td>
- <td><code>lower_with_under()</code></td>
- <td><code>_lower_with_under() (protected) or __lower_with_under() (private)</code></td>
- </tr>
-
- <tr>
- <td>Function/Method Parameters</td>
- <td><code>lower_with_under</code></td>
- <td></td>
- </tr>
-
- <tr>
- <td>Local Variables</td>
- <td><code>lower_with_under</code></td>
- <td></td>
- </tr>
-
-
- </table>
-
-
- </P>
- </DIV></DIV>
- </DIV>
- <DIV class="">
-<H3><A name="Main" id="Main">Main</A></H3>
-<SPAN class="link_button" id="link-Main__button" name="link-Main__button"><A href="?showone=Main#Main">
- link
- </A></SPAN><SPAN class="showhide_button" onclick="javascript:ShowHideByName('Main')" name="Main__button" id="Main__button">▶</SPAN>
- <DIV style="display:inline;" class="">
- Even a file meant to be used as a script should be importable and a
- mere import should not have the side effect of executing the script's
- main functionality. The main functionality should be in a main()
- function.
- </DIV>
- <DIV class=""><DIV class="stylepoint_body" name="Main__body" id="Main__body" style="display: none">
- <p>
- In Python,
- <code>pydoc</code> as well as unit tests
- require modules to be importable. Your code should always check
- <code>if __name__ == '__main__'</code> before executing your
- main program so that the main program is not executed when the
- module is imported.
-
- </p>
-
-
-
-
-
-
-
- <DIV class=""><PRE>
-<span class="external"></span>def main():
- <span class="external"> </span>...
-
-<span class="external"></span>if __name__ == '__main__':
- <span class="external"> </span>main()
-<span class="external"></span>
-</PRE></DIV>
-
- <p>
- All code at the top level will be executed when the module is
- imported. Be careful not to call functions, create objects, or
- perform other operations that should not be executed when the
- file is being <code>pydoc</code>ed.
- </p>
- </DIV></DIV>
- </DIV>
- </DIV>
-
-<H2>Parting Words</H2>
- <p>
- <em>BE CONSISTENT</em>.
- </p>
-
- <p>
- If you're editing code, take a few minutes to look at the code
- around you and determine its style. If they use spaces around
- all their arithmetic operators, you should too. If their
- comments have little boxes of hash marks around them, make your
- comments have little boxes of hash marks around them too.
- </p>
-
- <p>
- The point of having style guidelines is to have a common vocabulary
- of coding so people can concentrate on what you're saying rather
- than on how you're saying it. We present global style rules here so
- people know the vocabulary, but local style is also important. If
- code you add to a file looks drastically different from the existing
- code around it, it throws readers out of their rhythm when they go to
- read it. Avoid this.
- </p>
-
-
-
-<p align="right">
-Revision 2.59
-</p>
-
-
-<address>
- Amit Patel<br>
- Antoine Picard<br>
- Eugene Jhong<br>
- Gregory P. Smith<br>
- Jeremy Hylton<br>
- Matt Smart<br>
- Mike Shields<br>
- Shane Liebling<br>
-</address>
-</BODY>
-</HTML>
diff --git a/pyguide.md b/pyguide.md
new file mode 100644
index 0000000..5d9938c
--- /dev/null
+++ b/pyguide.md
@@ -0,0 +1,3241 @@
+<!--
+AUTHORS:
+Prefer only GitHub-flavored Markdown in external text.
+See README.md for details.
+-->
+
+# Google Python Style Guide
+
+
+<a id="1-background"></a>
+
+<a id="background"></a>
+## 1 Background
+
+Python is the main dynamic language used at Google. This style guide is a list
+of *dos and don'ts* for Python programs.
+
+To help you format code correctly, we've created a [settings file for
+Vim](google_python_style.vim). For Emacs, the default settings should be fine.
+
+Many teams use the [yapf](https://github.com/google/yapf/)
+auto-formatter to avoid arguing over formatting.
+
+
+<a id="s2-python-language-rules"></a>
+<a id="2-python-language-rules"></a>
+
+<a id="python-language-rules"></a>
+## 2 Python Language Rules
+
+<a id="s2.1-lint"></a>
+<a id="21-lint"></a>
+
+<a id="lint"></a>
+### 2.1 Lint
+
+Run `pylint` over your code.
+
+<a id="s2.1.1-definition"></a>
+<a id="211-definition"></a>
+
+<a id="lint-definition"></a>
+#### 2.1.1 Definition
+
+`pylint` is a tool for finding bugs and style problems in Python source
+code. It finds problems that are typically caught by a compiler for less dynamic
+languages like C and C++. Because of the dynamic nature of Python, some
+warnings may be incorrect; however, spurious warnings should be fairly
+infrequent.
+
+<a id="s2.1.2-pros"></a>
+<a id="212-pros"></a>
+
+<a id="lint-pros"></a>
+#### 2.1.2 Pros
+
+Catches easy-to-miss errors like typos, using-vars-before-assignment, etc.
+
+<a id="s2.1.3-cons"></a>
+<a id="213-cons"></a>
+
+<a id="lint-cons"></a>
+#### 2.1.3 Cons
+
+`pylint` isn't perfect. To take advantage of it, we'll need to sometimes: a)
+Write around it b) Suppress its warnings or c) Improve it.
+
+<a id="s2.1.4-decision"></a>
+<a id="214-decision"></a>
+
+<a id="lint-decision"></a>
+#### 2.1.4 Decision
+
+Make sure you run `pylint` on your code.
+
+
+Suppress warnings if they are inappropriate so that other issues are not hidden.
+To suppress warnings, you can set a line-level comment:
+
+```python
+dict = 'something awful' # Bad Idea... pylint: disable=redefined-builtin
+```
+
+`pylint` warnings are each identified by symbolic name (`empty-docstring`)
+Google-specific warnings start with `g-`.
+
+If the reason for the suppression is not clear from the symbolic name, add an
+explanation.
+
+Suppressing in this way has the advantage that we can easily search for
+suppressions and revisit them.
+
+You can get a list of `pylint` warnings by doing:
+
+```shell
+pylint --list-msgs
+```
+
+To get more information on a particular message, use:
+
+```shell
+pylint --help-msg=C6409
+```
+
+Prefer `pylint: disable` to the deprecated older form `pylint: disable-msg`.
+
+Unused argument warnings can be suppressed by deleting the variables at the
+beginning of the function. Always include a comment explaining why you are
+deleting it. "Unused." is sufficient. For example:
+
+```python
+def viking_cafe_order(spam, beans, eggs=None):
+ del beans, eggs # Unused by vikings.
+ return spam + spam + spam
+```
+
+Other common forms of suppressing this warning include using '`_`' as the
+identifier for the unused argument, prefixing the argument name with
+'`unused_`', or assigning them to '`_`'. These forms are allowed but no longer
+encouraged. The first two break callers that pass arguments by name, while the
+last does not enforce that the arguments are actually unused.
+
+<a id="s2.2-imports"></a>
+<a id="22-imports"></a>
+
+<a id="imports"></a>
+### 2.2 Imports
+
+Use `import` statements for packages and modules only, not for individual
+classes or functions. Note that there is an explicit exemption for imports from
+the [typing module](#typing-imports).
+
+<a id="s2.2.1-definition"></a>
+<a id="221-definition"></a>
+
+<a id="imports-definition"></a>
+#### 2.2.1 Definition
+
+Reusability mechanism for sharing code from one module to another.
+
+<a id="s2.2.2-pros"></a>
+<a id="222-pros"></a>
+
+<a id="imports-pros"></a>
+#### 2.2.2 Pros
+
+The namespace management convention is simple. The source of each identifier is
+indicated in a consistent way; `x.Obj` says that object `Obj` is defined in
+module `x`.
+
+<a id="s2.2.3-cons"></a>
+<a id="223-cons"></a>
+
+<a id="imports-cons"></a>
+#### 2.2.3 Cons
+
+Module names can still collide. Some module names are inconveniently long.
+
+<a id="s2.2.4-decision"></a>
+<a id="224-decision"></a>
+
+<a id="imports-decision"></a>
+#### 2.2.4 Decision
+
+* Use `import x` for importing packages and modules.
+* Use `from x import y` where `x` is the package prefix and `y` is the module
+name with no prefix.
+* Use `from x import y as z` if two modules named `y` are to be imported or if
+`y` is an inconveniently long name.
+* Use `import y as z` only when `z` is a standard abbreviation (e.g., `np` for
+`numpy`).
+
+For example the module `sound.effects.echo` may be imported as follows:
+
+```python
+from sound.effects import echo
+...
+echo.EchoFilter(input, output, delay=0.7, atten=4)
+```
+
+Do not use relative names in imports. Even if the module is in the same package,
+use the full package name. This helps prevent unintentionally importing a
+package twice.
+
+Imports from the [typing module](#typing-imports) and the
+[six.moves module](https://six.readthedocs.io/#module-six.moves)
+are exempt from this rule.
+
+<a id="s2.3-packages"></a>
+<a id="23-packages"></a>
+
+<a id="packages"></a>
+### 2.3 Packages
+
+Import each module using the full pathname location of the module.
+
+<a id="s2.3.1-pros"></a>
+<a id="231-pros"></a>
+
+<a id="packages-pros"></a>
+#### 2.3.1 Pros
+
+Avoids conflicts in module names or incorrect imports due to the module search
+path not being what the author expected. Makes it easier to find modules.
+
+<a id="s2.3.2-cons"></a>
+<a id="232-cons"></a>
+
+<a id="packages-cons"></a>
+#### 2.3.2 Cons
+
+Makes it harder to deploy code because you have to replicate the package
+hierarchy. Not really a problem with modern deployment mechanisms.
+
+<a id="s2.3.3-decision"></a>
+<a id="233-decision"></a>
+
+<a id="packages-decision"></a>
+#### 2.3.3 Decision
+
+All new code should import each module by its full package name.
+
+Imports should be as follows:
+
+Yes:
+
+```python
+# Reference absl.flags in code with the complete name (verbose).
+import absl.flags
+from doctor.who import jodie
+
+FLAGS = absl.flags.FLAGS
+```
+
+```python
+# Reference flags in code with just the module name (common).
+from absl import flags
+from doctor.who import jodie
+
+FLAGS = flags.FLAGS
+```
+
+No: _(assume this file lives in `doctor/who/` where `jodie.py` also exists)_
+
+```python
+# Unclear what module the author wanted and what will be imported. The actual
+# import behavior depends on external factors controlling sys.path.
+# Which possible jodie module did the author intend to import?
+import jodie
+```
+
+The directory the main binary is located in should not be assumed to be in
+`sys.path` despite that happening in some environments. This being the case,
+code should assume that `import jodie` refers to a third party or top level
+package named `jodie`, not a local `jodie.py`.
+
+
+<a id="s2.4-exceptions"></a>
+<a id="24-exceptions"></a>
+
+<a id="exceptions"></a>
+### 2.4 Exceptions
+
+Exceptions are allowed but must be used carefully.
+
+<a id="s2.4.1-definition"></a>
+<a id="241-definition"></a>
+
+<a id="exceptions-definition"></a>
+#### 2.4.1 Definition
+
+Exceptions are a means of breaking out of the normal flow of control of a code
+block to handle errors or other exceptional conditions.
+
+<a id="s2.4.2-pros"></a>
+<a id="242-pros"></a>
+
+<a id="exceptions-pros"></a>
+#### 2.4.2 Pros
+
+The control flow of normal operation code is not cluttered by error-handling
+code. It also allows the control flow to skip multiple frames when a certain
+condition occurs, e.g., returning from N nested functions in one step instead of
+having to carry-through error codes.
+
+<a id="s2.4.3-cons"></a>
+<a id="243-cons"></a>
+
+<a id="exceptions-cons"></a>
+#### 2.4.3 Cons
+
+May cause the control flow to be confusing. Easy to miss error cases when making
+library calls.
+
+<a id="s2.4.4-decision"></a>
+<a id="244-decision"></a>
+
+<a id="exceptions-decision"></a>
+#### 2.4.4 Decision
+
+Exceptions must follow certain conditions:
+
+- Raise exceptions like this: `raise MyError('Error message')` or `raise
+ MyError()`. Do not use the two-argument form (`raise MyError, 'Error
+ message'`).
+
+- Make use of built-in exception classes when it makes sense. For example,
+ raise a `ValueError` to indicate a programming mistake like a violated
+ precondition (such as if you were passed a negative number but required a
+ positive one). Do not use `assert` statements for validating argument values
+ of a public API. `assert` is used to ensure internal correctness, not to
+ enforce correct usage nor to indicate that some unexpected event occurred.
+ If an exception is desired in the latter cases, use a raise statement. For
+ example:
+
+
+ ```python
+ Yes:
+ def connect_to_next_port(self, minimum):
+ """Connects to the next available port.
+
+ Args:
+ minimum: A port value greater or equal to 1024.
+
+ Returns:
+ The new minimum port.
+
+ Raises:
+ ConnectionError: If no available port is found.
+ """
+ if minimum < 1024:
+ # Note that this raising of ValueError is not mentioned in the doc
+ # string's "Raises:" section because it is not appropriate to
+ # guarantee this specific behavioral reaction to API misuse.
+ raise ValueError('Minimum port must be at least 1024, not %d.' % (minimum,))
+ port = self._find_next_open_port(minimum)
+ if not port:
+ raise ConnectionError('Could not connect to service on %d or higher.' % (minimum,))
+ assert port >= minimum, 'Unexpected port %d when minimum was %d.' % (port, minimum)
+ return port
+ ```
+
+ ```python
+ No:
+ def connect_to_next_port(self, minimum):
+ """Connects to the next available port.
+
+ Args:
+ minimum: A port value greater or equal to 1024.
+
+ Returns:
+ The new minimum port.
+ """
+ assert minimum >= 1024, 'Minimum port must be at least 1024.'
+ port = self._find_next_open_port(minimum)
+ assert port is not None
+ return port
+ ```
+
+- Libraries or packages may define their own exceptions. When doing so they
+ must inherit from an existing exception class. Exception names should end in
+ `Error` and should not introduce stutter (`foo.FooError`).
+
+- Never use catch-all `except:` statements, or catch `Exception` or
+ `StandardError`, unless you are
+
+ - re-raising the exception, or
+ - creating an isolation point in the program where exceptions are not
+ propagated but are recorded and suppressed instead, such as protecting a
+ thread from crashing by guarding its outermost block.
+
+ Python is very tolerant in this regard and `except:` will really catch
+ everything including misspelled names, sys.exit() calls, Ctrl+C interrupts,
+ unittest failures and all kinds of other exceptions that you simply don't
+ want to catch.
+
+- Minimize the amount of code in a `try`/`except` block. The larger the body
+ of the `try`, the more likely that an exception will be raised by a line of
+ code that you didn't expect to raise an exception. In those cases, the
+ `try`/`except` block hides a real error.
+
+- Use the `finally` clause to execute code whether or not an exception is
+ raised in the `try` block. This is often useful for cleanup, i.e., closing a
+ file.
+
+- When capturing an exception, use `as` rather than a comma. For example:
+
+
+ ```python
+ try:
+ raise Error()
+ except Error as error:
+ pass
+ ```
+
+<a id="s2.5-global-variables"></a>
+<a id="25-global-variables"></a>
+
+<a id="global-variables"></a>
+### 2.5 Global variables
+
+Avoid global variables.
+
+<a id="s2.5.1-definition"></a>
+<a id="251-definition"></a>
+
+<a id="global-variables-definition"></a>
+#### 2.5.1 Definition
+
+Variables that are declared at the module level or as class attributes.
+
+<a id="s2.5.2-pros"></a>
+<a id="252-pros"></a>
+
+<a id="global-variables-pros"></a>
+#### 2.5.2 Pros
+
+Occasionally useful.
+
+<a id="s2.5.3-cons"></a>
+<a id="253-cons"></a>
+
+<a id="global-variables-cons"></a>
+#### 2.5.3 Cons
+
+Has the potential to change module behavior during the import, because
+assignments to global variables are done when the module is first imported.
+
+<a id="s2.5.4-decision"></a>
+<a id="254-decision"></a>
+
+<a id="global-variables-decision"></a>
+#### 2.5.4 Decision
+
+Avoid global variables.
+
+While they are technically variables, module-level constants are permitted and
+encouraged. For example: `MAX_HOLY_HANDGRENADE_COUNT = 3`. Constants must be
+named using all caps with underscores. See [Naming](#s3.16-naming) below.
+
+If needed, globals should be declared at the module level and made internal to
+the module by prepending an `_` to the name. External access must be done
+through public module-level functions. See [Naming](#s3.16-naming) below.
+
+<a id="s2.6-nested"></a>
+<a id="26-nested"></a>
+
+<a id="nested-classes-functions"></a>
+### 2.6 Nested/Local/Inner Classes and Functions
+
+Nested local functions or classes are fine when used to close over a local
+variable. Inner classes are fine.
+
+<a id="s2.6.1-definition"></a>
+<a id="261-definition"></a>
+
+<a id="nested-classes-functions-definition"></a>
+#### 2.6.1 Definition
+
+A class can be defined inside of a method, function, or class. A function can be
+defined inside a method or function. Nested functions have read-only access to
+variables defined in enclosing scopes.
+
+<a id="s2.6.2-pros"></a>
+<a id="262-pros"></a>
+
+<a id="nested-classes-functions-pros"></a>
+#### 2.6.2 Pros
+
+Allows definition of utility classes and functions that are only used inside of
+a very limited scope. Very
+[ADT](http://www.google.com/url?sa=D&q=http://en.wikipedia.org/wiki/Abstract_data_type)-y.
+Commonly used for implementing decorators.
+
+<a id="s2.6.3-cons"></a>
+<a id="263-cons"></a>
+
+<a id="nested-classes-functions-cons"></a>
+#### 2.6.3 Cons
+
+Instances of nested or local classes cannot be pickled. Nested functions and
+classes cannot be directly tested. Nesting can make your outer function longer
+and less readable.
+
+<a id="s2.6.4-decision"></a>
+<a id="264-decision"></a>
+
+<a id="nested-classes-functions-decision"></a>
+#### 2.6.4 Decision
+
+They are fine with some caveats. Avoid nested functions or classes except when
+closing over a local value. Do not nest a function just to hide it from users
+of a module. Instead, prefix its name with an \_ at the module level so that it
+can still be accessed by tests.
+
+<a id="s2.7-list_comprehensions"></a>
+<a id="27-list_comprehensions"></a>
+<a id="list_comprehensions"></a>
+<a id="list-comprehensions"></a>
+
+<a id="comprehensions"></a>
+### 2.7 Comprehensions & Generator Expressions
+
+Okay to use for simple cases.
+
+<a id="s2.7.1-definition"></a>
+<a id="271-definition"></a>
+
+<a id="comprehensions-definition"></a>
+#### 2.7.1 Definition
+
+List, Dict, and Set comprehensions as well as generator expressions provide a
+concise and efficient way to create container types and iterators without
+resorting to the use of traditional loops, `map()`, `filter()`, or `lambda`.
+
+<a id="s2.7.2-pros"></a>
+<a id="272-pros"></a>
+
+<a id="comprehensions-pros"></a>
+#### 2.7.2 Pros
+
+Simple comprehensions can be clearer and simpler than other dict, list, or set
+creation techniques. Generator expressions can be very efficient, since they
+avoid the creation of a list entirely.
+
+<a id="s2.7.3-cons"></a>
+<a id="273-cons"></a>
+
+<a id="comprehensions-cons"></a>
+#### 2.7.3 Cons
+
+Complicated comprehensions or generator expressions can be hard to read.
+
+<a id="s2.7.4-decision"></a>
+<a id="274-decision"></a>
+
+<a id="comprehensions-decision"></a>
+#### 2.7.4 Decision
+
+Okay to use for simple cases. Each portion must fit on one line: mapping
+expression, `for` clause, filter expression. Multiple `for` clauses or filter
+expressions are not permitted. Use loops instead when things get more
+complicated.
+
+```python
+Yes:
+ result = [mapping_expr for value in iterable if filter_expr]
+
+ result = [{'key': value} for value in iterable
+ if a_long_filter_expression(value)]
+
+ result = [complicated_transform(x)
+ for x in iterable if predicate(x)]
+
+ descriptive_name = [
+ transform({'key': key, 'value': value}, color='black')
+ for key, value in generate_iterable(some_input)
+ if complicated_condition_is_met(key, value)
+ ]
+
+ result = []
+ for x in range(10):
+ for y in range(5):
+ if x * y > 10:
+ result.append((x, y))
+
+ return {x: complicated_transform(x)
+ for x in long_generator_function(parameter)
+ if x is not None}
+
+ squares_generator = (x**2 for x in range(10))
+
+ unique_names = {user.name for user in users if user is not None}
+
+ eat(jelly_bean for jelly_bean in jelly_beans
+ if jelly_bean.color == 'black')
+```
+
+```python
+No:
+ result = [complicated_transform(
+ x, some_argument=x+1)
+ for x in iterable if predicate(x)]
+
+ result = [(x, y) for x in range(10) for y in range(5) if x * y > 10]
+
+ return ((x, y, z)
+ for x in xrange(5)
+ for y in xrange(5)
+ if x != y
+ for z in xrange(5)
+ if y != z)
+```
+
+<a id="s2.8-default-iterators-and-operators"></a>
+
+<a id="default-iterators-operators"></a>
+### 2.8 Default Iterators and Operators
+
+Use default iterators and operators for types that support them, like lists,
+dictionaries, and files.
+
+<a id="s2.8.1-definition"></a>
+<a id="281-definition"></a>
+
+<a id="default-iterators-operators-definition"></a>
+#### 2.8.1 Definition
+
+Container types, like dictionaries and lists, define default iterators and
+membership test operators ("in" and "not in").
+
+<a id="s2.8.2-pros"></a>
+<a id="282-pros"></a>
+
+<a id="default-iterators-operators-pros"></a>
+#### 2.8.2 Pros
+
+The default iterators and operators are simple and efficient. They express the
+operation directly, without extra method calls. A function that uses default
+operators is generic. It can be used with any type that supports the operation.
+
+<a id="s2.8.3-cons"></a>
+<a id="283-cons"></a>
+
+<a id="default-iterators-operators-cons"></a>
+#### 2.8.3 Cons
+
+You can't tell the type of objects by reading the method names (e.g. has\_key()
+means a dictionary). This is also an advantage.
+
+<a id="s2.8.4-decision"></a>
+<a id="284-decision"></a>
+
+<a id="default-iterators-operators-decision"></a>
+#### 2.8.4 Decision
+
+Use default iterators and operators for types that support them, like lists,
+dictionaries, and files. The built-in types define iterator methods, too. Prefer
+these methods to methods that return lists, except that you should not mutate a
+container while iterating over it. Never use Python 2 specific iteration
+methods such as `dict.iter*()` unless necessary.
+
+```python
+Yes: for key in adict: ...
+ if key not in adict: ...
+ if obj in alist: ...
+ for line in afile: ...
+ for k, v in adict.items(): ...
+ for k, v in six.iteritems(adict): ...
+```
+
+```python
+No: for key in adict.keys(): ...
+ if not adict.has_key(key): ...
+ for line in afile.readlines(): ...
+ for k, v in dict.iteritems(): ...
+```
+
+<a id="s2.9-generators"></a>
+<a id="29-generators"></a>
+
+<a id="generators"></a>
+### 2.9 Generators
+
+Use generators as needed.
+
+<a id="s2.9.1-definition"></a>
+<a id="291-definition"></a>
+
+<a id="generators-definition"></a>
+#### 2.9 Definition
+
+A generator function returns an iterator that yields a value each time it
+executes a yield statement. After it yields a value, the runtime state of the
+generator function is suspended until the next value is needed.
+
+<a id="s2.9.2-pros"></a>
+<a id="292-pros"></a>
+
+<a id="generators-pros"></a>
+#### 2.9.2 Pros
+
+Simpler code, because the state of local variables and control flow are
+preserved for each call. A generator uses less memory than a function that
+creates an entire list of values at once.
+
+<a id="s2.9.3-cons"></a>
+<a id="293-cons"></a>
+
+<a id="generators-cons"></a>
+#### 2.9.3 Cons
+
+None.
+
+<a id="s2.9.4-decision"></a>
+<a id="294-decision"></a>
+
+<a id="generators-decision"></a>
+#### 2.9.4 Decision
+
+Fine. Use "Yields:" rather than "Returns:" in the docstring for generator
+functions.
+
+<a id="s2.10-lambda-functions"></a>
+<a id="210-lambda-functions"></a>
+
+<a id="lambdas"></a>
+### 2.10 Lambda Functions
+
+Okay for one-liners.
+
+<a id="s2.10.1-definition"></a>
+<a id="2101-definition"></a>
+
+<a id="lambdas-definition"></a>
+#### 2.10.1 Definition
+
+Lambdas define anonymous functions in an expression, as opposed to a statement.
+They are often used to define callbacks or operators for higher-order functions
+like `map()` and `filter()`.
+
+<a id="s2.10.2-pros"></a>
+<a id="2102-pros"></a>
+
+<a id="lambdas-pros"></a>
+#### 2.10.2 Pros
+
+Convenient.
+
+<a id="s2.10.3-cons"></a>
+<a id="2103-cons"></a>
+
+<a id="lambdas-cons"></a>
+#### 2.10.3 Cons
+
+Harder to read and debug than local functions. The lack of names means stack
+traces are more difficult to understand. Expressiveness is limited because the
+function may only contain an expression.
+
+<a id="s2.10.4-decision"></a>
+<a id="2104-decision"></a>
+
+<a id="lambdas-decision"></a>
+#### 2.10.4 Decision
+
+Okay to use them for one-liners. If the code inside the lambda function is
+longer than 60-80 chars, it's probably better to define it as a regular [nested
+function](#lexical-scoping).
+
+For common operations like multiplication, use the functions from the `operator`
+module instead of lambda functions. For example, prefer `operator.mul` to
+`lambda x, y: x * y`.
+
+<a id="s2.11-conditional-expressions"></a>
+<a id="211-conditional-expressions"></a>
+
+<a id="conditional-expressions"></a>
+### 2.11 Conditional Expressions
+
+Okay for simple cases.
+
+<a id="s2.11.1-definition"></a>
+<a id="2111-definition"></a>
+
+<a id="conditional-expressions-definition"></a>
+#### 2.11.1 Definition
+
+Conditional expressions (sometimes called a “ternary operator”) are mechanisms
+that provide a shorter syntax for if statements. For example:
+`x = 1 if cond else 2`.
+
+<a id="s2.11.2-pros"></a>
+<a id="2112-pros"></a>
+
+<a id="conditional-expressions-pros"></a>
+#### 2.11.2 Pros
+
+Shorter and more convenient than an if statement.
+
+<a id="s2.11.3-cons"></a>
+<a id="2113-cons"></a>
+
+<a id="conditional-expressions-cons"></a>
+#### 2.11.3 Cons
+
+May be harder to read than an if statement. The condition may be difficult to
+locate if the expression is long.
+
+<a id="s2.11.4-decision"></a>
+<a id="2114-decision"></a>
+
+<a id="conditional-expressions-decision"></a>
+#### 2.11.4 Decision
+
+Okay to use for simple cases. Each portion must fit on one line:
+true-expression, if-expression, else-expression. Use a complete if statement
+when things get more complicated.
+
+```python
+one_line = 'yes' if predicate(value) else 'no'
+slightly_split = ('yes' if predicate(value)
+ else 'no, nein, nyet')
+the_longest_ternary_style_that_can_be_done = (
+ 'yes, true, affirmative, confirmed, correct'
+ if predicate(value)
+ else 'no, false, negative, nay')
+```
+
+```python
+bad_line_breaking = ('yes' if predicate(value) else
+ 'no')
+portion_too_long = ('yes'
+ if some_long_module.some_long_predicate_function(
+ really_long_variable_name)
+ else 'no, false, negative, nay')
+```
+
+<a id="s2.12-default-argument-values"></a>
+<a id="212-default-argument-values"></a>
+
+<a id="default-arguments"></a>
+### 2.12 Default Argument Values
+
+Okay in most cases.
+
+<a id="s2.12.1-definition"></a>
+<a id="2121-definition"></a>
+
+<a id="default-arguments-definition"></a>
+#### 2.12.1 Definition
+
+You can specify values for variables at the end of a function's parameter list,
+e.g., `def foo(a, b=0):`. If `foo` is called with only one argument,
+`b` is set to 0. If it is called with two arguments, `b` has the value of the
+second argument.
+
+<a id="s2.12.2-pros"></a>
+<a id="2122-pros"></a>
+
+<a id="default-arguments-pros"></a>
+#### 2.12.2 Pros
+
+Often you have a function that uses lots of default values, but on rare
+occasions you want to override the defaults. Default argument values provide an
+easy way to do this, without having to define lots of functions for the rare
+exceptions. As Python does not support overloaded methods/functions, default
+arguments are an easy way of "faking" the overloading behavior.
+
+<a id="s2.12.3-cons"></a>
+<a id="2123-cons"></a>
+
+<a id="default-arguments-cons"></a>
+#### 2.12.3 Cons
+
+Default arguments are evaluated once at module load time. This may cause
+problems if the argument is a mutable object such as a list or a dictionary. If
+the function modifies the object (e.g., by appending an item to a list), the
+default value is modified.
+
+<a id="s2.12.4-decision"></a>
+<a id="2124-decision"></a>
+
+<a id="default-arguments-decision"></a>
+#### 2.12.4 Decision
+
+Okay to use with the following caveat:
+
+Do not use mutable objects as default values in the function or method
+definition.
+
+```python
+Yes: def foo(a, b=None):
+ if b is None:
+ b = []
+Yes: def foo(a, b: Optional[Sequence] = None):
+ if b is None:
+ b = []
+Yes: def foo(a, b: Sequence = ()): # Empty tuple OK since tuples are immutable
+ ...
+```
+
+```python
+No: def foo(a, b=[]):
+ ...
+No: def foo(a, b=time.time()): # The time the module was loaded???
+ ...
+No: def foo(a, b=FLAGS.my_thing): # sys.argv has not yet been parsed...
+ ...
+```
+
+<a id="s2.13-properties"></a>
+<a id="213-properties"></a>
+
+<a id="properties"></a>
+### 2.13 Properties
+
+Use properties for accessing or setting data where you would normally have used
+simple, lightweight accessor or setter methods.
+
+<a id="s2.13.1-definition"></a>
+<a id="2131-definition"></a>
+
+<a id="properties-definition"></a>
+#### 2.13.1 Definition
+
+A way to wrap method calls for getting and setting an attribute as a standard
+attribute access when the computation is lightweight.
+
+<a id="s2.13.2-pros"></a>
+<a id="2132-pros"></a>
+
+<a id="properties-pros"></a>
+#### 2.13.2 Pros
+
+Readability is increased by eliminating explicit get and set method calls for
+simple attribute access. Allows calculations to be lazy. Considered the Pythonic
+way to maintain the interface of a class. In terms of performance, allowing
+properties bypasses needing trivial accessor methods when a direct variable
+access is reasonable. This also allows accessor methods to be added in the
+future without breaking the interface.
+
+<a id="s2.13.3-cons"></a>
+<a id="2133-cons"></a>
+
+<a id="properties-cons"></a>
+#### 2.13.3 Cons
+
+Must inherit from `object` in Python 2. Can hide side-effects much like operator
+overloading. Can be confusing for subclasses.
+
+<a id="s2.13.4-decision"></a>
+<a id="2134-decision"></a>
+
+<a id="properties-decision"></a>
+#### 2.13.4 Decision
+
+Use properties in new code to access or set data where you would normally have
+used simple, lightweight accessor or setter methods. Properties should be
+created with the `@property` [decorator](#s2.17-function-and-method-decorators).
+
+Inheritance with properties can be non-obvious if the property itself is not
+overridden. Thus one must make sure that accessor methods are called indirectly
+to ensure methods overridden in subclasses are called by the property (using the
+Template Method DP).
+
+```python
+Yes: import math
+
+ class Square(object):
+ """A square with two properties: a writable area and a read-only perimeter.
+
+ To use:
+ >>> sq = Square(3)
+ >>> sq.area
+ 9
+ >>> sq.perimeter
+ 12
+ >>> sq.area = 16
+ >>> sq.side
+ 4
+ >>> sq.perimeter
+ 16
+ """
+
+ def __init__(self, side):
+ self.side = side
+
+ @property
+ def area(self):
+ """Area of the square."""
+ return self._get_area()
+
+ @area.setter
+ def area(self, area):
+ return self._set_area(area)
+
+ def _get_area(self):
+ """Indirect accessor to calculate the 'area' property."""
+ return self.side ** 2
+
+ def _set_area(self, area):
+ """Indirect setter to set the 'area' property."""
+ self.side = math.sqrt(area)
+
+ @property
+ def perimeter(self):
+ return self.side * 4
+```
+
+<a id="s2.14-truefalse-evaluations"></a>
+<a id="214-truefalse-evaluations"></a>
+
+<a id="truefalse-evaluations"></a>
+### 2.14 True/False Evaluations
+
+Use the "implicit" false if at all possible.
+
+<a id="s2.14.1-definition"></a>
+<a id="2141-definition"></a>
+
+<a id="truefalse-evaluations-definition"></a>
+#### 2.14.1 Definition
+
+Python evaluates certain values as `False` when in a boolean context. A quick
+"rule of thumb" is that all "empty" values are considered false, so
+`0, None, [], {}, ''` all evaluate as false in a boolean context.
+
+<a id="s2.14.2-pros"></a>
+<a id="2142-pros"></a>
+
+<a id="truefalse-evaluations-pros"></a>
+#### 2.14.2 Pros
+
+Conditions using Python booleans are easier to read and less error-prone. In
+most cases, they're also faster.
+
+<a id="s2.14.3-cons"></a>
+<a id="2143-cons"></a>
+
+<a id="truefalse-evaluations-cons"></a>
+#### 2.14.3 Cons
+
+May look strange to C/C++ developers.
+
+<a id="s2.14.4-decision"></a>
+<a id="2144-decision"></a>
+
+<a id="truefalse-evaluations-decision"></a>
+#### 2.14.4 Decision
+
+Use the "implicit" false if possible, e.g., `if foo:` rather than `if foo !=
+[]:`. There are a few caveats that you should keep in mind though:
+
+- Always use `if foo is None:` (or `is not None`) to check for a `None`
+ value-e.g., when testing whether a variable or argument that defaults to
+ `None` was set to some other value. The other value might be a value that's
+ false in a boolean context!
+
+- Never compare a boolean variable to `False` using `==`. Use `if not x:`
+ instead. If you need to distinguish `False` from `None` then chain the
+ expressions, such as `if not x and x is not None:`.
+
+- For sequences (strings, lists, tuples), use the fact that empty sequences
+ are false, so `if seq:` and `if not seq:` are preferable to `if len(seq):`
+ and `if not len(seq):` respectively.
+
+- When handling integers, implicit false may involve more risk than benefit
+ (i.e., accidentally handling `None` as 0). You may compare a value which is
+ known to be an integer (and is not the result of `len()`) against the
+ integer 0.
+
+ ```python
+ Yes: if not users:
+ print('no users')
+
+ if foo == 0:
+ self.handle_zero()
+
+ if i % 10 == 0:
+ self.handle_multiple_of_ten()
+
+ def f(x=None):
+ if x is None:
+ x = []
+ ```
+
+ ```python
+ No: if len(users) == 0:
+ print('no users')
+
+ if foo is not None and not foo:
+ self.handle_zero()
+
+ if not i % 10:
+ self.handle_multiple_of_ten()
+
+ def f(x=None):
+ x = x or []
+ ```
+
+- Note that `'0'` (i.e., `0` as string) evaluates to true.
+
+<a id="s2.15-deprecated-language-features"></a>
+<a id="215-deprecated-language-features"></a>
+
+<a id="deprecated-features"></a>
+### 2.15 Deprecated Language Features
+
+Use string methods instead of the `string` module where possible. Use function
+call syntax instead of `apply`. Use list comprehensions and `for` loops instead
+of `filter` and `map` when the function argument would have been an inlined
+lambda anyway. Use `for` loops instead of `reduce`.
+
+<a id="s2.15.1-definition"></a>
+<a id="2151-definition"></a>
+
+<a id="deprecated-features-definition"></a>
+#### 2.15.1 Definition
+
+Current versions of Python provide alternative constructs that people find
+generally preferable.
+
+<a id="s2.15.2-decision"></a>
+<a id="2152-decision"></a>
+
+<a id="deprecated-features-decision"></a>
+#### 2.15.2 Decision
+
+We do not use any Python version which does not support these features, so there
+is no reason not to use the new styles.
+
+```python
+Yes: words = foo.split(':')
+
+ [x[1] for x in my_list if x[2] == 5]
+
+ map(math.sqrt, data) # Ok. No inlined lambda expression.
+
+ fn(*args, **kwargs)
+```
+
+```python
+No: words = string.split(foo, ':')
+
+ map(lambda x: x[1], filter(lambda x: x[2] == 5, my_list))
+
+ apply(fn, args, kwargs)
+```
+
+<a id="s2.16-lexical-scoping"></a>
+<a id="216-lexical-scoping"></a>
+
+<a id="lexical-scoping"></a>
+### 2.16 Lexical Scoping
+
+Okay to use.
+
+<a id="s2.16.1-definition"></a>
+<a id="2161-definition"></a>
+
+<a id="lexical-scoping-definition"></a>
+#### 2.16.1 Definition
+
+A nested Python function can refer to variables defined in enclosing functions,
+but can not assign to them. Variable bindings are resolved using lexical
+scoping, that is, based on the static program text. Any assignment to a name in
+a block will cause Python to treat all references to that name as a local
+variable, even if the use precedes the assignment. If a global declaration
+occurs, the name is treated as a global variable.
+
+An example of the use of this feature is:
+
+```python
+def get_adder(summand1):
+ """Returns a function that adds numbers to a given number."""
+ def adder(summand2):
+ return summand1 + summand2
+
+ return adder
+```
+
+<a id="s2.16.2-pros"></a>
+<a id="2162-pros"></a>
+
+<a id="lexical-scoping-pros"></a>
+#### 2.16.2 Pros
+
+Often results in clearer, more elegant code. Especially comforting to
+experienced Lisp and Scheme (and Haskell and ML and ...) programmers.
+
+<a id="s2.16.3-cons"></a>
+<a id="2163-cons"></a>
+
+<a id="lexical-scoping-cons"></a>
+#### 2.16.3 Cons
+
+Can lead to confusing bugs. Such as this example based on
+[PEP-0227](http://www.google.com/url?sa=D&q=http://www.python.org/dev/peps/pep-0227/):
+
+```python
+i = 4
+def foo(x):
+ def bar():
+ print(i, end='')
+ # ...
+ # A bunch of code here
+ # ...
+ for i in x: # Ah, i *is* local to foo, so this is what bar sees
+ print(i, end='')
+ bar()
+```
+
+So `foo([1, 2, 3])` will print `1 2 3 3`, not `1 2 3
+4`.
+
+<a id="s2.16.4-decision"></a>
+<a id="2164-decision"></a>
+
+<a id="lexical-scoping-decision"></a>
+#### 2.16.4 Decision
+
+Okay to use.
+
+<a id="s2.17-function-and-method-decorators"></a>
+<a id="217-function-and-method-decorators"></a>
+<a id="function-and-method-decorators"></a>
+
+<a id="decorators"></a>
+### 2.17 Function and Method Decorators
+
+Use decorators judiciously when there is a clear advantage. Avoid
+`@staticmethod` and limit use of `@classmethod`.
+
+<a id="s2.17.1-definition"></a>
+<a id="2171-definition"></a>
+
+<a id="decorators-definition"></a>
+#### 2.17.1 Definition
+
+[Decorators for Functions and
+Methods](https://docs.python.org/3/glossary.html#term-decorator)
+(a.k.a "the `@` notation"). One common decorator is `@property`, used for
+converting ordinary methods into dynamically computed attributes. However, the
+decorator syntax allows for user-defined decorators as well. Specifically, for
+some function `my_decorator`, this:
+
+```python
+class C(object):
+ @my_decorator
+ def method(self):
+ # method body ...
+```
+
+is equivalent to:
+
+
+```python
+class C(object):
+ def method(self):
+ # method body ...
+ method = my_decorator(method)
+```
+
+<a id="s2.17.2-pros"></a>
+<a id="2172-pros"></a>
+
+<a id="decorators-pros"></a>
+#### 2.17.2 Pros
+
+Elegantly specifies some transformation on a method; the transformation might
+eliminate some repetitive code, enforce invariants, etc.
+
+<a id="s2.17.3-cons"></a>
+<a id="2173-cons"></a>
+
+<a id="decorators-cons"></a>
+#### 2.17.3 Cons
+
+Decorators can perform arbitrary operations on a function's arguments or return
+values, resulting in surprising implicit behavior. Additionally, decorators
+execute at import time. Failures in decorator code are pretty much impossible to
+recover from.
+
+<a id="s2.17.4-decision"></a>
+<a id="2174-decision"></a>
+
+<a id="decorators-decision"></a>
+#### 2.17.4 Decision
+
+Use decorators judiciously when there is a clear advantage. Decorators should
+follow the same import and naming guidelines as functions. Decorator pydoc
+should clearly state that the function is a decorator. Write unit tests for
+decorators.
+
+Avoid external dependencies in the decorator itself (e.g. don't rely on files,
+sockets, database connections, etc.), since they might not be available when the
+decorator runs (at import time, perhaps from `pydoc` or other tools). A
+decorator that is called with valid parameters should (as much as possible) be
+guaranteed to succeed in all cases.
+
+Decorators are a special case of "top level code" - see [main](#s3.17-main) for
+more discussion.
+
+Never use `@staticmethod` unless forced to in order to integrate with an API
+defined in an existing library. Write a module level function instead.
+
+Use `@classmethod` only when writing a named constructor or a class-specific
+routine that modifies necessary global state such as a process-wide cache.
+
+<a id="s2.18-threading"></a>
+<a id="218-threading"></a>
+
+<a id="threading"></a>
+### 2.18 Threading
+
+Do not rely on the atomicity of built-in types.
+
+While Python's built-in data types such as dictionaries appear to have atomic
+operations, there are corner cases where they aren't atomic (e.g. if `__hash__`
+or `__eq__` are implemented as Python methods) and their atomicity should not be
+relied upon. Neither should you rely on atomic variable assignment (since this
+in turn depends on dictionaries).
+
+Use the Queue module's `Queue` data type as the preferred way to communicate
+data between threads. Otherwise, use the threading module and its locking
+primitives. Learn about the proper use of condition variables so you can use
+`threading.Condition` instead of using lower-level locks.
+
+<a id="s2.19-power-features"></a>
+<a id="219-power-features"></a>
+
+<a id="power-features"></a>
+### 2.19 Power Features
+
+Avoid these features.
+
+<a id="s2.19.1-definition"></a>
+<a id="2191-definition"></a>
+
+<a id="power-features-definition"></a>
+#### 2.19.1 Definition
+
+Python is an extremely flexible language and gives you many fancy features such
+as custom metaclasses, access to bytecode, on-the-fly compilation, dynamic
+inheritance, object reparenting, import hacks, reflection (e.g. some uses of
+`getattr()`), modification of system internals, etc.
+
+<a id="s2.19.2-pros"></a>
+<a id="2192-pros"></a>
+
+<a id="power-features-pros"></a>
+#### 2.19.2 Pros
+
+These are powerful language features. They can make your code more compact.
+
+<a id="s2.19.3-cons"></a>
+<a id="2193-cons"></a>
+
+<a id="power-features-cons"></a>
+#### 2.19.3 Cons
+
+It's very tempting to use these "cool" features when they're not absolutely
+necessary. It's harder to read, understand, and debug code that's using unusual
+features underneath. It doesn't seem that way at first (to the original author),
+but when revisiting the code, it tends to be more difficult than code that is
+longer but is straightforward.
+
+<a id="s2.19.4-decision"></a>
+<a id="2194-decision"></a>
+
+<a id="power-features-decision"></a>
+#### 2.19.4 Decision
+
+Avoid these features in your code.
+
+Standard library modules and classes that internally use these features are okay
+to use (for example, `abc.ABCMeta`, `collections.namedtuple`, `dataclasses`,
+and `enum`).
+
+<a id="s2.20-modern-python"></a>
+<a id="220-modern-python"></a>
+
+<a id="modern-python"></a>
+### 2.20 Modern Python: Python 3 and from \_\_future\_\_ imports
+
+Python 3 is here! While not every project is ready to
+use it yet, all code should be written to be 3 compatible (and tested under
+3 when possible).
+
+<a id="s2.20.1-definition"></a>
+<a id="2201-definition"></a>
+
+<a id="modern-python-definition"></a>
+#### 2.20.1 Definition
+
+Python 3 is a significant change in the Python language. While existing code is
+often written with 2.7 in mind, there are some simple things to do to make code
+more explicit about its intentions and thus better prepared for use under Python
+3 without modification.
+
+<a id="s2.20.2-pros"></a>
+<a id="2202-pros"></a>
+
+<a id="modern-python-pros"></a>
+#### 2.20.2 Pros
+
+Code written with Python 3 in mind is more explicit and easier to get running
+under Python 3 once all of the dependencies of your project are ready.
+
+<a id="s2.20.3-cons"></a>
+<a id="2203-cons"></a>
+
+<a id="modern-python-cons"></a>
+#### 2.20.3 Cons
+
+Some people find the additional boilerplate to be ugly. It's unusual to add
+imports to a module that doesn't actually require the features added by the
+import.
+
+<a id="s2.20.4-decision"></a>
+<a id="2204-decision"></a>
+
+<a id="modern-python-decision"></a>
+#### 2.20.4 Decision
+
+##### from \_\_future\_\_ imports
+
+Use of `from __future__ import` statements is encouraged. All new code should
+contain the following and existing code should be updated to be compatible when
+possible:
+
+```python
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+```
+
+If you are not already familiar with those, read up on each here: [absolute
+imports](https://www.python.org/dev/peps/pep-0328/), [new `/` division
+behavior](https://www.python.org/dev/peps/pep-0238/), and [the print
+function](https://www.python.org/dev/peps/pep-3105/).
+
+
+Please don't omit or remove these imports, even if they're not currently used in
+the module, unless the code is Python 3 only. It is better to always have the
+future imports in all files so that they are not forgotten during later edits
+when someone starts using such a feature.
+
+There are other `from __future__` import statements. Use them as you see fit. We
+do not include `unicode_literals` in our recommendations as it is not a clear
+win due to implicit default codec conversion consequences it introduces in many
+places within Python 2.7. Most code is better off with explicit use of `b''` and
+`u''` bytes and unicode string literals as necessary.
+
+##### The six, future, or past libraries
+
+When your project needs to actively support use under both Python 2 and 3, use
+the [six](https://pypi.org/project/six/),
+[future](https://pypi.org/project/future/), and
+[past](https://pypi.org/project/past/) libraries as you see fit. They exist to
+make your code cleaner and life easier.
+
+<a name="s2.21-typed-code"></a>
+<a name="221-type-annotated-code"></a>
+<a name="typed-code"></a>
+
+<a id="typed-code"></a>
+### 2.21 Type Annotated Code
+
+You can annotate Python 3 code with type hints according to
+[PEP-484](https://www.python.org/dev/peps/pep-0484/), and type-check the code at
+build time with a type checking tool like
+[pytype](https://github.com/google/pytype).
+
+
+Type annotations can be in the source or in a [stub pyi
+file](https://www.python.org/dev/peps/pep-0484/#stub-files). Whenever possible,
+annotations should be in the source. Use pyi files for third-party or extension
+modules.
+
+
+<a id="s2.21.1-definition"></a>
+<a id="2211-definition"></a>
+
+<a id="typed-code-definition"></a>
+#### 2.21.1 Definition
+
+Type annotations (or "type hints") are for function or method arguments and
+return values:
+
+```python
+def func(a: int) -> List[int]:
+```
+
+You can also declare the type of a variable using a special comment:
+
+```python
+a = SomeFunc() # type: SomeType
+```
+
+<a id="s2.21.2-pros"></a>
+<a id="2212-pros"></a>
+
+<a id="typed-code-pros"></a>
+#### 2.21.2 Pros
+
+Type annotations improve the readability and maintainability of your code. The
+type checker will convert many runtime errors to build-time errors, and reduce
+your ability to use [Power Features](#power-features).
+
+<a id="s2.21.3-cons"></a>
+<a id="2213-cons"></a>
+
+<a id="typed-code-cons"></a>
+#### 2.21.3 Cons
+
+You will have to keep the type declarations up to date. You might see type errors that you think are valid code. Use of a [type checker](https://github.com/google/pytype)
+may reduce your ability to use [Power Features](#power-features).
+
+<a id="s2.21.4-decision"></a>
+<a id="2214-decision"></a>
+
+<a id="typed-code-decision"></a>
+#### 2.21.4 Decision
+
+You are strongly encouraged to enable Python type analysis when updating code.
+When adding or modifying public APIs, include type annotations and enable
+checking via pytype in the build system. As static analysis is relatively new to
+Python, we acknowledge that undesired side-effects (such as
+wrongly
+inferred types) may prevent adoption by some projects. In those situations,
+authors are encouraged to add a comment with a TODO or link to a bug describing
+the issue(s) currently preventing type annotation adoption in the BUILD file or
+in the code itself as appropriate.
+
+<a id="s3-python-style-rules"></a>
+<a id="3-python-style-rules"></a>
+
+<a id="python-style-rules"></a>
+## 3 Python Style Rules
+
+<a id="s3.1-semicolons"></a>
+<a id="31-semicolons"></a>
+
+<a id="semicolons"></a>
+### 3.1 Semicolons
+
+Do not terminate your lines with semicolons, and do not use semicolons to put
+two statements on the same line.
+
+<a id="s3.2-line-length"></a>
+<a id="32-line-length"></a>
+
+<a id="line-length"></a>
+### 3.2 Line length
+
+Maximum line length is *80 characters*.
+
+Explicit exceptions to the 80 character limit:
+
+- Long import statements.
+- URLs, pathnames, or long flags in comments.
+- Long string module level constants not containing whitespace that would be
+ inconvenient to split across lines such as URLs or pathnames.
+- Pylint disable comments. (e.g.: `# pylint: disable=invalid-name`)
+
+Do not use backslash line continuation except for `with` statements requiring
+three or more context managers.
+
+Make use of Python's [implicit line joining inside parentheses, brackets and
+braces](http://docs.python.org/reference/lexical_analysis.html#implicit-line-joining).
+If necessary, you can add an extra pair of parentheses around an expression.
+
+```python
+Yes: foo_bar(self, width, height, color='black', design=None, x='foo',
+ emphasis=None, highlight=0)
+
+ if (width == 0 and height == 0 and
+ color == 'red' and emphasis == 'strong'):
+```
+
+When a literal string won't fit on a single line, use parentheses for implicit
+line joining.
+
+```python
+x = ('This will build a very long long '
+ 'long long long long long long string')
+```
+
+Within comments, put long URLs on their own line if necessary.
+
+```python
+Yes: # See details at
+ # http://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html
+```
+
+```python
+No: # See details at
+ # http://www.example.com/us/developer/documentation/api/content/\
+ # v2.0/csv_file_name_extension_full_specification.html
+```
+
+It is permissible to use backslash continuation when defining a `with` statement
+whose expressions span three or more lines. For two lines of expressions, use a
+nested `with` statement:
+
+```python
+Yes: with very_long_first_expression_function() as spam, \
+ very_long_second_expression_function() as beans, \
+ third_thing() as eggs:
+ place_order(eggs, beans, spam, beans)
+```
+
+```python
+No: with VeryLongFirstExpressionFunction() as spam, \
+ VeryLongSecondExpressionFunction() as beans:
+ PlaceOrder(eggs, beans, spam, beans)
+```
+
+```python
+Yes: with very_long_first_expression_function() as spam:
+ with very_long_second_expression_function() as beans:
+ place_order(beans, spam)
+```
+
+Make note of the indentation of the elements in the line continuation examples
+above; see the [indentation](#s3.4-indentation) section for explanation.
+
+In all other cases where a line exceeds 80 characters, and the
+[yapf](https://github.com/google/yapf/)
+auto-formatter does not help bring the line below the limit, the line is allowed
+to exceed this maximum.
+
+<a id="s3.3-parentheses"></a>
+<a id="33-parentheses"></a>
+
+<a id="parentheses"></a>
+### 3.3 Parentheses
+
+Use parentheses sparingly.
+
+It is fine, though not required, to use parentheses around tuples. Do not use
+them in return statements or conditional statements unless using parentheses for
+implied line continuation or to indicate a tuple.
+
+```python
+Yes: if foo:
+ bar()
+ while x:
+ x = bar()
+ if x and y:
+ bar()
+ if not x:
+ bar()
+ # For a 1 item tuple the ()s are more visually obvious than the comma.
+ onesie = (foo,)
+ return foo
+ return spam, beans
+ return (spam, beans)
+ for (x, y) in dict.items(): ...
+```
+
+```python
+No: if (x):
+ bar()
+ if not(x):
+ bar()
+ return (foo)
+```
+
+<a id="s3.4-indentation"></a>
+<a id="34-indentation"></a>
+
+<a id="indentation"></a>
+### 3.4 Indentation
+
+Indent your code blocks with *4 spaces*.
+
+Never use tabs or mix tabs and spaces. In cases of implied line continuation,
+you should align wrapped elements either vertically, as per the examples in the
+[line length](#s3.2-line-length) section; or using a hanging indent of 4 spaces,
+in which case there should be nothing after the open parenthesis or bracket on
+the first line.
+
+```python
+Yes: # Aligned with opening delimiter
+ foo = long_function_name(var_one, var_two,
+ var_three, var_four)
+ meal = (spam,
+ beans)
+
+ # Aligned with opening delimiter in a dictionary
+ foo = {
+ long_dictionary_key: value1 +
+ value2,
+ ...
+ }
+
+ # 4-space hanging indent; nothing on first line
+ foo = long_function_name(
+ var_one, var_two, var_three,
+ var_four)
+ meal = (
+ spam,
+ beans)
+
+ # 4-space hanging indent in a dictionary
+ foo = {
+ long_dictionary_key:
+ long_dictionary_value,
+ ...
+ }
+```
+
+```python
+No: # Stuff on first line forbidden
+ foo = long_function_name(var_one, var_two,
+ var_three, var_four)
+ meal = (spam,
+ beans)
+
+ # 2-space hanging indent forbidden
+ foo = long_function_name(
+ var_one, var_two, var_three,
+ var_four)
+
+ # No hanging indent in a dictionary
+ foo = {
+ long_dictionary_key:
+ long_dictionary_value,
+ ...
+ }
+```
+
+<a id="s3.4.1-trailing_comma"></a>
+<a id="341-trailing_comma"></a>
+<a id="trailing_comma"></a>
+
+<a id="trailing-comma"></a>
+### 3.4.1 Trailing commas in sequences of items?
+
+Trailing commas in sequences of items are recommended only when the closing
+container token `]`, `)`, or `}` does not appear on the same line as the final
+element. The presence of a trailing comma is also used as a hint to our Python
+code auto-formatter [YAPF](https://pypi.org/project/yapf/) to direct it to auto-format the container
+of items to one item per line when the `,` after the final element is present.
+
+```python
+Yes: golomb3 = [0, 1, 3]
+Yes: golomb4 = [
+ 0,
+ 1,
+ 4,
+ 6,
+ ]
+```
+
+```python
+No: golomb4 = [
+ 0,
+ 1,
+ 4,
+ 6
+ ]
+```
+
+<a id="s3.5-blank-lines"></a>
+<a id="35-blank-lines"></a>
+
+<a id="blank-lines"></a>
+### 3.5 Blank Lines
+
+Two blank lines between top-level definitions, be they function or class
+definitions. One blank line between method definitions and between the `class`
+line and the first method. No blank line following a `def` line. Use single
+blank lines as you judge appropriate within functions or methods.
+
+<a id="s3.6-whitespace"></a>
+<a id="36-whitespace"></a>
+
+<a id="whitespace"></a>
+### 3.6 Whitespace
+
+Follow standard typographic rules for the use of spaces around punctuation.
+
+No whitespace inside parentheses, brackets or braces.
+
+```python
+Yes: spam(ham[1], {eggs: 2}, [])
+```
+
+```python
+No: spam( ham[ 1 ], { eggs: 2 }, [ ] )
+```
+
+No whitespace before a comma, semicolon, or colon. Do use whitespace after a
+comma, semicolon, or colon, except at the end of the line.
+
+```python
+Yes: if x == 4:
+ print(x, y)
+ x, y = y, x
+```
+
+```python
+No: if x == 4 :
+ print(x , y)
+ x , y = y , x
+```
+
+No whitespace before the open paren/bracket that starts an argument list,
+indexing or slicing.
+
+```python
+Yes: spam(1)
+```
+
+```python
+No: spam (1)
+```
+
+
+```python
+Yes: dict['key'] = list[index]
+```
+
+```python
+No: dict ['key'] = list [index]
+```
+
+No trailing whitespace.
+
+Surround binary operators with a single space on either side for assignment
+(`=`), comparisons (`==, <, >, !=, <>, <=, >=, in, not in, is, is not`), and
+Booleans (`and, or, not`). Use your better judgment for the insertion of spaces
+around arithmetic operators (`+`, `-`, `*`, `/`, `//`, `%`, `**`, `@`).
+
+```python
+Yes: x == 1
+```
+
+```python
+No: x<1
+```
+
+Never use spaces around `=` when passing keyword arguments or defining a default
+parameter value, with one exception: [when a type annotation is
+present](#typing-default-values), _do_ use spaces around the `=` for the default
+parameter value.
+
+```python
+Yes: def complex(real, imag=0.0): return Magic(r=real, i=imag)
+Yes: def complex(real, imag: float = 0.0): return Magic(r=real, i=imag)
+```
+
+```python
+No: def complex(real, imag = 0.0): return Magic(r = real, i = imag)
+No: def complex(real, imag: float=0.0): return Magic(r = real, i = imag)
+```
+
+Don't use spaces to vertically align tokens on consecutive lines, since it
+becomes a maintenance burden (applies to `:`, `#`, `=`, etc.):
+
+```python
+Yes:
+ foo = 1000 # comment
+ long_name = 2 # comment that should not be aligned
+
+ dictionary = {
+ 'foo': 1,
+ 'long_name': 2,
+ }
+```
+
+```python
+No:
+ foo = 1000 # comment
+ long_name = 2 # comment that should not be aligned
+
+ dictionary = {
+ 'foo' : 1,
+ 'long_name': 2,
+ }
+```
+
+
+<a id="Python_Interpreter"></a>
+<a id="s3.7-shebang-line"></a>
+<a id="37-shebang-line"></a>
+
+<a id="shebang-line"></a>
+### 3.7 Shebang Line
+
+Most `.py` files do not need to start with a `#!` line. Start the main file of a
+program with
+`#!/usr/bin/python` with an optional single digit `2` or `3` suffix per
+[PEP-394](https://www.google.com/url?sa=D&q=http://www.python.org/dev/peps/pep-0394/).
+
+This line is used by the kernel to find the Python interpreter, but is ignored
+by Python when importing modules. It is only necessary on a file that will be
+executed directly.
+
+<a id="s3.8-comments"></a>
+<a id="38-comments-and-docstrings"></a>
+
+<a id="documentation"></a>
+### 3.8 Comments and Docstrings
+
+Be sure to use the right style for module, function, method docstrings and
+inline comments.
+
+<a id="s3.8.1-comments-in-doc-strings"></a>
+<a id="381-docstrings"></a>
+<a id="comments-in-doc-strings"></a>
+
+<a id="docstrings"></a>
+#### 3.8.1 Docstrings
+
+Python uses _docstrings_ to document code. A docstring is a string that is the
+first statement in a package, module, class or function. These strings can be
+extracted automatically through the `__doc__` member of the object and are used
+by `pydoc`.
+(Try running `pydoc` on your module to see how it looks.) Always use the three
+double-quote `"""` format for docstrings (per [PEP
+257](https://www.google.com/url?sa=D&q=http://www.python.org/dev/peps/pep-0257/)).
+A docstring should be organized as a summary line (one physical line) terminated
+by a period, question mark, or exclamation point, followed by a blank line,
+followed by the rest of the docstring starting at the same cursor position as
+the first quote of the first line. There are more formatting guidelines for
+docstrings below.
+
+<a id="s3.8.2-comments-in-modules"></a>
+<a id="382-modules"></a>
+<a id="comments-in-modules"></a>
+
+<a id="module-docs"></a>
+#### 3.8.2 Modules
+
+Every file should contain license boilerplate.
+Choose the appropriate boilerplate for the license used by the project (for
+example, Apache 2.0, BSD, LGPL, GPL)
+
+Files should start with a docstring describing the contents and usage of the
+module.
+```python
+"""A one line summary of the module or program, terminated by a period.
+
+Leave one blank line. The rest of this docstring should contain an
+overall description of the module or program. Optionally, it may also
+contain a brief description of exported classes and functions and/or usage
+examples.
+
+ Typical usage example:
+
+ foo = ClassFoo()
+ bar = foo.FunctionBar()
+"""
+```
+
+
+<a id="s3.8.3-functions-and-methods"></a>
+<a id="383-functions-and-methods"></a>
+<a id="functions-and-methods"></a>
+
+<a id="function-docs"></a>
+#### 3.8.3 Functions and Methods
+
+In this section, "function" means a method, function, or generator.
+
+A function must have a docstring, unless it meets all of the following criteria:
+
+- not externally visible
+- very short
+- obvious
+
+A docstring should give enough information to write a call to the function
+without reading the function's code. The docstring should be descriptive-style
+(`"""Fetches rows from a Bigtable."""`) rather than imperative-style (`"""Fetch
+rows from a Bigtable."""`), except for `@property` data descriptors, which
+should use the <a href="#384-classes">same style as attributes</a>. A docstring
+should describe the function's calling syntax and its semantics, not its
+implementation. For tricky code, comments alongside the code are more
+appropriate than using docstrings.
+
+A method that overrides a method from a base class may have a simple docstring
+sending the reader to its overridden method's docstring, such as `"""See base
+class."""`. The rationale is that there is no need to repeat in many places
+documentation that is already present in the base method's docstring. However,
+if the overriding method's behavior is substantially different from the
+overridden method, or details need to be provided (e.g., documenting additional
+side effects), a docstring with at least those differences is required on the
+overriding method.
+
+Certain aspects of a function should be documented in special sections, listed
+below. Each section begins with a heading line, which ends with a colon. All
+sections other than the heading should maintain a hanging indent of two or four
+spaces (be consistent within a file). These sections can be omitted in cases
+where the function's name and signature are informative enough that it can be
+aptly described using a one-line docstring.
+
+<a id="doc-function-args"></a>
+[*Args:*](#doc-function-args)
+: List each parameter by name. A description should follow the name, and be
+ separated by a colon and a space. If the description is too long to fit on a
+ single 80-character line, use a hanging indent of 2 or 4 spaces (be
+ consistent with the rest of the file).
+
+ The description should include required type(s) if the code does not contain
+ a corresponding type annotation. If a function accepts `*foo` (variable
+ length argument lists) and/or `**bar` (arbitrary keyword arguments), they
+ should be listed as `*foo` and `**bar`.
+
+<a id="doc-function-returns"></a>
+[*Returns:* (or *Yields:* for generators)](#doc-function-returns)
+: Describe the type and semantics of the return value. If the function only
+ returns None, this section is not required. It may also be omitted if the
+ docstring starts with Returns or Yields (e.g. `"""Returns row from Bigtable
+ as a tuple of strings."""`) and the opening sentence is sufficient to
+ describe return value.
+
+<a id="doc-function-raises"></a>
+[*Raises:*](#doc-function-raises)
+: List all exceptions that are relevant to the interface. You should not
+ document exceptions that get raised if the API specified in the docstring is
+ violated (because this would paradoxically make behavior under violation of
+ the API part of the API).
+
+```python
+def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
+ """Fetches rows from a Bigtable.
+
+ Retrieves rows pertaining to the given keys from the Table instance
+ represented by big_table. Silly things may happen if
+ other_silly_variable is not None.
+
+ Args:
+ big_table: An open Bigtable Table instance.
+ keys: A sequence of strings representing the key of each table row
+ to fetch.
+ other_silly_variable: Another optional variable, that has a much
+ longer name than the other args, and which does nothing.
+
+ Returns:
+ A dict mapping keys to the corresponding table row data
+ fetched. Each row is represented as a tuple of strings. For
+ example:
+
+ {'Serak': ('Rigel VII', 'Preparer'),
+ 'Zim': ('Irk', 'Invader'),
+ 'Lrrr': ('Omicron Persei 8', 'Emperor')}
+
+ If a key from the keys argument is missing from the dictionary,
+ then that row was not found in the table.
+
+ Raises:
+ IOError: An error occurred accessing the bigtable.Table object.
+ """
+```
+
+<a id="s3.8.4-comments-in-classes"></a>
+<a id="384-classes"></a>
+<a id="comments-in-classes"></a>
+
+<a id="class-docs"></a>
+#### 3.8.4 Classes
+
+Classes should have a docstring below the class definition describing the class.
+If your class has public attributes, they should be documented here in an
+`Attributes` section and follow the same formatting as a
+[function's `Args`](#doc-function-args) section.
+
+```python
+class SampleClass(object):
+ """Summary of class here.
+
+ Longer class information....
+ Longer class information....
+
+ Attributes:
+ likes_spam: A boolean indicating if we like SPAM or not.
+ eggs: An integer count of the eggs we have laid.
+ """
+
+ def __init__(self, likes_spam=False):
+ """Inits SampleClass with blah."""
+ self.likes_spam = likes_spam
+ self.eggs = 0
+
+ def public_method(self):
+ """Performs operation blah."""
+```
+
+<a id="comments-in-block-and-inline"></a>
+<a id="s3.8.5-comments-in-block-and-inline"></a>
+<a id="385-block-and-inline-comments"></a>
+
+<a id="comments"></a>
+#### 3.8.5 Block and Inline Comments
+
+The final place to have comments is in tricky parts of the code. If you're going
+to have to explain it at the next [code
+review](http://en.wikipedia.org/wiki/Code_review), you should comment it
+now. Complicated operations get a few lines of comments before the operations
+commence. Non-obvious ones get comments at the end of the line.
+
+```python
+# We use a weighted dictionary search to find out where i is in
+# the array. We extrapolate position based on the largest num
+# in the array and the array size and then do binary search to
+# get the exact number.
+
+if i & (i-1) == 0: # True if i is 0 or a power of 2.
+```
+
+To improve legibility, these comments should start at least 2 spaces away from
+the code with the comment character `#`, followed by at least one space before
+the text of the comment itself.
+
+On the other hand, never describe the code. Assume the person reading the code
+knows Python (though not what you're trying to do) better than you do.
+
+```python
+# BAD COMMENT: Now go through the b array and make sure whenever i occurs
+# the next element is i+1
+```
+
+<!-- The next section is copied from the C++ style guide. -->
+
+<a id="s3.8.6-punctuation-spelling-and-grammar"></a>
+<a id="386-punctuation-spelling-and-grammar"></a>
+<a id="spelling"></a>
+<a id="punctuation"></a>
+<a id="grammar"></a>
+
+<a id="punctuation-spelling-grammar"></a>
+#### 3.8.6 Punctuation, Spelling and Grammar
+
+Pay attention to punctuation, spelling, and grammar; it is easier to read
+well-written comments than badly written ones.
+
+Comments should be as readable as narrative text, with proper capitalization and
+punctuation. In many cases, complete sentences are more readable than sentence
+fragments. Shorter comments, such as comments at the end of a line of code, can
+sometimes be less formal, but you should be consistent with your style.
+
+Although it can be frustrating to have a code reviewer point out that you are
+using a comma when you should be using a semicolon, it is very important that
+source code maintain a high level of clarity and readability. Proper
+punctuation, spelling, and grammar help with that goal.
+
+<a id="s3.9-classes"></a>
+<a id="39-classes"></a>
+
+<a id="classes"></a>
+### 3.9 Classes
+
+If a class inherits from no other base classes, explicitly inherit from
+`object`. This also applies to nested classes.
+
+```python
+Yes: class SampleClass(object):
+ pass
+
+
+ class OuterClass(object):
+
+ class InnerClass(object):
+ pass
+
+
+ class ChildClass(ParentClass):
+ """Explicitly inherits from another class already."""
+
+```
+
+```python
+No: class SampleClass:
+ pass
+
+
+ class OuterClass:
+
+ class InnerClass:
+ pass
+```
+
+Inheriting from `object` is needed to make properties work properly in Python 2
+and can protect your code from potential incompatibility with Python 3. It also
+defines special methods that implement the default semantics of objects
+including `__new__`, `__init__`, `__delattr__`, `__getattribute__`,
+`__setattr__`, `__hash__`, `__repr__`, and `__str__`.
+
+<a id="s3.10-strings"></a>
+<a id="310-strings"></a>
+
+<a id="strings"></a>
+### 3.10 Strings
+
+Use the `format` method or the `%` operator for formatting strings, even when
+the parameters are all strings. Use your best judgment to decide between `+` and
+`%` (or `format`) though.
+
+```python
+Yes: x = a + b
+ x = '%s, %s!' % (imperative, expletive)
+ x = '{}, {}'.format(first, second)
+ x = 'name: %s; score: %d' % (name, n)
+ x = 'name: {}; score: {}'.format(name, n)
+ x = f'name: {name}; score: {n}' # Python 3.6+
+```
+
+```python
+No: x = '%s%s' % (a, b) # use + in this case
+ x = '{}{}'.format(a, b) # use + in this case
+ x = first + ', ' + second
+ x = 'name: ' + name + '; score: ' + str(n)
+```
+
+Avoid using the `+` and `+=` operators to accumulate a string within a loop.
+Since strings are immutable, this creates unnecessary temporary objects and
+results in quadratic rather than linear running time. Instead, add each
+substring to a list and `''.join` the list after the loop terminates (or, write
+each substring to a `io.BytesIO` buffer).
+
+```python
+Yes: items = ['<table>']
+ for last_name, first_name in employee_list:
+ items.append('<tr><td>%s, %s</td></tr>' % (last_name, first_name))
+ items.append('</table>')
+ employee_table = ''.join(items)
+```
+
+```python
+No: employee_table = '<table>'
+ for last_name, first_name in employee_list:
+ employee_table += '<tr><td>%s, %s</td></tr>' % (last_name, first_name)
+ employee_table += '</table>'
+```
+
+Be consistent with your choice of string quote character within a file. Pick `'`
+or `"` and stick with it. It is okay to use the other quote character on a
+string to avoid the need to `\\ ` escape within the string.
+
+```python
+Yes:
+ Python('Why are you hiding your eyes?')
+ Gollum("I'm scared of lint errors.")
+ Narrator('"Good!" thought a happy Python reviewer.')
+```
+
+```python
+No:
+ Python("Why are you hiding your eyes?")
+ Gollum('The lint. It burns. It burns us.')
+ Gollum("Always the great lint. Watching. Watching.")
+```
+
+Prefer `"""` for multi-line strings rather than `'''`. Projects may choose to
+use `'''` for all non-docstring multi-line strings if and only if they also use
+`'` for regular strings. Docstrings must use `"""` regardless.
+
+Multi-line strings do not flow with the indentation of the rest of the program.
+If you need to avoid embedding extra space in the string, use either
+concatenated single-line strings or a multi-line string with
+[`textwrap.dedent()`](https://docs.python.org/3/library/textwrap.html#textwrap.dedent)
+to remove the initial space on each line:
+
+```python
+ No:
+ long_string = """This is pretty ugly.
+Don't do this.
+"""
+```
+
+```python
+ Yes:
+ long_string = """This is fine if your use case can accept
+ extraneous leading spaces."""
+```
+
+```python
+ Yes:
+ long_string = ("And this is fine if you can not accept\n" +
+ "extraneous leading spaces.")
+```
+
+```python
+ Yes:
+ long_string = ("And this too is fine if you can not accept\n"
+ "extraneous leading spaces.")
+```
+
+```python
+ Yes:
+ import textwrap
+
+ long_string = textwrap.dedent("""\
+ This is also fine, because textwrap.dedent()
+ will collapse common leading spaces in each line.""")
+```
+
+<a id="s3.11-files-and-sockets"></a>
+<a id="311-files-and-sockets"></a>
+<a id="files-and-sockets"></a>
+
+<a id="files"></a>
+### 3.11 Files and Sockets
+
+Explicitly close files and sockets when done with them.
+
+Leaving files, sockets or other file-like objects open unnecessarily has many
+downsides:
+
+- They may consume limited system resources, such as file descriptors. Code
+ that deals with many such objects may exhaust those resources unnecessarily
+ if they're not returned to the system promptly after use.
+- Holding files open may prevent other actions such as moving or deleting
+ them.
+- Files and sockets that are shared throughout a program may inadvertently be
+ read from or written to after logically being closed. If they are actually
+ closed, attempts to read or write from them will throw exceptions, making
+ the problem known sooner.
+
+Furthermore, while files and sockets are automatically closed when the file
+object is destructed, tying the lifetime of the file object to the state of the
+file is poor practice:
+
+- There are no guarantees as to when the runtime will actually run the file's
+ destructor. Different Python implementations use different memory management
+ techniques, such as delayed Garbage Collection, which may increase the
+ object's lifetime arbitrarily and indefinitely.
+- Unexpected references to the file, e.g. in globals or exception tracebacks,
+ may keep it around longer than intended.
+
+The preferred way to manage files is using the ["with"
+statement](http://docs.python.org/reference/compound_stmts.html#the-with-statement):
+
+```python
+with open("hello.txt") as hello_file:
+ for line in hello_file:
+ print(line)
+```
+
+For file-like objects that do not support the "with" statement, use
+`contextlib.closing()`:
+
+```python
+import contextlib
+
+with contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:
+ for line in front_page:
+ print(line)
+```
+
+<a id="s3.12-todo-comments"></a>
+<a id="312-todo-comments"></a>
+
+<a id="todo"></a>
+### 3.12 TODO Comments
+
+Use `TODO` comments for code that is temporary, a short-term solution, or
+good-enough but not perfect.
+
+A `TODO` comment begins with the string `TODO` in all caps and a parenthesized
+name, e-mail address, or other identifier
+of the person or issue with the best context about the problem. This is followed
+by an explanation of what there is to do.
+
+The purpose is to have a consistent `TODO` format that can be searched to find
+out how to get more details. A `TODO` is not a commitment that the person
+referenced will fix the problem. Thus when you create a
+`TODO`, it is almost always your name
+that is given.
+
+```python
+# TODO(kl@gmail.com): Use a "*" here for string repetition.
+# TODO(Zeke) Change this to use relations.
+```
+
+If your `TODO` is of the form "At a future date do something" make sure that you
+either include a very specific date ("Fix by November 2009") or a very specific
+event ("Remove this code when all clients can handle XML responses.").
+
+<a id="s3.13-imports-formatting"></a>
+<a id="313-imports-formatting"></a>
+
+<a id="imports-formatting"></a>
+### 3.13 Imports formatting
+
+Imports should be on separate lines.
+
+E.g.:
+
+```python
+Yes: import os
+ import sys
+```
+
+```python
+No: import os, sys
+```
+
+
+Imports are always put at the top of the file, just after any module comments
+and docstrings and before module globals and constants. Imports should be
+grouped from most generic to least generic:
+
+1. Python future import statements. For example:
+
+ ```python
+ from __future__ import absolute_import
+ from __future__ import division
+ from __future__ import print_function
+ ```
+
+ See [above](#from-future-imports) for more information about those.
+
+2. Python standard library imports. For example:
+
+ ```python
+ import sys
+ ```
+
+3. [third-party](https://pypi.org/) module
+ or package imports. For example:
+
+
+ ```python
+ import tensorflow as tf
+ ```
+
+4. Code repository
+ sub-package imports. For example:
+
+
+ ```python
+ from otherproject.ai import mind
+ ```
+
+5. **Deprecated:** application-specific imports that are part of the same
+ top level
+ sub-package as this file. For example:
+
+
+ ```python
+ from myproject.backend.hgwells import time_machine
+ ```
+
+ You may find older Google Python Style code doing this, but it is no longer
+ required. **New code is encouraged not to bother with this.** Simply treat
+ application-specific sub-package imports the same as other sub-package
+ imports.
+
+
+Within each grouping, imports should be sorted lexicographically, ignoring case,
+according to each module's full package path. Code may optionally place a blank
+line between import sections.
+
+```python
+import collections
+import queue
+import sys
+
+from absl import app
+from absl import flags
+import bs4
+import cryptography
+import tensorflow as tf
+
+from book.genres import scifi
+from myproject.backend.hgwells import time_machine
+from myproject.backend.state_machine import main_loop
+from otherproject.ai import body
+from otherproject.ai import mind
+from otherproject.ai import soul
+
+# Older style code may have these imports down here instead:
+#from myproject.backend.hgwells import time_machine
+#from myproject.backend.state_machine import main_loop
+```
+
+
+<a id="s3.14-statements"></a>
+<a id="314-statements"></a>
+
+<a id="statements"></a>
+### 3.14 Statements
+
+Generally only one statement per line.
+
+However, you may put the result of a test on the same line as the test only if
+the entire statement fits on one line. In particular, you can never do so with
+`try`/`except` since the `try` and `except` can't both fit on the same line, and
+you can only do so with an `if` if there is no `else`.
+
+```python
+Yes:
+
+ if foo: bar(foo)
+```
+
+```python
+No:
+
+ if foo: bar(foo)
+ else: baz(foo)
+
+ try: bar(foo)
+ except ValueError: baz(foo)
+
+ try:
+ bar(foo)
+ except ValueError: baz(foo)
+```
+
+<a id="s3.15-access-control"></a>
+<a id="315-access-control"></a>
+<a id="access-control"></a>
+
+<a id="accessors"></a>
+### 3.15 Accessors
+
+If an accessor function would be trivial, you should use public variables
+instead of accessor functions to avoid the extra cost of function calls in
+Python. When more functionality is added you can use `property` to keep the
+syntax consistent.
+
+On the other hand, if access is more complex, or the cost of accessing the
+variable is significant, you should use function calls (following the
+[Naming](#s3.16-naming) guidelines) such as `get_foo()` and
+`set_foo()`. If the past behavior allowed access through a property, do not
+bind the new accessor functions to the property. Any code still attempting to
+access the variable by the old method should break visibly so they are made
+aware of the change in complexity.
+
+<a id="s3.16-naming"></a>
+<a id="316-naming"></a>
+
+<a id="naming"></a>
+### 3.16 Naming
+
+`module_name`, `package_name`, `ClassName`, `method_name`, `ExceptionName`,
+`function_name`, `GLOBAL_CONSTANT_NAME`, `global_var_name`, `instance_var_name`,
+`function_parameter_name`, `local_var_name`.
+
+
+Function names, variable names, and filenames should be descriptive; eschew
+abbreviation. In particular, do not use abbreviations that are ambiguous or
+unfamiliar to readers outside your project, and do not abbreviate by deleting
+letters within a word.
+
+Always use a `.py` filename extension. Never use dashes.
+
+<a id="s3.16.1-names-to-avoid"></a>
+<a id="3161-names-to-avoid"></a>
+
+<a id="names-to-avoid"></a>
+#### 3.16.1 Names to Avoid
+
+- single character names except for counters or iterators. You may use "e" as
+ an exception identifier in try/except statements.
+- dashes (`-`) in any package/module name
+- `__double_leading_and_trailing_underscore__` names (reserved by Python)
+
+<a id="s3.16.2-naming-conventions"></a>
+<a id="3162-naming-convention"></a>
+
+<a id="naming-conventions"></a>
+#### 3.16.2 Naming Conventions
+
+- "Internal" means internal to a module, or protected or private within a
+ class.
+
+- Prepending a single underscore (`_`) has some support for protecting module
+ variables and functions (not included with `from module import *`). While
+ prepending a double underscore (`__` aka "dunder") to an instance variable
+ or method effectively makes the variable or method private to its class
+ (using name mangling) we discourage its use as it impacts readability and
+ testability and isn't *really* private.
+
+- Place related classes and top-level functions together in a
+ module.
+ Unlike Java, there is no need to limit yourself to one class per module.
+
+- Use CapWords for class names, but lower\_with\_under.py for module names.
+ Although there are some old modules named CapWords.py, this is now
+ discouraged because it's confusing when the module happens to be named after
+ a class. ("wait -- did I write `import StringIO` or `from StringIO import
+ StringIO`?")
+
+- Underscores may appear in *unittest* method names starting with `test` to
+ separate logical components of the name, even if those components use
+ CapWords. One possible pattern is `test<MethodUnderTest>_<state>`; for
+ example `testPop_EmptyStack` is okay. There is no One Correct Way to name
+ test methods.
+
+<a id="s3.16.3-file-naming"></a>
+<a id="3163-file-naming"></a>
+
+<a id="file-naming"></a>
+#### 3.16.3 File Naming
+
+Python filenames must have a `.py` extension and must not contain dashes (`-`).
+This allows them to be imported and unittested. If you want an executable to be
+accessible without the extension, use a symbolic link or a simple bash wrapper
+containing `exec "$0.py" "$@"`.
+
+<a id="s3.16.4-guidelines-derived-from-guidos-recommendations"></a>
+<a id="3164-guidelines-derived-from-guidos-recommendations"></a>
+
+<a id="guidelines-derived-from-guidos-recommendations"></a>
+#### 3.16.4 Guidelines derived from Guido's Recommendations
+
+<table rules="all" border="1" summary="Guidelines from Guido's Recommendations"
+ cellspacing="2" cellpadding="2">
+
+ <tr>
+ <th>Type</th>
+ <th>Public</th>
+ <th>Internal</th>
+ </tr>
+
+ <tr>
+ <td>Packages</td>
+ <td><code>lower_with_under</code></td>
+ <td></td>
+ </tr>
+
+ <tr>
+ <td>Modules</td>
+ <td><code>lower_with_under</code></td>
+ <td><code>_lower_with_under</code></td>
+ </tr>
+
+ <tr>
+ <td>Classes</td>
+ <td><code>CapWords</code></td>
+ <td><code>_CapWords</code></td>
+ </tr>
+
+ <tr>
+ <td>Exceptions</td>
+ <td><code>CapWords</code></td>
+ <td></td>
+ </tr>
+
+ <tr>
+ <td>Functions</td>
+ <td><code>lower_with_under()</code></td>
+ <td><code>_lower_with_under()</code></td>
+ </tr>
+
+ <tr>
+ <td>Global/Class Constants</td>
+ <td><code>CAPS_WITH_UNDER</code></td>
+ <td><code>_CAPS_WITH_UNDER</code></td>
+ </tr>
+
+ <tr>
+ <td>Global/Class Variables</td>
+ <td><code>lower_with_under</code></td>
+ <td><code>_lower_with_under</code></td>
+ </tr>
+
+ <tr>
+ <td>Instance Variables</td>
+ <td><code>lower_with_under</code></td>
+ <td><code>_lower_with_under</code> (protected)</td>
+ </tr>
+
+ <tr>
+ <td>Method Names</td>
+ <td><code>lower_with_under()</code></td>
+ <td><code>_lower_with_under()</code> (protected)</td>
+ </tr>
+
+ <tr>
+ <td>Function/Method Parameters</td>
+ <td><code>lower_with_under</code></td>
+ <td></td>
+ </tr>
+
+ <tr>
+ <td>Local Variables</td>
+ <td><code>lower_with_under</code></td>
+ <td></td>
+ </tr>
+
+</table>
+
+While Python supports making things private by using a leading double underscore
+`__` (aka. "dunder") prefix on a name, this is discouraged. Prefer the use of a
+single underscore. They are easier to type, read, and to access from small
+unittests. Lint warnings take care of invalid access to protected members.
+
+
+<a id="s3.17-main"></a>
+<a id="317-main"></a>
+
+<a id="main"></a>
+### 3.17 Main
+
+Even a file meant to be used as an executable should be importable and a mere
+import should not have the side effect of executing the program's main
+functionality. The main functionality should be in a `main()` function.
+
+In Python, `pydoc` as well as unit tests require modules to be importable. Your
+code should always check `if __name__ == '__main__'` before executing your main
+program so that the main program is not executed when the module is imported.
+
+```python
+def main():
+ ...
+
+if __name__ == '__main__':
+ main()
+```
+
+All code at the top level will be executed when the module is imported. Be
+careful not to call functions, create objects, or perform other operations that
+should not be executed when the file is being `pydoc`ed.
+
+<a id="s3.18-function-length"></a>
+<a id="318-function-length"></a>
+
+<a id="function-length"></a>
+### 3.18 Function length
+
+Prefer small and focused functions.
+
+We recognize that long functions are sometimes appropriate, so no hard limit is
+placed on function length. If a function exceeds about 40 lines, think about
+whether it can be broken up without harming the structure of the program.
+
+Even if your long function works perfectly now, someone modifying it in a few
+months may add new behavior. This could result in bugs that are hard to find.
+Keeping your functions short and simple makes it easier for other people to read
+and modify your code.
+
+You could find long and complicated functions when working with
+some code. Do not be intimidated by modifying existing code: if working with such
+a function proves to be difficult, you find that errors are hard to debug, or
+you want to use a piece of it in several different contexts, consider breaking
+up the function into smaller and more manageable pieces.
+
+<a id="s3.19-type-annotations"></a>
+<a id="319-type-annotations"></a>
+
+<a id="type-annotations"></a>
+### 3.19 Type Annotations
+
+<a id="s3.19.1-general"></a>
+<a id="3191-general-rules"></a>
+
+<a id="typing-general"></a>
+#### 3.19.1 General Rules
+
+* Familiarize yourself with [PEP-484](https://www.python.org/dev/peps/pep-0484/).
+* In methods, only annotate `self`, or `cls` if it is necessary for proper type
+ information. e.g., `@classmethod def create(cls: Type[T]) -> T: return cls()`
+* If any other variable or a returned type should not be expressed, use `Any`.
+* You are not required to annotate all the functions in a module.
+ - At least annotate your public APIs.
+ - Use judgment to get to a good balance between safety and clarity on the
+ one hand, and flexibility on the other.
+ - Annotate code that is prone to type-related errors (previous bugs or
+ complexity).
+ - Annotate code that is hard to understand.
+ - Annotate code as it becomes stable from a types perspective. In many
+ cases, you can annotate all the functions in mature code without losing
+ too much flexibility.
+
+
+<a id="s3.19.2-line-breaking"></a>
+<a id="3192-line-breaking"></a>
+
+<a id="typing-line-breaking"></a>
+#### 3.19.2 Line Breaking
+
+Try to follow the existing [indentation](#indentation) rules.
+
+After annotating, many function signatures will become "one parameter per line".
+
+```python
+def my_method(self,
+ first_var: int,
+ second_var: Foo,
+ third_var: Optional[Bar]) -> int:
+ ...
+```
+
+Always prefer breaking between variables, and not for example between variable
+names and type annotations. However, if everything fits on the same line,
+go for it.
+
+```python
+def my_method(self, first_var: int) -> int:
+ ...
+```
+
+If the combination of the function name, the last parameter, and the return type
+is too long, indent by 4 in a new line.
+
+```python
+def my_method(
+ self, first_var: int) -> Tuple[MyLongType1, MyLongType1]:
+ ...
+```
+
+When the return type does not fit on the same line as the last parameter, the
+preferred way is to indent the parameters by 4 on a new line and align the
+closing parenthesis with the def.
+
+```python
+Yes:
+def my_method(
+ self, other_arg: Optional[MyLongType]
+) -> Dict[OtherLongType, MyLongType]:
+ ...
+```
+
+`pylint` allows you to move the closing parenthesis to a new line and align
+with the opening one, but this is less readable.
+
+```python
+No:
+def my_method(self,
+ other_arg: Optional[MyLongType]
+ ) -> Dict[OtherLongType, MyLongType]:
+ ...
+```
+
+As in the examples above, prefer not to break types. However, sometimes they are
+too long to be on a single line (try to keep sub-types unbroken).
+
+```python
+def my_method(
+ self,
+ first_var: Tuple[List[MyLongType1],
+ List[MyLongType2]],
+ second_var: List[Dict[
+ MyLongType3, MyLongType4]]) -> None:
+ ...
+```
+
+If a single name and type is too long, consider using an
+[alias](#typing-aliases) for the type. The last resort is to break after the
+colon and indent by 4.
+
+```python
+Yes:
+def my_function(
+ long_variable_name:
+ long_module_name.LongTypeName,
+) -> None:
+ ...
+```
+
+```python
+No:
+def my_function(
+ long_variable_name: long_module_name.
+ LongTypeName,
+) -> None:
+ ...
+```
+
+<a id="s3.19.3-forward-declarations"></a>
+<a id="3193-forward-declarations"></a>
+
+<a id="forward-declarations"></a>
+#### 3.19.3 Forward Declarations
+
+If you need to use a class name from the same module that is not yet defined --
+for example, if you need the class inside the class declaration, or if you use a
+class that is defined below -- use a string for the class name.
+
+```python
+class MyClass(object):
+
+ def __init__(self,
+ stack: List["MyClass"]) -> None:
+```
+
+<a id="s3.19.4-default-values"></a>
+<a id="3194-default-values"></a>
+
+<a id="typing-default-values"></a>
+#### 3.19.4 Default Values
+
+As per
+[PEP-008](https://www.python.org/dev/peps/pep-0008/#other-recommendations), use
+spaces around the `=` _only_ for arguments that have both a type annotation and
+a default value.
+
+```python
+Yes:
+def func(a: int = 0) -> int:
+ ...
+```
+```python
+No:
+def func(a:int=0) -> int:
+ ...
+```
+
+<a id="s3.19.5-none-type"></a>
+<a id="3195-nonetype"></a>
+
+<a id="none-type"></a>
+#### 3.19.5 NoneType
+
+In the Python type system, `NoneType` is a "first class" type, and for typing
+purposes, `None` is an alias for `NoneType`. If an argument can be `None`, it
+has to be declared! You can use `Union`, but if there is only one other type,
+use `Optional`.
+
+Use explicit `Optional` instead of implicit `Optional`. Earlier versions of PEP
+484 allowed `a: Text = None` to be interpretted as `a: Optional[Text] = None`,
+but that is no longer the preferred behavior.
+
+```python
+Yes:
+def func(a: Optional[Text], b: Optional[Text] = None) -> Text:
+ ...
+def multiple_nullable_union(a: Union[None, Text, int]) -> Text
+ ...
+```
+
+```python
+No:
+def nullable_union(a: Union[None, Text]) -> Text:
+ ...
+def implicit_optional(a: Text = None) -> Text:
+ ...
+```
+
+<a id="s3.19.6-aliases"></a>
+<a id="3196-type-aliases"></a>
+<a id="typing-aliases"></a>
+
+<a id="type-aliases"></a>
+#### 3.19.6 Type Aliases
+
+You can declare aliases of complex types. The name of an alias should be
+CapWorded. If the alias is used only in this module, it should be
+\_Private.
+
+For example, if the name of the module together with the name of the type is too
+long:
+
+```python
+_ShortName = module_with_long_name.TypeWithLongName
+ComplexMap = Mapping[Text, List[Tuple[int, int]]]
+```
+
+Other examples are complex nested types and multiple return variables from a
+function (as a tuple).
+
+<a id="s3.19.7-ignore"></a>
+<a id="3197-ignoring-types"></a>
+
+<a id="typing-ignore"></a>
+#### 3.19.7 Ignoring Types
+
+You can disable type checking on a line with the special comment
+`# type: ignore`.
+
+`pytype` has a disable option for specific errors (similar to lint):
+
+```python
+# pytype: disable=attribute-error
+```
+
+<a id="s3.19.8-comments"></a>
+<a id="3198-typing-internal-variables"></a>
+
+<a id="typing-variables"></a>
+#### 3.19.8 Typing Variables
+
+If an internal variable has a type that is hard or impossible to infer, you can
+specify its type in a couple ways.
+
+<a id="type-comments"></a>
+[*Type Comments:*](#type-comments)
+: Use a `# type:` comment on the end of the line
+
+ ```python
+ a = SomeUndecoratedFunction() # type: Foo
+ ```
+
+[*Annotated Assignments*](#annotated-assignments)
+: Use a colon and type between the variable name and value, as with function
+ arguments.
+
+ ```python
+ a: Foo = SomeUndecoratedFunction()
+ ```
+
+<a id="s3.19.9-tuples"></a>
+<a id="3199-tuples-vs-lists"></a>
+
+<a id="typing-tuples"></a>
+#### 3.19.9 Tuples vs Lists
+
+Unlike Lists, which can only have a single type, Tuples can have either a single
+repeated type or a set number of elements with different types. The latter is
+commonly used as return type from a function.
+
+```python
+a = [1, 2, 3] # type: List[int]
+b = (1, 2, 3) # type: Tuple[int, ...]
+c = (1, "2", 3.5) # type: Tuple[int, Text, float]
+```
+
+<a id="s3.19.10-type-var"></a>
+<a id="31910-typevar"></a>
+<a id="typing-type-var"></a>
+
+<a id="typevars"></a>
+#### 3.19.10 TypeVars
+
+The Python type system has
+[generics](https://www.python.org/dev/peps/pep-0484/#generics). The factory
+function `TypeVar` is a common way to use them.
+
+Example:
+
+```python
+from typing import List, TypeVar
+T = TypeVar("T")
+...
+def next(l: List[T]) -> T:
+ return l.pop()
+```
+
+A TypeVar can be constrained:
+
+```python
+AddableType = TypeVar("AddableType", int, float, Text)
+def add(a: AddableType, b: AddableType) -> AddableType:
+ return a + b
+```
+
+A common predefined type variable in the `typing` module is `AnyStr`. Use it for
+multiple annotations that can be `bytes` or `unicode` and must all be the same
+type.
+
+```python
+from typing import AnyStr
+def check_length(x: AnyStr) -> AnyStr:
+ if len(x) <= 42:
+ return x
+ raise ValueError()
+```
+
+<a id="s3.19.11-strings"></a>
+<a id="31911-string-types"></a>
+
+<a id="typing-strings"></a>
+#### 3.19.11 String types
+
+The proper type for annotating strings depends on what versions of Python the
+code is intended for.
+
+For Python 3 only code, prefer to use `str`. `Text` is also acceptable. Be
+consistent in using one or the other.
+
+For Python 2 compatible code, use `Text`. In some rare cases, `str` may make
+sense; typically to aid compatibility when the return types aren't the same
+between the two Python versions. Avoid using `unicode`: it doesn't exist in
+Python 3.
+
+The reason this discrepancy exists is because `str` means different things
+depending on the Python version.
+
+```python
+No:
+def py2_code(x: str) -> unicode:
+ ...
+```
+
+For code that deals with binary data, use `bytes`.
+
+```python
+def deals_with_binary_data(x: bytes) -> bytes:
+ ...
+```
+
+For Python 2 compatible code that processes text data (`str` or `unicode` in
+Python 2, `str` in Python 3), use `Text`. For Python 3 only code that process
+text data, prefer `str`.
+
+```python
+from typing import Text
+...
+def py2_compatible(x: Text) -> Text:
+ ...
+def py3_only(x: str) -> str:
+ ...
+```
+
+If the type can be either bytes or text, use `Union`, with the appropriate text
+type.
+
+```python
+from typing import Text, Union
+...
+def py2_compatible(x: Union[bytes, Text]) -> Union[bytes, Text]:
+ ...
+def py3_only(x: Union[bytes, str]) -> Union[bytes, str]:
+ ...
+```
+
+If all the string types of a function are always the same, for example if the
+return type is the same as the argument type in the code above, use
+[AnyStr](#typing-type-var).
+
+Writing it like this will simplify the process of porting the code to Python 3.
+
+<a id="s3.19.12-imports"></a>
+<a id="31912-imports-for-typing"></a>
+
+<a id="typing-imports"></a>
+#### 3.19.12 Imports For Typing
+
+For classes from the `typing` module, always import the class itself. You are
+explicitly allowed to import multiple specific classes on one line from the
+`typing` module. Ex:
+
+```python
+from typing import Any, Dict, Optional
+```
+
+Given that this way of importing from `typing` adds items to the local
+namespace, any names in `typing` should be treated similarly to keywords, and
+not be defined in your Python code, typed or not. If there is a collision
+between a type and an existing name in a module, import it using
+`import x as y`.
+
+```python
+from typing import Any as AnyType
+```
+
+<a id="s3.19.13-conditional-imports"></a>
+<a id="31913-conditional-imports"></a>
+
+<a id="typing-conditional-imports"></a>
+#### 3.19.13 Conditional Imports
+
+Use conditional imports only in exceptional cases where the additional imports
+needed for type checking must be avoided at runtime. This pattern is
+discouraged; alternatives such as refactoring the code to allow top level
+imports should be preferred.
+
+Imports that are needed only for type annotations can be placed within an
+`if TYPE_CHECKING:` block.
+
+- Conditionally imported types need to be referenced as strings, to be
+ forward compatible with Python 3.6 where the annotation expressions are
+ actually evaluated.
+- Only entities that are used solely for typing should be defined here; this
+ includes aliases. Otherwise it will be a runtime error, as the module will
+ not be imported at runtime.
+- The block should be right after all the normal imports.
+- There should be no empty lines in the typing imports list.
+- Sort this list as if it were a regular imports list.
+
+```python
+import typing
+if typing.TYPE_CHECKING:
+ import sketch
+def f(x: "sketch.Sketch"): ...
+```
+
+<a id="s3.19.14-circular-deps"></a>
+<a id="31914-circular-dependencies"></a>
+
+<a id="typing-circular-deps"></a>
+#### 3.19.14 Circular Dependencies
+
+Circular dependencies that are caused by typing are code smells. Such code is a
+good candidate for refactoring. Although technically it is possible to keep
+circular dependencies, the [build system](#typing-build-deps) will not let you
+do so because each module has to depend on the other.
+
+Replace modules that create circular dependency imports with `Any`. Set an
+[alias](#typing-aliases) with a meaningful name, and use the real type name from
+this module (any attribute of Any is Any). Alias definitions should be separated
+from the last import by one line.
+
+```python
+from typing import Any
+
+some_mod = Any # some_mod.py imports this module.
+...
+
+def my_method(self, var: some_mod.SomeType) -> None:
+ ...
+```
+
+<a id="typing-generics"></a>
+<a id="s3.19.15-generics"></a>
+<a id="31915-generics"></a>
+
+<a id="generics"></a>
+#### 3.19.15 Generics
+
+When annotating, prefer to specify type parameters for generic types; otherwise,
+[the generics' parameters will be assumed to be `Any`](https://www.python.org/dev/peps/pep-0484/#the-any-type).
+
+```python
+def get_names(employee_ids: List[int]) -> Dict[int, Any]:
+ ...
+```
+
+```python
+# These are both interpreted as get_names(employee_ids: List[Any]) -> Dict[Any, Any]
+def get_names(employee_ids: list) -> Dict:
+ ...
+
+def get_names(employee_ids: List) -> Dict:
+ ...
+```
+
+If the best type parameter for a generic is `Any`, make it explicit, but
+remember that in many cases [`TypeVar`](#typing-type-var) might be more
+appropriate:
+
+```python
+def get_names(employee_ids: List[Any]) -> Dict[Any, Text]:
+ """Returns a mapping from employee ID to employee name for given IDs."""
+```
+
+```python
+T = TypeVar('T')
+def get_names(employee_ids: List[T]) -> Dict[T, Text]:
+ """Returns a mapping from employee ID to employee name for given IDs."""
+```
+
+
+<a id="4-parting-words"></a>
+
+<a id="consistency"></a>
+## 4 Parting Words
+
+*BE CONSISTENT*.
+
+If you're editing code, take a few minutes to look at the code around you and
+determine its style. If they use spaces around all their arithmetic operators,
+you should too. If their comments have little boxes of hash marks around them,
+make your comments have little boxes of hash marks around them too.
+
+The point of having style guidelines is to have a common vocabulary of coding so
+people can concentrate on what you're saying rather than on how you're saying
+it. We present global style rules here so people know the vocabulary, but local
+style is also important. If code you add to a file looks drastically different
+from the existing code around it, it throws readers out of their rhythm when
+they go to read it. Avoid this.
+
+
