| > For example any such function can be marked with __attribute__((pure)) in compilers like gcc and clang. https://gcc.gnu.org/onlinedocs/gcc/Common-Attributes.html states: > However, functions declared with the pure attribute can safely [...] in a way that does not affect [...] or the observable state of the program So an exception-aware FP op cannot be __attribute__((pure)) in a program that may read the FP status later, or has trapping on FP exceptions enabled. This is obvious from the fact that gcc & clang will entirely delete a call to a pure function if the result isn't used, thereby making potential FP traps not happen, or accrued exceptions not mutated. (also traps on exceptions would make FP ops clearly not pure by the definition in functional programming too) > If exceptions were enabled only for a part of the program, then the rest of the program can still generate special values and you need to test for them everywhere. So you get the worst of both choices, a complex program that can be crashed by an error. Would be perfectly fine if combined with separate NaNful and NaNless types; design the language s.t. exception handling state must always be (or is automatically set to) the necessary one, and you never get NaNs in the NaNless types. |