Le langage de programmation Luon (Lua/Oberon) présente une syntaxe similaire à celle d'Oberon et intègre des concepts de Lua

Une version statiquement typée de Lua

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

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

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