I don't see a var in your example?
Basically, we can use def and have flow typing (which would be the behavior
if we make var always an alias for def) or we can behave like Java:
// Java
import java.util.Date;
public class Main {
public static void main(String[] args) {
var x = new Object() {
public void myMethod() { System.out.println(new Date());}
};
x.myMethod(); // okay because the inferred type is the AIC
var y = new Main();
y = new Main() { // reassignment okay because new type is subclass of
inferred type
public void myMethod() { System.out.println(new Date());}
};
// y.myMethod(); // <=== error: cannot find symbol
// symbol: method myMethod()
// location: variable y of type Main
// y = new Integer(3); // <=== error: incompatible types: Integer cannot be
converted to Main
}
}
which effectively means that we infer as we do now but no flow typing.
Conceptually, you may think that in the above Java example that var y has
type Main (typeof RHS) but that isn't reflected in the bytecode in the same
way that a type for a field or parameter would be reflected, so it's much
more a concept that the compiler knows about rather than a concept that the
bytecode knows about. Currently flow typing allows both the above "error"
lines to succeed. But to behave like Java, we need both to fail.
Cheers, Paul.
On Sat, Mar 24, 2018 at 3:14 AM, MG <mg...@arscreat.com> wrote:
> Hi Paul,
>
> wouldn't it make sense to combine flow typing with var x = RHS being
> identical to typeof(RHS) x = RHS :
>
> @Canonicalstatic class Foo {
> int x}
> @InheritConstructorsstatic class SonOfFoo extends Foo {
> int sonOfFooMethod() { 2*x }
> }
>
> @Test@Ignore@CompileStaticvoid flowTypedVar() {
> SonOfFoo f = new SonOfFoo(21)
> //f = new Foo(-1) // compile time fails with "Groovyc: [Static type
> checking] - Cannot assign value of type groovy.GroovyGeneralSpike$Foo to
> variable of type groovy.GroovyGeneralSpike$SonOfFoo" //f.sonOfFooMethod()
> // compile time fails with "Groovyc: [Static type checking] - Cannot find
> matching method groovy.GroovyGeneralSpike$Foo#sonOfFooMethod()." if(f
> instanceof SonOfFoo) {
> println f.sonOfFooMethod() // works because of flow typing }
> }
>
> Cheers,
> mg
>
>
>
>
> On 23.03.2018 15:42, Paul King wrote:
>
> The Parrot parser already has support for this at the grammar level but we
> regard some of the current implementation details as experimental.
>
> At the moment it is almost just an alias for "def" but discussions have
> been around whether we can make the behavior closer to Java when used
> within static Groovy code. We haven't defined exactly what this would mean
> yet but roughly I suspect it could mean the same inferencing as now but
> without flow typing.
>
> Cheers, Paul.
>
>
> On Fri, Mar 23, 2018 at 10:12 PM, Merlin Beedell <mbeed...@cryoserver.com>
> wrote:
>
>> I see that the newly release JDK 10 now supports the “var” declaration
>> for local variables where the type can clearly be inferred from its
>> initialiser:
>>
>>
>>
>> http://openjdk.java.net/jeps/286
>>
>>
>>
>> I note that Groovy’s “def” syntax (among others) was mentioned but
>> rejected.
>>
>>
>>
>> Would Groovy move to support this syntax in the same way (support ‘var’
>> only for Type Safe inferred declarations) or as a general alias to the
>> “def” keyword?
>>
>>
>>
>> JDK 10 also has support for “docker” containers. The ecosystem has
>> certainly shifted!
>>
>>
>>
>> Merlin Beedell
>>
>>
>>
>
>
>
