Allow loop in constant evaluation

text/0000-const-looping.md

@@ -0,0 +1,98 @@
+- Feature Name: const_looping
+- Start Date: 2018-02-18
+- RFC PR: (leave this empty)
+- Rust Issue: (leave this empty)
+
+# Summary
+[summary]: #summary
+
+Allow the use of `loop`, `while` and `while let` during constant evaluation.
+`for` loops are technically allowed, too, but can't be used in practice because
+each iteration calls `iterator.next()`, which is not a `const fn` and thus can't
+be called within constants.
+
+# Motivation
+[motivation]: #motivation
+
+Any iteration is expressible as a recursion. Since we already allow recursion
+via const fn and termination of said recursion via `if` or `match`, all code
+enabled by const recursion is already legal now. Writing loops with recursion is
+very tedious and can quickly become unreadable, while regular loops are much
+more natural in Rust.
+
+# Guide-level explanation
+[guide-level-explanation]: #guide-level-explanation
+
+If you previously had to write functional code inside constants, you can now
+change it to imperative code. For example if you wrote a fibonacci like
+
+```rust
+const fn fib(n: u128) -> u128 {
+ match n {
+ 0 => 1,
+ 1 => 1,
+ n => fib(n - 1) + fib(n + 1)
+ }
+}
+```
+
+which takes exponential time to compute a fibonacci number, you could have
+changed it to the functional loop
+
+```rust
+const fn fib(n: u128) -> u128 {
+ const fn helper(n: u128, a: u128, b: u128, i: u128) -> u128 {
+ if i <= n {
+ helper(n, b, a + b, i + 1)
+ } else {
+ b
+ }
+ }
+ helper(n, 1, 1, 2)
+}
+```
+
+but now you can just write it as an imperative loop, which also finishes in
+linear time.
+
+```rust
+const fn fib(n: u128) -> u128 {
+ let mut a = 1;
+ let mut b = 1;
+ let mut i = 2;
+ while i <= n {
+ let tmp = a + b;
+ a = b;
+ b = tmp;
+ i += 1;
+ }
+ b
+}
+```
+
+# Reference-level explanation
+[reference-level-explanation]: #reference-level-explanation
+
+A loop in MIR is a cyclic graph of BasicBlocks. Evaluating such a loop is no
+different from evaluating a linear sequence of BasicBlocks, except that
+termination is not guaranteed. To ensure that the compiler never hangs
+indefinitely, we count the number of terminators processed and once we reach a
+fixed limit, we report an error mentioning that we aborted constant evaluation,
+because we could not guarantee that it'll terminate.
+
+# Drawbacks
+[drawbacks]: #drawbacks
+
+* Loops are not guaranteed to terminate
+ * We catch this already by having a maximum number of basic blocks that we
+ can evaluate.
+* A guaranteed to terminate, non looping constant might trigger the limit, if it
+ has too much code.
+
+# Rationale and alternatives
+[alternatives]: #alternatives
+
+- Do nothing, users can keep using recursion
+
+# Unresolved questions
+[unresolved]: #unresolved-questions