---

yaml
---
r: 11787
b: refs/heads/master
c: d7ae9f1
h: refs/heads/master
i:
  11785: 0a451be
  11783: fdca1ea
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 813c41362b3588ab336b57ac6e2f1e0eb3f305e2
+refs/heads/master: d7ae9f1370fc14cd77f9da6b547e533cebf7e12b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/keywords.txt

@@ -7,7 +7,7 @@ do
 else export
 f32 f64 fail false float fn for
 i16 i32 i64 i8 if import in int
-let log
+let log loop
 mod mutable
 native note
 obj  

trunk/doc/rust.md

@@ -216,7 +216,7 @@ do
 else enum export
 fail false fn for
 if iface impl import
-let log
+let log loop
 mod mutable
 native
 pure
@@ -1901,6 +1901,38 @@ do {
 } while i < 10;
 ~~~~
 
+### Infinite loops
+
+A `loop` expression denotes an infinite loop:
+
+~~~~~~~~{.ebnf .gram}
+loop_expr : "loop" '{' block '}';
+~~~~~~~~
+
+For a block `b`, the expression `loop b` is semantically equivalent to
+`while true b`. However, `loop`s differ from `while` loops in that the
+typestate analysis pass takes into account that `loop`s are infinite.
+
+For example, the following (contrived) function uses a `loop` with a
+`ret` expression:
+
+~~~~
+fn count() -> bool {
+  let i = 0;
+  loop {
+    i += 1;
+    if i == 20 { ret true; }
+  }
+}
+~~~~
+
+This function compiles, because typestate recognizes that the `loop`
+never terminates (except non-locally, with `ret`), thus there is no
+need to insert a spurious `fail` or `ret` after the `loop`. If `loop`
+were replaced with `while true`, the function would be rejected
+because from the compiler's perspective, there would be a control path
+along which `count` does not return a value (that is, if the loop
+condition is always false).
 
 ### Break expressions