Xtend Programming Language

Transcription

1 Xtend Programming Language Produced by: Eamonn de Leastar Department of Computing and Mathematics

2 Agenda Subtitle Excellent Xtend User Guide (Version 2.6) API Docs (version 2.8) In Xtend everything is an expression and has a return type. Statements do not exist. 2

3 Hello World xtend class HelloWorld def static void main(string[] args) println("hello World") java public class HelloWorld public static void main(string[] args) System.out.println("Hello World"); 3

4 Relevant XTend Features (for pace-consolextend) Java Interoperability Type Inference Conversion Rules Classes Constructors Fields Methods Override Inferred return types Expressions Literals Casts Field access & method invocation Constructor call Lambda Expressions If expression switch Expression return 4

5 Type inference Xtend and Java statically typed language (type checking done at compile time). Supports Java's type system i.e. primitive types, arrays all Java classes, interfaces, enums and annotations that reside on the class path. With Java, you are forced to write type signatures over and over again it s not a problem of static typing but simply a problem with Java. Although Xtend is statically typed just like Java, you rarely have to write types down because they can be computed from the context. 5

6 public static void main(string[] args) List<String> names = new ArrayList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); System.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); System.out.println(short_names.size()); for (String s : short_names) System.out.println(s); def static void main(string[] args) var names = new ArrayList<String>() names.add("ted") names.add("fred") names.add("jed") names.add("ned") System.out.println(names) var e = new Erase() var short_names = e.filterlongerthan(names, 3) System.out.println(short_names.size()) for (s : short_names) System.out.println(s) Type inference Java XTend 6

7 public static void main(string[] args) List<String> names = new ArrayList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); System.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); System.out.println(short_names.size()); for (String s : short_names) System.out.println(s); def static void main(string[] args) var names = new ArrayList<String>() names.add("ted") names.add("fred") names.add("jed") names.add("ned") System.out.println(names) var e = new Erase() var short_names = e.filterlongerthan(names, 3) System.out.println(short_names.size()) for (s : short_names) System.out.println(s) Type inference Java XTend 7

8 Conversion Rules In addition to Java's autoboxing to convert primitives to their corresponding wrapper types (e.g. int is automatically converted to Integer when needed), there are additional conversion rules in Xtend. Arrays are automatically converted to List<ComponentType> when needed and vice versa. This is valid Xtend code: def tolist(string[] array) val List<String> aslist = array return aslist Subsequent changes to the array are reflected by the list and vice versa. Arrays of primitive types are converted to lists of their respective wrapper types. Conversion works the other way around too, similar to Java s unboxing: all subtypes of Iterable are automatically converted to arrays on demand. 8

9 Relevant XTend Features (for pace-consolextend) Java Interoperability Type Inference Conversion Rules Classes Constructors Fields Methods Override Inferred return types Expressions Literals Casts Field access & method invocation Constructor call Lambda Expressions If expression switch Expression return 9

10 Classes At a first glance an Xtend file pretty much looks like a Java file. It starts with a package declaration followed by an import section and class definitions. The classes in fact are directly translated to Java classes in the corresponding Java package (see the xtend-gen folder). package acme.com import java.util.list class MyClass String name new(string name) this.name = name An Xtend class can have constructors, fields, methods and annotations. def String first(list<string> elements) elements.get(0) 10

11 Class Declaration The class declaration reuses a lot of Java's syntax but still is a bit different in some aspects: All Xtend types are public by default. Xtend supports multiple public top level class declarations per file. Each Xtend class is compiled to a separate top-level Java class. Abstract classes are defined using the abstract modifier as in Java. 11

12 Constructors An Xtend class can define any number of constructors. Unlike Java you do not have to repeat the name of the class over and over again, but use the keyword new to declare a constructor. Constructors can also delegate to other constructors using this() in their first line. class MyClass String name new(string name) this.name = name def String first(list<string> elements) elements.get(0) class MySpecialClass extends MyClass new(string s) super(s) new() //delegating to the first constructor above this("default") 12

