ABCL has a built-in way of converting values from Java to Lisp:
JavaObject.getInstance(x, true), which covers the most common cases.
The contrary AFAIK is not as well-defined: conversion from Lisp to
Java is done in ad-hoc ways all over the place. This is not optimal,
especially for someone using abcl embedded into Java - someone who
might not know the rules and conventions used in abcl.
I believe the method LispObject.javaInstance(Class) could be used to
provide such a conversion facility. Currently it has not very clear
semantics: the one in LispObject does a type check to ensure "this" is
an instance of the class passed as parameter, however there are
overrides in subclasses which skip the check and happily return a
value in all cases, ignoring the parameter.
I propose the following unified semantics: x.javaInstance(c) returns a
value (x itself, or some other object) that is guaranteed to be of
class c (*) and to represent a value "similar" to x, for some meaning
of "similar". If such a value cannot be produced, a type error is
signaled. Examples:
LispObject.javaInstance(Boolean.{class|TYPE}) ==> true if this != NIL,
false otherwise
LispObject.javaInstance(anythingelse) ==> this if (this instanceof
anythingelse), error otherwise (like it does now)
Nil.javaInstance(Boolean.{class|TYPE}) ==> false
Nil.javaInstance(anything else) ==> null
AbstractString.javaInstance(CharSequence and subclasses) ==> the string
AbstractString.javaInstance(anything else) ==> error
...etc (numbers, what else?) ...
I.e. in general
x = y.javaInstance(c);
JavaObject.getInstance(x, true).equals(y) ==> true
and
x = JavaObject.getInstance(y, true);
x.javaInstance(y.getClass()).equals(y) ==> true
What do you think?
Bye,
Ale
---------------------
(*) or better, assignable to a variable of type c - this includes null
while the former doesn't.