Require braces

proposals/README.md

@@ -60,5 +60,6 @@ request:
 -   [0540 - Remove `Void`](p0540.md)
 -   [0555 - Operator precedence](p0555.md)
 -   [0601 - Operator tokens](p0601.md)
+-   [0623 - Require braces](p0623.md)
 
 <!-- endproposals -->

proposals/p0623.md

@@ -0,0 +1,150 @@
+# Require braces
+
+<!--
+Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+Exceptions. See /LICENSE for license information.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+[Pull request](https://github.com/carbon-language/carbon-lang/pull/623)
+
+<!-- toc -->
+
+## Table of contents
+
+-   [Problem](#problem)
+-   [Background](#background)
+-   [Proposal](#proposal)
+-   [Rationale based on Carbon's goals](#rationale-based-on-carbons-goals)
+-   [Alternatives considered](#alternatives-considered)
+    -   [Optional braces](#optional-braces)
+    -   [Optional parentheses](#optional-parentheses)
+
+<!-- tocstop -->
+
+## Problem
+
+In C++, braces are often optional, such as in:
+
+```
+for (Shape x : shapes)
+  Draw(x);
+```
+
+Carbon adopted this design choice by default in proposals
+[#285](https://github.com/carbon-language/carbon-lang/blob/trunk/proposals/p0285.md),
+[#340](https://github.com/carbon-language/carbon-lang/blob/trunk/proposals/p0340.md),
+and
+[#353](https://github.com/carbon-language/carbon-lang/blob/trunk/proposals/p0353.md).
+But should we keep it?
+
+## Background
+
+We were adopting the C++ syntax primarily for easy consistency with C++.
+
+Some modern languages require braces, including Go, Rust, and Swift. Kotlin is
+an example which does not. Note some which require braces make parentheses
+optional.
+
+## Proposal
+
+Carbon should require braces when they might otherwise be optional. We should
+continue to require parentheses. This currently comes up in `if`/`else`,
+`while`, and `for`.
+
+## Rationale based on Carbon's goals
+
+-   **Software and language evolution**: Reducing parsing ambiguity of curly
+    braces is important for expanding the syntactic options for Carbon.
+
+-   **Code that is easy to read, understand, and write**: We have a preference
+    to give only one way to do things, and optional braces are inconsistent with
+    that. It's also easier to understand and parse code that uses braces, and
+    defends against the possibility of
+    [`goto fail`](https://dwheeler.com/essays/apple-goto-fail.html)-style bugs,
+    whether accidental or malicious.
+
+-   **Interoperability with and migration from existing C++ code**: While C++
+    does make braces optional in related situations, we believe this isn't
+    fundamental to migration or familiarity for C++ developers, so this goal is
+    not meaningfully impacted by this change.
+
+## Alternatives considered
+
+### Optional braces
+
+We could instead keep braces optional, such as:
+
+```carbon
+if (x)
+  return y;
+```
+
+Advantages:
+
+-   Consistent with C++.
+-   Allows for greater brevity in code, such as `if (!success) return error;`.
+
+Disadvantages:
+
+-   Gives two ways of doing the same thing.
+    -   Style guides will make choices, creating more contextual coding style.
+-   More complex and harder to parse.
+
+    -   Nested `if` statements can have unclear `else` bindings. For example:
+
+        ```carbon
+        if (x)
+        if (y)
+          DoIfY();
+        else
+          DoIfNotY();
+        else
+          DoIfNotX();
+        ```
+
+    -   If Carbon were to reuse `if` and `else` keywords for a ternary operator,
+        that could omit braces in order to avoid ambiguity. For example,
+        `int x = if y then 3 else 7;`.
+
+-   Developers are known to make mistakes adding statements to conditionals
+    missing braces, keeping consistent indentation, and missing the incorrect
+    behavior due to cognitive load. For example:
+
+    ```carbon
+    if (x)
+      return y;
+    ```
+
+    ->
+
+    ```carbon
+    if (x)
+      print("Returning y");
+      return y;
+    ```
+
+### Optional parentheses
+
+Languages which make braces required can make parentheses optional, or even
+disallow them, such as:
+
+```carbon
+if x {
+  return y;
+}
+```
+
+Advantages:
+
+-   Exchanges verbosity in syntax, requiring `{}` but removing `()`.
+    -   Particularly useful in that many conditionals have `{}` regardless of
+        optionality, but all conditionals could in theory remove `()`.
+-   Cross-language consistency with languages that require `{}`.
+
+Disadvantages:
+
+-   Visual inconsistency with C++.
+-   Parentheses make parsing less likely to encounter ambiguity.
+-   Optional parentheses lead to two ways of doing the same thing, although
+    disallowing them entirely could address this.