13 Fields A field can have an initializer. Final fields are declared using val, while var introduces a non-final field (and can be omitted). If an initializer expression is present, the type of a field can be inferred only if val or var was used to introduce the field. The keyword final is synonym to val. Fields marked as static will be compiled to static Java fields. The default visibility for fields is private. You can also declare it explicitly as being public, protected, package or private. class MyDemoClass int count = 1 static boolean debug = false var name = 'Foo' // type String is inferred val UNIVERSAL_ANSWER = 42 // final field with inferred type int 13

14 Methods Xtend methods are declared within a class and are translated to a corresponding Java method with exactly the same signature. Method declarations start with the keyword def. The default visibility of a method is public; you can explicitly declare it as being public, protected, package or private. class MyClass String name new(string name) this.name = name def String first(list<string> elements) elements.get(0) def static createinstance() new MyClass('foo') 14

15 Inferred Return Types If the return type of a method can be inferred from its body it does not have to be declared. Notice also that the keyword, return, is not used. Return types must be explicit in abstract and recursive methods. def String first(list<string> elements) elements.get(0) def first(list<string> elements) elements.get(0) 15

16 Overriding Methods Methods can override methods from the super class or implement interface methods using the keyword override. If a method overrides a method from a super type, the override keyword is mandatory and replaces the keyword def. The override semantics are the same as in Java, e.g. it is impossible to override final methods or invisible methods. class MyClass String name new(string name) this.name = name def String first(list<string> elements) elements.get(0) class MySpecial extends MyClass new(string s) super(s) Overriding methods inherit their return type from the super declaration. override first(list<string> elements) elements.get(1) 16

17 Relevant XTend Features (for pace-consolextend) Java Interoperability Type Inference Conversion Rules Classes Constructors Fields Methods Override Inferred return types Expressions Literals Casts Field access & method invocation Constructor call Lambda Expressions If expression switch Expression return 17

18 Collection Literals Convenient to create instances of the various collection types the JDK offers. val mylist = newarraylist('hello', 'World') val mymap = newlinkedhashmap('a' -> 1, 'b' -> 2) Xtend supports collection literals to create immutable collections and arrays, depending on the target type. val mylist = #['Hello','World'] If the target type is an array, an array is created instead without any conversion: val String[] myarray = #['Hello','World'] An immutable set can be created using curly braces instead of the squared brackets: val myset = #'Hello','World' val mymap = #'a' -> 1,'b' ->2 An immutable map is created like this: 18

19 Type Casts A type cast behaves exactly like casts in Java, but has a slightly more readable syntax. something as MyClass 42 as Integer 19

20 Null-Safe Feature Call Checking for null references can make code very unreadable. if (myref!= null) myref.dostuff() In many situations it is ok for an expression to return null if a receiver was null. Xtend supports the safe navigation operator?. to make such code more readable. myref?.dostuff 20

