ooc (langage)
« ooc » redirige ici. Pour les autres significations, voir OOC.
| ooc | ||
 | ||
| Date de première version | ||
|---|---|---|
| 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 | topooc-lang.org | |
modifier  |
||
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.
Caractéristiques[modifier | modifier le code]
Syntaxe[modifier | modifier le code]
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:
| Déclaration de variables en ooc | Déclaration de variables en Java |
|---|---|
reponse := 42
chiens := ArrayList<Chien> new()
|
int reponse = 42;
List<Chien> chiens = new ArrayList<Chien>();
|
Types de bases[modifier | modifier le code]
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[modifier | modifier le code]
Héritage simple[modifier | modifier le code]
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[modifier | modifier le code]
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[modifier | modifier le code]
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é[modifier | modifier le code]
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 espace 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[modifier | modifier le 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[modifier | modifier le code]
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
Il existe également un effort pour implémenter un compilateur ooc écrit en Ruby, nommé rooc.
