Section on declaring function types with ftype is incorrect

[VisenDev]

This section says that a function may have multiple incompatible ftypes declarations.

cl-cookbook/performance.md

Lines 394 to 398 in 89018a5

	Another useful declaration is a `ftype` declaration which establishes
	the relationship between the function argument types and the return value type.
	If the type of passed arguments matches the declared types, the return value type
	is expected to match the declared one. Because of that, a function can have more
	than one `ftype` declaration associated with it. A `ftype` declaration restricts

However, after investigating this claim, i'm not sure if it is accurate. The hyperspec simply says that an ftype declaration "Specifies that the functions named by function-names are of the functional type type." I couldn't find anything about multiple ftype declarations being valid.

Furthermore, when testing with sbcl, I get a warning when defining two different ftypes for the same function.

CL-USER> (declaim (ftype (function (fixnum fixnum) fixnum) minus))
(MINUS)
CL-USER> (declaim (ftype (function (float float) float) minus))
WARNING:
   The new FTYPE proclamation for COMMON-LISP-USER::MINUS
     (FUNCTION (FLOAT FLOAT) FLOAT)
   does not match the old FTYPE proclamation
     (FUNCTION (FIXNUM FIXNUM) (VALUES FIXNUM &REST T))
(MINUS)
CL-USER> 

However, neither ECL. CLISP, or ABCL gave a similar warning.

[Bike]

The standard is pretty vague about how clashing proclamations work, but it is very explicit about function types:

Consider a declaration of the following form:
(ftype (function (arg0-type arg1-type ...) val-type) f))
Any form (f arg0 arg1 ...) within the scope of that declaration is equivalent to the following:
(the val-type (f (the arg0-type arg0) (the arg1-type arg1) ...))
That is, the consequences are undefined if any of the arguments are not of the specified types or the result is not of the specified type. In particular, if any argument is not of the correct type, the result is not guaranteed to be of the specified type.

I think it's fairly obvious that this definition of function types is not compatible with the idea of having multiple declarations apply, since the declarations could have incompatible consequences here. Also note that the conditional statement in the cookbook, "If the type of passed arguments matches the declared types, the return value type is expected to match the declared one." is incorrect, as the standard defines instead that the effects are undefined if the type of passed arguments doesn't match the declared types. Rather than the result just not being of the declared result type, an error could be signaled, you could get a segfault, etc.