How to handle Collection.toArray()

[Tako Schotanus]

Ok, I need some help figuring this out.

I want to implement Java's Collection interface on a Ceylon object that wraps a Ceylon Iterable like this:

    shared class JavaCollection<T>({T*} items) satisfies JCollection<T> { }

But there's one method that's giving me trouble, in the Java interface it's:

    Object[] toArray()

which gets translated in Ceylon to:

    shared actual ObjectArray<Object> toArray() { }

I'm trying something like this:

    shared actual ObjectArray<Object> toArray() => arrays.toObjectArray(items);

but obviously the the toObjectArray() method returns a T[], not an Object[].

I thought I could maybe change the signature to return ObjectArray<Anything> but that can't work either.

So is there a way to make this work in Ceylon or am I stuck with implementing this in Java?

-Tako

[Stephane Epardaud]

Did you try arrays.toObjectArray<Object>(items)?

--
You received this message because you are subscribed to the Google Groups "ceylon-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ceylon-dev+...@googlegroups.com.
To post to this group, send email to ceylo...@googlegroups.com.
Visit this group at http://groups.google.com/group/ceylon-dev?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.
 
 

--
Stéphane Épardaud

[Tako Schotanus]

Yes, it will then complain: argument must be assignable to parameter values of toObjectArray: {T*} is not assignable to {Object*}

-Tako

[Stephane Epardaud]

arrays.toObjectArray<Anything>(items)?

[Tako Schotanus]

specified expression type must be assignable to declared return type: ObjectArray<Anything> is not assignable to ObjectArray<Object>

-Tako

[Stephane Epardaud]

Interesting. This may be related to the model loader and our mapping of types, because in theory it shouldn't even be ObjectArray<Object> but ObjectArray<Object?>, no?

[Tako Schotanus]

Right, it seems we're being too strict in our mapping. But I'm not sure where/how exactly it should be relaxed.

But even though ObjectArray<Object?> should definitely be possible it still wouldn't solve this problem.

I guess Gavin will have to take a look at this.

-Tako

[Stephane Epardaud]

What about:

 shared actual ObjectArray<Anything> toArray() => arrays.toObjectArray<Anything>(items);

[Tako Schotanus]

No, I mentioned that in the original mail, the typechecker doesn't think that implements the interface.

-Tako

[Stephane Epardaud]

So we have a more general problem with interop and type parameters then. Because when a Java interface says it returns X<Y> it may mean any combination of X<Y>?, X<Y?>?, X<Y> or X<Y?> in reality. I'm pretty sure we already support X<Y>? and X<Y> but not the rest.

[Tako Schotanus]

Yes, the last one we support.

This is first a spec issue, right? With possibly/probably repercussions in the compiler.

So shall I open an issue for it on spec?

-Tako

[Stephane Epardaud]

This is a jvm compiler issue. It's mostly about the model loader, though it requires a bit of support in the typechecker to let things pass. Perhaps we can generalise the current solution for java types and optionality.

[Ross Tate]

I think arrays.toObjectArray<T> should accept a {T?*} rather than a {T*} (and still return an ObjectArray<T>).

[Gavin King]

That looks right to me, assuming ObjectArray<T> is an Iterable<T?>, which would be the correct thing...

Sent from my iPhone

[Stéphane Épardaud]

It is not Iterable.

Sent from my phone

[Gavin King]

OK then what I mean is assuming an element can be null.

Sent from my iPhone