Ceylon

Introduction

Vous avez certainement entendu parler du nouveau langage de JVM que prépare Red Hat, Ceylon. Le projet est encore en cours de développement mais il est déjà possible de l’essayer et un plugin Eclipse est disponible (Java 7 nécessaire).

Pour rappel, ce langage est orienté objet, à typage statique et intègre des notions de programmation fonctionnelle (« high-order functions »).

Le leitmotiv de ce nouveau langage est : « Say more, more clearly ». Gavin King, à l’origine du projet, explique : « We want to see plain, readable code, not executable ASCII-art. ». Le but de cette simplification étant de rendre le code Ceylon lisible à toute personne initiée à un langage comme Java ou C#.

Quelques features

Je ne vais pas vous refaire la documentation du langage, que vous trouverez ici, mais vous présenter quelques features intéressantes.

Unions et intersections

Le système de typage est assez puissant. Il est possible définir des variables en tant qu’union ou intersection de types.

Unions :

1
Student|Teacher person = … ;

Intersections :

1
Comparable&Printable element = … ;

Si l’on prend le code suivant :

1
2
3
for (i in {"toto",123,null}) {
      print(i else "vide");
}

Le compilateur est capable de faire de l’inférence sur la variable « i » et de lui attribuer le type :

1
String|Integer|Nothing

La fin des NullPointerException

Dans Ceylon, une variable « nullable » doit être définit explicitement en tant que telle :

1
String|Nothing titre = … ;

« null » est en fait une instance du type Nothring. Du sucre syntaxique permet d’utiliser « ? » en tant qu’abréviation :

1
String? titre = … ;

Dans ce cas, le compilateur de Ceylon vous obligera à vérifier si la valeur est « null » avant de faire quoi que ce soit avec.

Ce code provoquera une erreur à la compilation :

1
2
3
4
5
void allo() {
      for (i in {"allo",null}) {
            print(i);
      }
}

Avec les vérifications nécessaire, ça se passe beaucoup mieux :

1
2
3
4
5
void allo() {
      for (i in {"allo",null}) {
            print(i else "toto");
      }
}
1
2
3
4
5
void allo() {
      for (i in {"allo",null}) {
            print(i ? "toto");
      }
}

Surcharge

Ceylon ne supporte pas la surcharge de méthode ou de constructeur. Cependant, on peut facilement s’en passer dans la majorité des cas grâce aux valeurs par défaut et à l’union de types.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Person(String|Integer matricule="Not defined"){

     shared void printMatricule(){
           switch (matricule)
                 case (is String) {
                       print("Nom : " matricule "");
                 }
                 case (is Integer){
                      print("Numero : " matricule "");
                 }
     }
}

void hello() {
     Person person1 = Person(123);
     Person person2 = Person("toto");
     Person noOne = Person();

     person1.printMatricule();
     person2.printMatricule();
     noOne.printMatricule();
}

Sortie :

1
2
3
Numero : 123
Nom : toto
Nom : Not defined

Avec ces outils, ne pas avoir de surcharge ne devrait pas être un problème même si cela doit amener à voir les choses différement.

Paramètres nommés :

Lorsque l’on se retrouve avec des constructeurs un peu gourmand en paramètres, on est souvent un peu perdu dans l’ordre des paramètres à passer. Il ne faut pas non plus compter sur Eclipse pour nous aider, ce dernier se contentant de nous donner la liste des types (bien qu’IntelliJ le fasse). Mais lorsque le langage supporte les paramètres nommés, c’est une autre histoire.

Si l’on prend deux classes Person et Job definit comme ci-dessous :

1
2
3
4
5
6
7
8
import java.util { Date }

class Person(String? firstname,
             String? lastname,
             List jobs,
             Date birthDate,
             String|Integer matricule="Not defined"){
}
1
2
3
4
5
6
import java.util { Date }

class Job (String title,
           String firm,
           Date hiringDate){
}

Il est possible de les instancier de cette manière :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Person person = { firstname = "Mon prénom";
                  lastname = "Mon nom";
                  birthDate = Date(...);
                  jobs = {
                          Job{
                              title = "engineer";
                              firm = "Entreprise1";
                              hiringDate = Date(...);
                              },
                          Job{
                              title = "engineer";
                              firm = "Entreprise2";
                              hiringDate = Date(...);
                              }
                  };
                 }

Ici, l’ordre de passage des paramètres n’a pas d’importance. Outre la simplification à l’écriture, la lisibilité est ainsi bien meilleur.

PS : Vous remarquerez au passage l’interopérabilité avec Java, mais je ne m’étenderais pas sur ce sujet aujourd’hui.

Conclusion

Le langage n’est pas encore terminé mais la documentation donne déjà une bonne idée de ce qu’il sera possible de faire. Il y a bien d’autres features intéressantes comme la gestion de l’héritage multiple. Ce langage n’invente pas grand chose mais tente d’intégrer les meilleurs points d’autres langages. Finalement, du côté de la syntaxe, je trouve qu’il réussi à trouver un bon compromis entre la lisibilité et la concision du code.
Pour la suite, je vous laisse vous renseigner sur www.ceylon-lang.org.

VN:R_U [1.9.22_1171]
Rating: 0 (from 0 votes)
Share
Ce contenu a été publié dans Non classé. Vous pouvez le mettre en favoris avec ce permalien.

Laisser un commentaire