21 Elvis class Person String title String firstname In addition to null-safe feature calls, Xtend supports the Elvis operator (?:) known from Groovy. The right hand side of the expression is only evaluated if the left side was null. val person = new Person(null, 'John') val salutation = person.title?: 'Sir/Madam' println(salutation) Prints Sir/Madam to the console val person = new Person( Master', 'John') val salutation = person.title?: 'Sir/Madam' println(salutation) Prints Master to the console 21

22 Variable Declarations A variable declaration starting with the keyword val denotes a value, which is essentially a final, unsettable variable. The variable needs to be declared with the keyword var, which stands for 'variable' if it should be allowed to reassign its value. Xtend val max = 100 var i = 0 while (i < max) println("hi there!") i = i + 1 Generated Java final int max = 100; int i = 0; while ((i < max)) InputOutput.<String>println("Hi there!"); i = (i + 1); 22

23 Typing The type of the variable itself can either be explicitly declared or it can be inferred from the initializer expression. Explicit declaration: the type of the right hand expression must conform to the type of the expression on the left side. var List<String> strings = new ArrayList Inferred declaration: the type can be inferred from the initializer. var strings = new ArrayList<String> 23

24 Constructor Call Constructor calls have the same syntax as in Java. The only difference is that empty parentheses are optional e.g.: new String() == new String new ArrayList<BigDecimal>() == new ArrayList<BigDecimal> If type arguments are omitted, they will be inferred from the current context similar to Java's diamond operator on generic method and constructor calls. var stringlist = new ArrayList // type will be ArrayList <String> stringlist.add("first Element") println(stringlist.get(0)) 24

25 Lambda Expressions (1) A lambda expression is basically a piece of code, which is wrapped in an object to pass it around. As a Java developer it is best to think of a lambda expression as an anonymous class with a single method. These kind of anonymous classes can be found everywhere in Java code and have always been the poorman's replacement for lambda expressions in Java. // Java Code final JTextField textfield = new JTextField(); textfield.addactionlistener(new public void actionperformed(actionevent e) textfield.settext("something happened!"); ); 25

26 Lambda Expressions (2) Xtend not only supports lambda expressions, but offers an extremely dense syntax for it. // Xtend Code val textfield = new JTextField // Java Code final JTextField textfield = new JTextField(); textfield.addactionlistener(new public void actionperformed(actionevent e) textfield.settext("something happened!"); ); textfield.addactionlistener([ ActionEvent e ]) textfield.text = "Something happened!" 26

27 Lambda Expressions (3) Lambda expression is surrounded by square brackets (inspired from Smalltalk). Also a lambda expression like a method declares parameters. The lambda here has one parameter : e which is of type ActionEvent. textfield.addactionlistener([ e textfield.text = "Something happened!" ]) You do not have to specify the type explicitly because it can be inferred from the context. 27

28 Lambda Expressions (4) Also as lambdas with one parameter are a common case, there is a special short hand notation for them, which is to leave the declaration including the vertical bar out. textfield.addactionlistener([ textfield.text = "Something happened!" ]) The name of the single variable will be it in that case. Since you can leave out empty parentheses for methods which get a lambda as their only argument, you can reduce the code above further down. textfield.addactionlistener [textfield.text = "Something happened!"] 28

29 textfield.addactionlistener(new public void actionperformed(actionevent e) textfield.settext("something happened!"); ); textfield.addactionlistener([ ActionEvent e textfield.text = "Something happened!" ]) textfield.addactionlistener([ e textfield.text = "Something happened!" ]) textfield.addactionlistener([ textfield.text = "Something happened!" ]) Java Code Xtend Code Inferred Type Shorthand for single parameter lambdas textfield.addactionlistener [textfield.text = "Something happened!"] 29 No parenthesis

30 Lambdas & Collections (1) The collections have been equipped with Extension Methods that take lambda as parameters e.g. classes ListExtensions, IterableExtensions, etc. def printall(arraylist<string> strings) strings.foreach [ s println(s) ] list.foreach[ element, index ].. // if you need access to the current index list.reverseview.foreach[ ].. // if you just need the element it in reverse order Can dramatically reduce number of loops in a program! 30

31 Lambdas & Collections (2) val strings = newarraylist("red", "blue", "green") val charcount = strings.map[s s.length].reduce[sum, size sum + size] println(charcount) Output is 12 strings.map[s s.length] The map method is in the ListExtensions class. It returns a list built using the Lambda expression i.e. Iterate through the ArrayList called strings, and for each object s found in the ArrayList, the length of the String s is added as an element to the returned List i.e. [3, 4, 5] is returned. reduce[sum, size sum + size] The reduce method is in the IterableExtensions class. It applies the function to all elements of the List [3, 4, 5] in turn i.e. given our list [3, 4, 5] and the function add (+), the result returned will be: add(add(3, 4), 5) 31

32 Switch Expression The switch expression is very different from Java's switch statement: there is no fall through which means only one case is evaluated at most. The use of switch is not limited to certain values but can be used for any object reference. Object.equals(Object) is used to compare the value in the case with the one you are switching over. switch mystring case mystring.length > 5 : print("a long string.") case 'some' : print("it\'s some string.") default : print("it\'s another short string.") 32

33 Switch Expression- Type guards Instead of or in addition to the case guard you can specify a type guard. The case only matches if the switch value conforms to this type. A case with both a type guard and a predicate only matches if both conditions match. def length(object x) switch x String case x.length > 0 : x.length // length is defined for String List<?> : x.size // size is defined for List default : -1 33

34 Relevant XTend Features (for pace-consolextend) Java Interoperability Type Inference Conversion Rules Classes Constructors Fields Methods Override Inferred return types Expressions Literals Casts Field access & method invocation Constructor call Lambda Expressions If expression switch Expression return 34

35 Active Annotations Xtend comes with ready-to-use active annotations for common code patterns. They reside in the org.eclipse.xtend.lib.annotations plug-in/jar which must be on the class path of the project containing the Xtend files. 35

36 @Accessors For fields that are annotated the Xtend compiler will generate a Java field, a getter and, if the field is non-final, a setter method. The generated methods are, by default, can be used at class level too class String name generates private String name; public String getname() return this.name; public void setname(final String name) this.name = name; 36

37 @Accessors You can use the AccessorType to change the PROTECTED_SETTER) int String internalfield PROTECTED_SETTER) private int private String internalfield public int getage() return this.age; protected void setage(final int age) this.age = age; 37

