Merge pull request #2341 from oli-obk/const_locals

Allow locals and destructuring in const fn

text/2341-const-locals.md

@@ -0,0 +1,68 @@
+- Feature Name: `const_locals`
+- Start Date: 2018-01-11
+- RFC PR: [rust-lang/rfcs#2341](/~https://github.com/rust-lang/rfcs/pull/2341)
+- Rust Issue: [rust-lang/rust#48821](/~https://github.com/rust-lang/rust/issues/48821)
+
+# Summary
+[summary]: #summary
+
+Allow `let` bindings in the body of constants and const fns. Additionally enable
+destructuring in `let` bindings and const fn arguments.
+
+# Motivation
+[motivation]: #motivation
+
+It makes writing const fns much more like writing regular functions and is
+not possible right now because the old constant evaluator was a constant folder
+that could only process expressions. With the miri const evaluator this feature
+exists but is still disallowed.
+
+# Guide-level explanation
+[guide-level-explanation]: #guide-level-explanation
+
+`let` bindings in constants and const fn work just like `let` bindings
+everywhere else. Historically these did not exist in constants and const fn
+because it would have been very hard to support them in the old const evaluator.
+
+This means that you can only move out of any let binding once, even though in a
+const environment obtaining a copy of the object could be done by executing the
+code twice, side effect free. All invariants held by runtime code are also
+upheld by constant evaluation.
+
+# Reference-level explanation
+[reference-level-explanation]: #reference-level-explanation
+
+Expressions like `a + b + c` are already transformed to
+
+```rust
+let tmp = a + b;
+tmp + c
+```
+
+With this RFC we can create bindings ourselves instead of only allowing compiler
+generated bindings.
+
+# Drawbacks
+[drawbacks]: #drawbacks
+
+You can create mutable locals in constants and then actually modify them. This
+has no real impact on the constness, as the mutation happens entirely at compile
+time and results in an immutable value.
+
+# Rationale and alternatives
+[alternatives]: #alternatives
+
+The backend already supports this 100%. This is essentially just disabling a
+check
+
+## Why is this design the best in the space of possible designs?
+
+Being the only design makes it the best design by definition
+
+## What is the impact of not doing this?
+
+Not having locals and destructuring severely limits the functions that can be
+turned into const fn and generally leads to unreadable const fns.
+
+# Unresolved questions
+[unresolved]: #unresolved-questions