should convert_to_foreign call COERCE?

[Sam S. <sd...@gn...>]

Right now convert_to_foreign errors out if the lisp object does not have the 
precise type.
e.g.:
(setq mem (ffi:foreign-allocate 'ffi:double-float))
==> #<FOREIGN-VARIABLE FFI:FOREIGN-ALLOCATE #x0000000016F61390>
(setf (ffi:memory-as mem 'ffi:double-float) 2d0)
==> 2.0d0
(ffi:memory-as mem 'double-float)
==> 2.0d0
but
(setf (ffi:memory-as mem 'ffi:double-float) 2)
*** - FFI::WRITE-MEMORY-AS: 2 cannot be converted to the foreign type
       DOUBLE-FLOAT

is this the desirable behavior?
wouldn't it be better to call COERCE if the value has the wrong type?
this is mostly relevant to coercing to floats because CLISP has a tendency to 
return the integer 0 when it can, e.g., (sin 0) ==> 0.
in fact, come to think of it, the patch should be fairly trivial:

--- foreign.d.~1.200.~	2009-12-30 15:26:59.000000000 -0500
+++ foreign.d	2010-07-28 17:27:36.000878000 -0400
@@ -2041,12 +2041,12 @@ modexp maygc void convert_to_foreign
        return;
      } else if (eq(fvd,S(single_float))) {
        var ffloatjanus* pdata = (ffloatjanus*) data;
-      if (!single_float_p(obj)) goto bad_obj;
+      if (!single_float_p(obj)) obj = coerce_float(obj,S(single_float));
        FF_to_c_float(obj,pdata);
        return;
      } else if (eq(fvd,S(double_float))) {
        var dfloatjanus* pdata = (dfloatjanus*) data;
-      if (!double_float_p(obj)) goto bad_obj;
+      if (!double_float_p(obj)) obj = coerce_float(obj,S(double_float));
        DF_to_c_double(obj,pdata);
        return;
      } else if (eq(fvd,S(boolean))) {


objections?