Introduction à Scala: Hello World

Scala Ce billet vient inaugurer une suite de billets visant à présenter quelques notions de base de Scala.

Comme il se doit dans de telles occasions, je vais commencer par l’inévitable Hello World, ou plus précisément comment récupérer ce qu’il faut pour faire du Scala et comment écrire, compiler et exécuter son premier programme.

Je vais commencer par les outils.
Malheureusement, Scala ne dispose pas encore de tooling décent, mais ça viendra, je n’en doutes pas.

En gros, vous avez le choix entre la méthode dure ou encore la méthode moins dure.

La méthode dure: ça consiste à télécharger la distribution Scala (la dernière version est la 2.7.0):

Il faut ensuite extraire l’archive téléchargé quelque part dans son disque (${SCALA_HOME}), et ajouter le dossier ${SCALA_HOME}/bin dans le PATH.

La méthode moins dure: ça consiste à passer par le plugin eclipse officiel de Scala.
Faites pointer un nouveau Update site (Remote) sur cette adresse:

http://www.scala-lang.org/downloads/scala-plugin/

N.B. Ce plugin nécessite eclipse 3.3.* et une JRE >= 5.0

Une fois le plugin installé et eclipse redémarré, vous disposerez d’un support décent de Scala mais pas plus.

Le plugin offre:
– Menu New:

Menu New

– Coloration Syntaxique

Coloriation syntaxique

– Emplacement des erreurs mais pas leur messages (ne me demandez pas pourquoi)

Erreurs

– Menu d’exécution et de débogage (qui marche parfois :) )

Exécution
– Voilou.

C’est encore très loin d’un tooling du calibre du JDT, mais c’est déjà infiniment plus pratique que de passer par le compilateur en ligne de commande.

Une fois votre environnement mis en place et configuré, il faudrait créer un fichier HelloWorld.scala avec le code suivant

object HelloWorld {    def main(args: Array[String]) {      val message = 'Hello World'     println(message)    }  }

Si vous êtes sous eclipse avec le plugin Scala, il suffit de passer par le menu Run, Run As, Scala Application.
En ligne de commande, il faudrait taper les commandes suivantes:

>cd "l'emplacement du fichier" 
>scalac HelloWorld.scala 
>scala HelloWorld 

Je vous laisse deviner la sortie de ce programme ;)

Passons maintenant à l’analyse de ce bout de code:

object HelloWorld {
Il s’agit ici de la déclaration d’un objet nommé HelloWorld.
Dans la terminologie Scala, un objet est grosso modo l’équivalent d’une classe Java complètement statique. Mais en réalité, Scala ne supporte pas la notion des membres statiques et propose plutôt les objets qui sont des singletons.
Si on a besoin d’un membre statique, il faut le déclarer dans un objet.

def main(args: Array[String]) {
Il s’agit ici de définir la méthode main de l’objet, i.e. la méthode où commence l’exécution du programme.
Une méthode est déclarée avec le mot clé def en Scala suivi par son nom, ses paramètres et son type de retour.
Comme je viens de le préciser, et à l’inverse de Java, la méthode main n’est pas statique (Scala n’a pas de notion de membres statiques), mais fait partie d’un objet (singleton).

Les paramètres de cette méthode sont toujours précisés entre parenthèses.
Là, un point capital dans Scala, les déclaration des variables est similaire à ce qu’on fait dans Pascal, c’est à dire de la forme “nom_de_la_variable : type_de_la_variable” et non pas comme dans les langages EcmaScript-like (C, C++, Java, JavaScript, etc.) où l’on procède plutôt par: “type_de_la_variable nom_de_la_variable

Comme pour Java, main prend un tableau de chaînes, représenté dans Scala par Array[String].
Je tiens tout d’abord à préciser que les crochets ici n’ont rien à voir avec les tableaux, et qu’il servent plutôt à déclarer les paramètres génériques d’un type (équivalent aux < et > de Java).

de plus, Scala est un langage orienté objet pur, dans la mesure où tout est soit un objet, soit un passage de message (appel de méthode) entre objets.
Donc exit les types primitifs (int, char, etc.) ou les types spéciaux (tableaux, etc.)
Ici, Array est un objet ordinaire et à part entière tout comme les listes par exemples.

Un autre point important à signaler ici est que malgré le côté objet pur de Scala, qui est une idée noble en théorie, mais généralement associée à de graves problèmes de performance en pratique, Scala transforme les objets aux types primitifs lors de la compilation là où c’est possible, ce qui élimine complètement les problèmes de performances.

val message = “Hello World”
Il s’agit ici d’une déclaration de variable, ou plus exactement d’une constante.
La déclaration commence par le mot clé val qui est l’équivalent du final de Java. On aurait pu aussi utiliser var au lieu de val pour ôter l’aspect constant de la variable.

S’en suit le nom de la variable, message ici, puis l’initialisation avec le littéral “Hello World”.

La question qui se pose est où est le type de la variable ?
Scala est un langage statiquement typé, et chaque membre doit obligatoirement avoir un type. Seulement, le compilateur de Scala est suffisamment intelligent pour reconnaître automatiquement le type d’un membre donné pour faire éviter au programmeur d’avoir à le spécifier explicitement tout le temps: c’est l’inférence de types.

Attention toutefois: ce n’est pas toujours possible d’avoir une inférence automatique, et il y’a des cas où l’on devrait spécifier explicitement le type de déclaration.

Dans ce cas-ci, vu que la partie droite de l’assignation est un littéral de type String, Scala infère automatiquement String comme type de message.

Si on voulait plutôt s’exercer à l’art de pourquoi-taper-moins-qunad-on-peut-taper-plus, on aurait pu déclarer explicitement le type ainsi:

val message : String = “Hello World”

Seulement, quand est ce qu’on sait si l’inférence de types est possible et quand est ce que ça ne l’est pas ?
Difficile de répondre … le moteur d’inférence de types de Scala est complexe, et il ne cesse d’évoluer au fil des versions.
En règle générale, essayez de ne pas déclarer les types jusqu’à ce que le compilateur s’en plaint ;)

Avant de passer à l’instruction suivante, vous l’aurez remarqué peut être déjà: les “;” sont optionnels dans Scala, dans la mesure où l’on met une instruction par ligne, ce qui est, j’espère, le cas tout le temps.
(Ce n’est pas la seule condition pour ne pas mettre des ; en fin de ligne en fait)

println(message)
L’instruction suivante est claire: ça affiche la valeur de message dans la console.
Notez juste le println introduit par Scala au lieu du system.out.println. Toutefois, il est toujours possible d’utiliser ce dernier si vous êtes adeptes de la règle citée plus haut :), chose possible grâce au fait que Scala importe implicitement tout le package java.lang mais aussi la compatibilité de Scala avec Java:

  • On peut utiliser les objets Java dans Scala
  • On peut étendre des classes Java dans Scala
  • On peut implémenter des interfaces Java avec Scala
  • Un programme Scala compilé tourne sur la JVM

L’autre sens n’est pas vrai.

Ainsi s’achève ce premier billet de la série “Introduction à Scala”, dans lequel j’ai présenté quelques notions (surfaciques) sur le langage de programmation Scala.

—-

Advertisements

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: