3 pièce(s) jointe(s)
Le langage de programmation Luon (Lua/Oberon) présente une syntaxe similaire à celle d'Oberon
Le langage de programmation Luon (Lua/Oberon) présente une syntaxe similaire à celle d'Oberon et intègre des concepts de Lua, Luon est une version statiquement typée de Lua.
Le langage de programmation Luon (Lua/Oberon) présente une syntaxe similaire à celle d'Oberon et intègre des concepts de Lua. Le langage cible la VM LuaJIT, en tant que version statiquement typée de Lua. Luon est un langage de programmation de haut niveau avec une syntaxe similaire à Oberon+, Oberon-07 et Oberon-2, intégrant des concepts de Lua. Luon peut être considéré comme une version statiquement typée de Lua.
Petit rappel sur les langages de programmation Oberon et Lua : Oberon est un langage de programmation généraliste publié pour la première fois en 1987 par Niklaus Wirth et le dernier membre de la famille wirthienne des langages de type ALGOL (Euler, ALGOL W, Pascal, Modula et Modula-2). Oberon est le résultat d'un effort concentré pour augmenter la puissance de Modula-2, le successeur direct de Pascal, tout en réduisant sa complexité.
Lua est un langage de programmation léger, de haut niveau et multi-paradigme conçu principalement pour une utilisation embarquée dans des applications. Lua est un logiciel multiplateforme, car l'interpréteur du bytecode compilé est écrit en ANSI C, et Lua dispose d'une interface de programmation d'application (API) C relativement simple pour l'intégrer dans des applications. Lua étant destiné à être un langage d'extension général intégrable, ses concepteurs se sont attachés à améliorer sa vitesse, sa portabilité, son extensibilité et sa facilité d'utilisation au cours du développement.
La combinaison des deux langages de programmation a donné lieu au langage de programmation Luon (Lua/Oberon). Luon est un langage de programmation de haut niveau avec une syntaxe similaire à Oberon+, Oberon-07 et Oberon-2, intégrant des concepts de Lua, et ciblant la VM LuaJIT. Luon peut être considéré comme une version statiquement typée de Lua. Son nom est donc une combinaison de "Lua" et "Oberon".
Les procédures Luon peuvent être déclarées "externes" et être implémentées en Lua. Cela permet de réutiliser des bibliothèques écrites en Lua, ainsi que des bibliothèques C via l'interface de fonctions étrangères LuaJIT. Le projet est le résultat de l'expérience de l'auteur avec l'implémentation de la VM Smalltalk-80 et SOM, et de la perspective de construire une VM Interlisp basée sur LuaJIT.
Contrairement à Oberon+, Luon n'a pas de pointeurs, mais tous les types de données structurés ont une sémantique de référence et sont créés dynamiquement. En plus du type ARRAY, il existe également un type HASHMAP pour la compatibilité avec Lua. Il existe également un type de données STRING qui, comme Lua, est immuable et suit une sémantique de valeur.
En particulier, Luon résout les lacunes suivantes de Lua, constatées au cours des projets susmentionnés :
- compilation conditionnelle permettant d'activer ou de désactiver des instructions utilisées uniquement pour le débogage et pour éviter de perdre du temps de calcul
- constantes ne nécessitant pas de slots locaux ou d'accès à des éléments hachés
- déclaration explicite en ligne, afin que le code puisse être mieux structuré sans changements de contexte supplémentaires et sans consommation de slots
- pas de déclarations globales implicites, et d'autres moyens de détecter autant d'erreurs que possible au moment de la compilation
- les locals ne peuvent plus être utilisés avant la déclaration
- déclaration de contrôle switch/case pour éviter d'écrire à nouveau l'expression de la relation.
Ce projet met en œuvre un compilateur et un IDE pour le langage de programmation Luon. Voici une capture d'écran de l'IDE :
Et voici le débogueur de niveau source de l'IDE :
Les exemples de code suivantes montrent la spécification du langage :
Programmation procédurale
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| module Fibonacci
proc calc*(n : integer): integer
var a, b, i, next: integer // comma is optional
begin
<* if use_recursion then *>
if n > 1 then
a := calc(n - 1)
b := calc(n - 2)
return a + b
elsif n = 0 then return 0
else return 1
end
<* else *>
b := 1
for i := 0 to n-1 do
next := a + b
a := b
b := next
end
return a
<* end *>
end calc
var res: integer
begin
res := calc(21)
assert(res = 10946)
print("Fibonaccy result: ")
println(res)
end Fibonacci |
Programmation générique
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| module Collections(T)
type Deque* = record data: array of T
size: integer end
proc createDeque*(): Deque
const initial_len = 1_000 // separators
var this: Deque // this is initialized to nil
begin
new(this);
new(this.data,initial_len)
return this
// this and data will be garbage collected
end createDeque
proc (this: Deque) append*(element: T)
begin
if this.size = len(this.data) then assert(false) end
this.data[this.size] := element inc(this.size)
end append
type Iterator* = record end
proc (this: Iterator) apply*(element: T) end
proc (this: Deque) forEach*(iter: Iterator)
var i: integer; val: T
begin
for i := 0 to this.size-1 do
iter.apply(this.data[i])
end
end forEach
end Collections |
Programmation orientée objet
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| module Drawing
import F := Fibonacci
C := Collections(Figure)
type Figure* = record position: record
x,y: integer end end
proc (this: Figure) draw*() end
type
Circle* = record (Figure) diameter: integer end
Square* = record (Figure) width: integer end
proc (this: Circle) draw*() end
proc (this: Square) draw*() end
var figures: C.Deque
circle: Circle
square: Square
proc drawAll()
type I = record(C.Iterator) count: integer end
proc (this: I) apply( figure: Figure )
begin
figure.draw(); inc(this.count)
end apply
var i: I // count is initialized to zero
begin
new(i)
figures.forEach(i)
assert(i.count = 2)
println("drawing done")
end drawAll
begin
figures := C.createDeque()
// use constructors instead of new:
circle := { { F.calc(3), F.calc(4) }, diameter: 3 }
figures.append(circle)
square := { { x: F.calc(5), y: F.calc(6) }, 4 }
figures.append(square)
drawAll()
end Drawing |
Et vous ?
:fleche: Pensez-vous que le langage de programmation Luon est crédible ou pertinent ?
:fleche: Quel est votre avis sur le sujet ?
Voir aussi :
:fleche: Niklaus Wirth, créateur du langage de programmation Pascal et lauréat du prix Turing, l'équivalent du Prix Nobel pour l'informatique, n'est plus. Un pionnier de l'informatique nous a quitté
:fleche: Lua 5.4 est disponible avec un nouveau mode de ramasse-miettes, prend désormais en charge les "attributs" des variables locales et une nouvelle sémantique pour la boucle "for"