38 @Data The will turn an annotated class into a value object class. A class annotated is processed according to the following rules: all fields are final, getter methods will be generated (if they do not yet exist), a constructor with parameters for all noninitialized fields will be generated (if it does not exist), equals(object) / hashcode() methods will be generated (if they do not exist), a tostring() method will be generated (if it does not class Person String firstname String lastname 38

39 @Data class Person String firstname public class Person private final String _firstname; public String getfirstname() return this._firstname; private final String _lastname; public String getlastname() return this._lastname; public Person(final String firstname, final String lastname) super(); this._firstname = firstname; this._lastname = public int hashcode() final int prime = 31; int result = 1; result = prime * result + ((_firstname== null)? 0 : _firstname.hashcode()); result = prime * result + ((_lastname== null)? 0 : _lastname.hashcode()); return public boolean equals(final Object obj) if (this == obj) return true; if (obj == null) return false; if (getclass()!= obj.getclass()) return false; Person other = (Person) obj; if (_firstname == null) if (other._firstname!= null) return false; else if (!_firstname.equals(other._firstname)) return false; if (_lastname == null) if (other._lastname!= null) return false; else if (!_lastname.equals(other._lastname)) return false; return public String tostring() String result = new ToStringHelper().toString(this); return result; 39

40 Additional Reading: Features (1) Extension methods - enhance closed types with new functionality Lambda Expressions - concise syntax for anonymous function literals ActiveAnnotations - annotation processing on steroids Operator overloading - make your libraries even more expressive Powerful switch expressions - type based switching with implicit casts Multiple dispatch - a.k.a. polymorphic method invocation 40

41 Additional Reading: Features (2) Template expressions - with intelligent white space handling No statements - everything is an expression and has a return type Properties - shorthands for accessing and defining getters and setter Type inference - you rarely need to write down type signatures anymore Full support for Java generics - including all conformance and conversion rules Translates to Java not bytecode - understand what is going on and use your code for platforms such as Android or GWT 41

42 Features Relevant to pacemaker-console-x Extension methods - enhance closed types with new functionality Lambda Expressions - concise syntax for anonymous function literals ActiveAnnotations (@Accessors) - shorthands for accessing and defining getters and setter Powerful switch expressions - type based switching with implicit casts Type inference - you rarely need to write down type signatures anymore 42

43 Except where otherwise noted, this content is licensed under a Creative Commons Attribution-NonCommercial 3.0 License. For more information, please see