Discussion :

[Jade Emy]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

Pensez-vous que le langage de programmation Luon est crédible ou pertinent ?
Quel est votre avis sur le sujet ?

Voir aussi :

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é

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"

[destroyedlolo]

J'utilise énormément Lua entre autre comme script utilisateur pour ma domotique, embarqué dans mes applies C ou C++.
En mode interprété évidemment.

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

Un préprocesseur quoi !
Pour les constantes, c'est d'aillieur domage que Lua ne supporte pas les constantes en tant que tel.

déclaration explicite en ligne, afin que le code puisse être mieux structuré sans changements de contexte supplémentaires et sans consommation de slots

S'il s'agit des déclaration de function ... Lua le fait déjà : les fonctions n'étant que des objets comme les autres.

pas de déclarations globales implicites, et d'autres moyens de détecter autant d'erreurs que possible au moment de la compilation

Bien et très utile : éviterait pas mal de problème.
Mais Lua permettant la déclarration de fonction à l'interrieur d'objet (permettant une POO extrement puissante quoi qu'un peu desorientant au début), je me demande si cette possibilité sera conservée.

les locals ne peuvent plus être utilisés avant la déclaration

???? si une variable est utilisée avant d'être défini comme local, c'est qu'elle est globale. En clair, le code du début adresse la variable globale alors qu'une fois "local" passé, une seconde variable, local ce coup-ci est créée.

déclaration de contrôle switch/case pour éviter d'écrire à nouveau l'expression de la relation.

Des années qu'on demande qu'il soit intégré au language, tout comme le fameux "?:" du C. Mais bon, toujours pas

Sinon, Lua est un très bon langage, fiable, rapide, léger (sans commune mesure avec Python) : extremement simple de l'embarqué !