Early versions of the C++ programming language included an optional mechanism for checked exceptions, called "exception specifications". By default any function could throw any exception, but this could be limited by a clause added to the function signature, that specified which exceptions the function may throw. Exception specifications were not enforced at compile-time. Violations resulted in the global function being called. An empty exception specification could be given, which indicated that the function will throw no exception. This was not made the default when exception handling was added to the language because it would have required too much modification of existing code, would have impeded interaction with code written in other languages, and would have tempted programmers into writing too many handlers at the local level. Explicit use of empty exception specifications could, however, allow C++ compilers to perform significant code and stack layout optimizations that are precluded when exception handling may take place in a function. Some analysts viewed the proper use of exception specifications in C++ as difficult to achieve. This use of exception specifications was included in C++03, deprecated in the 2012 C++ language standard (C++11), and was removed from the language in C++17. A function that will not throw any exceptions can now be denoted by the keyword.