Serialization opt-in syntax (again)

[David M. Lloyd]

I like it, not so much as a solution for serializability but as a 
general tool and for the aforementioned "runway".

On 10/01/2012 09:47 AM, Brian Goetz wrote:
> We need to wrap this up.  Does anyone have a *significant objection* to
> the syntax (cast to intersection type) suggested below?
>
>> Here is another option that we explored a while ago and initially
>> turned our nose up at, but we are still willing to explore: using
>> intersection types in a cast to target type, inspired by multiple type
>> bounds in generics:
>>
>>     Predicate<String> ps = (Predicate<String> & Serializable) x->
>> x.isEmpty();
>>
>> The major downsides are:
>>  - Verbose (have to repeat the target type)
>>  - Another ad-hoc context where we allow intersection types, though
>> offers some runway in the event we want to extend the use of
>> intersection types in the future.
>>
>> It extends to inner class expressions in an OK manner:
>>
>>   new Foo(blah) & Serializable { ... }
>>
>> Again, the cast syntax can apply to any intersection of types that
>> meets the SAM-ness requirement, and the inner class syntax can be any
>> arbitrary set of interfaces.
>>
>>
>> On Sep 28, 2012, at 11:48 PM, Brian Goetz wrote:
>>
>>> Bob is definitely right here that the semantics of this are closer to
>>> what we want than any of the others.  While the proximate problem is
>>> "how do I make a serializable lambda", the way you make a class
>>> serializable in Java is (in part) to extend Serializable.  So
>>> something that addresses the "how to I extend Serializable" question
>>> is much more in the spirit of how serialization works (for better or
>>> worse) than a special magic serialization syntax.
>>>
>>>
>>> On Sep 28, 2012, at 4:14 PM, Bob Lee wrote:
>>>
>>>> I like the semantics a lot! Maybe moving the "implements" decl to
>>>> the right of the -> would address Kevin's concerns? Then it would
>>>> read "lambda (->) implements ..."
>>>>
>>>> Bob
>>>>
>>>> On Fri, Sep 28, 2012 at 1:47 PM, Brian Goetz <brian.goetz at oracle.com
>>>> <mailto:brian.goetz at oracle.com>> wrote:
>>>>
>>>>     I put all the candidate syntaxes so far in the JIRA issue for
>>>>     this, but a new one came to light this week that we kind of like.
>>>>
>>>>     The problem is: let's say you have a SAM that is not
>>>>     serializable, but you want the instance to be, such as in:
>>>>
>>>>       Runnable r = () -> { };
>>>>
>>>>     The problem is that we really want to specify multiple
>>>>     interfaces for the lambda, and as long as their intersection has
>>>>     only one abstract method, that should be OK.
>>>>
>>>>     So, how about using the space between the closing paren and the
>>>>     arrow:
>>>>
>>>>       Runnable r = () implements Serializable -> { ... }
>>>>
>>>>     As a bonus, if we wanted to be explicit about all the
>>>>     implemented interfaces, this easily extends to:
>>>>
>>>>       Object p = (String s) implements Predicate<String>,
>>>>     Serializable -> { ... }
>>>>
>>>>
>>>>     This also extends nicely to inner class creation expressions.
>>>>      Right now there is a limit of one named supertype.  But this
>>>>     could be extended:
>>>>
>>>>       Predicate<String> p = new Predicate<String>() implements
>>>>     Serializable { ... }
>>>>
>>>>     In this case, there is no single-method restriction; you could
>>>>     implement Iterator and Runnable if you wanted:
>>>>
>>>>       new Iterator<T>() implements Runnable { ... }
>>>>
>>>>     Note that none of this is serialization-specific; it is simply a
>>>>     way of being explicit about multiple supertypes in contexts
>>>>     there this was not previously allowed.
>>>>
>>>>
>>>
>>
>


-- 
- DML