clarify relation of CTFE correctness and const safety

[web.git] / ralf / _posts / 2018-07-19-const.md

diff --git a/ralf/_posts/2018-07-19-const.md b/ralf/_posts/2018-07-19-const.md
index d93a6cddaf021ce1fd7341c730ad98b7b6a215af..23e9325ba43555e8b20de0e12f2b0f7783887fc7 100644 (file)
--- a/ralf/_posts/2018-07-19-const.md
+++ b/ralf/_posts/2018-07-19-const.md
@@ -34,7 +34,10 @@ We say that the `3 + 4` above is in *const context* and hence subject to CTFE, b
 Not all operations can be used in const context.
 For example, it makes no sense to compute your array length as "please go read that file from disk and compute something" -- we can't know what will be on the disk when the program actually runs.
 We could use the disk of the machine compiling the program, but that does not sound very appearling either.
-In fact, it would also be grossly unsafe:
+Things get even worse when you consider letting the program send information to the network.
+Clearly, we don't want CTFE to have actually observable side-effects outside of compilation.
+
+In fact, just naively letting programs read files would also be grossly unsafe:
 When computing the length of an array twice, it is important that we obtain the same result.
 
 > *CTFE must be deterministic.*
@@ -135,7 +138,8 @@ So, we will likely have to live with either considering floating point operation
 I think it is possible to achieve CTFE correctness for all other operations, and I think we should strive to do so.
 
 Before we go on, notice that CTFE correctness as defined above does not say anything about the case where CTFE fails with an error, e.g. because of an unsupported operation.
-That is a deliberate choice because it lets us gradually improve the operations supported by CTFE, but it is a choice that not everyone might agree with.
+CTFE would be trivially correct (in the above sense) if it just always immediately returned an error.
+However, since const-safe programs cannot error during CTFE, we know from CTFE correctness that *those* programs *do* in fact behave exactly the same at compile-time and at run-time.
 
 ## Unsafe Blocks in Const Context
 
@@ -228,8 +232,10 @@ I am not sure which effect that should or will have for promotion.
 ## Conclusion
 
 I have discussed the notions of CTFE determinism and CTFE correctness (which are properties of a CTFE engine like miri), as well as const safety (property of a piece of code) and const soundness (property of a type system).
+In particular, I propose that *when type-checking safe code in const context, we guarantee that this code is const-safe*, i.e., that it will not hit a CTFE error (though panics are allowed, just like they are in "run-time" Rust code).
+
 There are still plenty of open questions, in particular around the interaction of [`const fn` and traits](https://github.com/rust-lang/rust/issues/24111#issuecomment-311029471), but I hope this terminology is useful when having those discussions.
 Let the type systems guide us :)
 
-Thanks to @oli-obk for feedback on a draft of this post.
+Thanks to @oli-obk for feedback on a draft of this post, and to @centril for interesting discussion in #rust-lang that triggered me into developing these ideas and terminology.
 If you have feedback or questions, [let's discuss in the internals forum](https://internals.rust-lang.org/t/thoughts-on-compile-time-function-evaluation-and-type-systems/8004)!