"With"-Operator
A new operator '=>' has been added to the language and a corresponding extension method for java.lang.Object on the left hand side and a lambda expression on the right hand side.
The with operator allows you to write:
new JTextField => [
text = 'My Text'
]
Think of it as a let-expression, which allows for binding any object to the scope of the block, in order to do side-effects in it. Very handy when initializing objects.
Properties
A new annotation @Property will generate a Java-Bean-style getter and setter (if the field is not final) for an annotated field.
class Person {
@Property String firstName
@Property String lastName
}
The field itself will be renamed to _fieldname, to make one accesses the getter (resp. setter) when using the property syntax. OF course a getter or setter is only generated when not explicitly defined.
Data Classes (Value Objects)
Another annotation @Data, will turn an annotated class into a value object class. A class annotated with @Data has the following effect:
- all fields are flagged final,
- getter methods will be generated (if not existent),
- a constructor will be generated (if not existent),
- equals(Object) / hashCode() methods will be generated (if not existent),
- a toString() method will be generated (if not existent).
Example:
@Data class Person {
String firstName
String lastName
}
For now the processing of the two annotations is hard coded into the compiler. However as described in this bugzilla, we want to add support for library level annotation processing. This will allow for adding other annotations like @Delegate etc. Also we want to make this very easy so you can easily define your own project-specific annotations. Unfortunately this will not make it into the upcoming release.
Multiple Classes in One File
You can now have any number of classes in a single file. Also the name of the first class must no longer match the file's name. But still if it matches it will be renamed in a rename refactoring.
Enhanced Field Declarations
Type inference for fields is now working, also the val and var keywords are available.
Example:
class Person {
@Property val firstName = 'Hans'
@Property var lastName = 'Meier'
}
Other areas we've been working on
Besides enhancing the language, we put a lot of effort into the IDE as well. Several new features like for instance a quick assist to add method declarations have been added. Also Sebastian is working on a rewrite of the type inference and linking engine, since the current implementation turned out to be a bit slow in certain situations.
