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.