ooc (langage)

« ooc » redirige ici. Pour les autres significations, voir OOC.

ooc est un langage de programmation compilé. Il permet d'allier la programmation orienté objet avec la programmation fonctionnelle avec une syntaxe simple qui favorise la lisibilité et la concision des programmes. L'implémentation principale traduit le code ooc en sources C puis utilise un compilateur C pour produire un exécutable.

Le langage ooc et la plupart de son écosystème sont placés sous la licence BSD. Il est conçu pour combiner une syntaxe simple avec la performance d'un langage compilé, tout en restant flexible. Il est développé par des individus dans leur temps libre. Sa bibliothèque standard est multiplateforme (Linux, Mac OS X, et Windows sont notamment supportés), grâce aux blocs de versions intégrés au langage.

ooc
Apparu en	17 mars 2009
Paradigme	Programmation orientée objet, structurée, impérative, fonctionnelle
Typage	Statique, fort, sûr, nominatif
Influencé par	Io, Ruby, Scala, Java
Implémentations	rock, j/ooc
Système d'exploitation	Multiplateformes
Licence	Licence BSD
Site web	ooc-lang.org

Caractéristiques

Syntaxe

ooc, tout comme le Python, a été conçu pour être lisible, et pour être facilement écrit par un humain dans un simple éditeur de texte. Les blocs sont délimités par des accolades, comme en C.

Le principe DRY est au cœur de la syntaxe ooc. Par exemple, l'opérateur := permet de déclarer une variable à partir de l'expression à droite, en inférant son type:

  reponse := 42
  chiens := ArrayList<Chien> new()

  int reponse = 42;
  List<Chien> chiens = new ArrayList<Chien>();

Types de bases

ooc possède les mêmes types de bases que le langage C, toutefois, tous les types commencent par une majuscule, par convention.

La bibliothèque standard offre également de nombreuses structures de données telles que les tableaux-listes, les listes chaînées, les tables de hachages, les piles, etc. Les tableaux sont inclus dans le langage et, contrairement aux pointeurs C, sont sûrs (on ne peut y accéder en-dehors de leurs bornes).

On peut créer des types en définissant une classe, une interface, ou en faisant une cover d'un type défini en C.

Programmation objet

Héritage simple

Le modèle orienté objet d'ooc supporte l'héritage simple.

Animal: class {
    faireDuBruit: abstract func
}
 
Chien: class extends Animal {
    faireDuBruit: func {
      "Wouf!" println()
    }
}
 
Chat: class extends Animal {
    faireDuBruit: func {
      "Miaou!" println()
    }
}
 
toucher: func (animal: Animal) {
    animal faireDuBruit()
}
 
toucher(Chien new())
toucher(Chat new())

Interfaces

Les interfaces permettent un semblant d'héritage multiple, à l'instar du Java.

Representable: interface {
    toString: func -> String
}
 
Printable: interface {
    print: func
}
 
Document: class implements Representable, Printable {
   data: String
   init: func (=data) {}
 
   toString: func -> String { data }
   print: func { toString() println() }
}

Programmation fonctionnelle

ooc supporte les fonctions anonymes et les fermetures. On peut manipuler les fonctions comme n'importe quelle valeur, grâce à une syntaxe claire et lisible :

import structs/[ArrayList, List]
 
filter: func (list: List<Int>, f: Func (Int) -> Bool) -> List<Int> {
    copy := ArrayList<Int> new()
    for (x in list) if (f(x)) {
        copy add(x)
    }
    copy
}
 
list  := [7, 1, -3, 2, -12, 3, 42] as ArrayList<Int>
list2 := filter(list, |a| a > 0 && a < 20)
 
print(list); print(list2)
 
print: func (list: List<Int>) {
    for (x in list) (x + ", ") print()
    println()
}

Cet exemple utilise également des types génériques, montre une manière simple de créer des tableaux-listes (ArrayList), de parcourir des objets itérables, de retourner implicitement des objets, ainsi que la syntaxe courte pour les fonctions anonymes.

Modularité

Chaque fichier .ooc correspond à un module qui peut être importé depuis n'importe où. Les modules peuvent être organisés en paquetages (les dossiers où ils sont placés). Il est possible d'importer un module dans un espaces de noms donné, par exemple

// on importe le module File dans l'espace de noms IO.
import io/File into IO
 
// on peut définir sa propre classe sans se soucier des conflits
File: class {}
 
// on utilise la classe importée
IO File new("C:\\windows\\iexplore.exe") remove()

Contrairement au C il n'y a pas de fichiers d'en-tête séparés des fichiers sources. import, plutôt que de copier/coller le contenu du fichier, définit une dépendance entre deux modules.

Le compilateur ayant ainsi une vue claire des dépendances entre modules, il supporte la recompilation partielle sans besoin de fichiers de projets du type Makefile.

Les fichiers .use permettent également de spécifier des dépendances sur des bibliothèques externes, des options à passer au compilateur C, des informations de versions, etc. La directive use permet d'en faire usage dans du code ooc. Ainsi, utiliser par exemple la SDL, OpenGL est l'affaire d'une ligne de code source.

Exemples de code

Le hello world classique :

 println("Hello world!")

Afficher le contenu d'un fichier :

 File new("/etc/hosts") read() print()

Afficher les 5 premières puissances de 2

 for(i in 0..5) {
   "2^%d = %d" format(i, 2 pow(i)) println()
 }

Implémentations

L'implémentation principale d'ooc est rock, entièrement écrit en ooc et qui se compile lui-même. Il a été développé en quelques mois et a rendu obsolète j/ooc, l'implémentation initiale en Java qui a permis au langage de bootstrapper en avril 2010

Il existe également un effort pour implémenter un compilateur ooc écrit en Ruby, nommé rooc.

Liens externes

Site officiel

Wikilivre de référence sur ooc

• Portail de la programmation informatique