(This bounced or got hung up the first time I sent it.) Hi Guys,
I work on Gosu, a JDK-based language, and I was talking w/ Charles Nutter and Ola Bini today (ed: now last week) at OSCON, and a general idea that I've been kicking around for a long time came up. They both didn't think it was crazy, so I figured I'd bounce it off this mailing list. Apologies if this has been discussed before. Here's the problem I have: I'd like to return my mutable collections to consumers as an immutable collection. Now, I know I can wrap my collections in immutable versions, but that isn't really what I want: I'm less concerned that the implementation is actually immutable, but I'd like the consumer of my collections to *know* statically that they aren't supposed to mutate the collection I'm handing them. Tt a practical level, the wrapping approach necessitates me either wrapping the mutable collection I've got in my class every time I return it or to maintain a second reference to the wrapped class, both of which are ugly. So, what I think I want is an interface like, for example, ReadableList, which has only the readable methods on List and none of the mutators. And, presumably, that would extend a ReadableCollection, which would have only the readable methods on Collection, and so on. (One point that Josh Bloch made was that Iterable breaks this, but I *think* you could introduce a ReadableIterator interface without the remove() method and use covariance return types in the mutable collections to make it all work out.) I could then return my mutable Lists as this interface, and send a strong signal to the caller that they shouldn't mutate them. (If they downcast... hey, we are all adults here, right?) Some sample code: class MyClass { List<String> someNames = ... public ReadableList<String> getSomeNames() { return someNames; } } So callers of MyClass#getSomeNames() will know that I don't intend for them to mutate the list. And, of course, it would be nice if these interfaces worked properly with the for() statement, etc. As a side note, I like the name ReadableList vs. the more obvious ImmutableList, since java.util.List would extend this interface and it isn't an ImmutableList. Anyway, this is obviously a very rough idea, but I'd like to hear what people think and what problems might come up when implementing it. Thanks, Carson