OberonCore

   PROCEDURE SortBySelect (VAR a: ARRAY OF REAL; len: INTEGER);
   (* Сортировка прямым выбором *)
      VAR i, iMin: INTEGER;
            min: REAL;
      
      PROCEDURE FindMin;
         VAR j: INTEGER;
      BEGIN
         iMin := i; min := a[iMin];
         FOR j := i TO len-1 DO
            IF a[j] < min THEN
               iMin := j; min := a[iMin]
            END      
         END
      END FindMin;
      
   BEGIN
      i := 0;
      (* INV ( A m, k : (m < i) & (k >= i) : a[m] <= a[k] )
         & ( A m, k : (m < i) & (k < i) & (m < k) : a[m] <= a[k] )
      *)
      WHILE i < len DO
         FindMin;
         a[iMin] := a[i];
         a[i] := min;
         (* Post: ( A k : k >=  i : a[i] <= a[k] )
            & (A m : m < i : a[m] <= a[i],
            то есть, инвариант теперь будет выполняться и при i := i + 1 *)
         INC(i)
      END
   END SortBySelect;
   
   PROCEDURE SortByInsert (VAR a: ARRAY OF REAL; len: INTEGER);
      VAR i, place: INTEGER;
            elem: REAL;
      
      PROCEDURE FindPlace;
         VAR j: INTEGER;
      BEGIN
         place := 0;
         WHILE ~(elem <= a[place]) DO
            INC(place)
         END;
      END FindPlace;
      
      PROCEDURE Move;
         VAR j: INTEGER;
      BEGIN
         FOR j := i TO place+1 BY -1 DO
            a[j] := a[j-1]
         END
      END Move;
   
   BEGIN
      (* INV A m, k : (m < i) & (k < i) & (m < k) : a[m] <= a[k]
      *)
      i := 0;
      WHILE i < len DO
         elem := a[i];
         FindPlace;
         (* Post: (a[place-1] <= a[i]) & (a[place] >= a[i]) *)
         Move;
         a[place] := elem;
         INC(i)
      END
   END SortByInsert;

def SortByInsert(a):
    for i in range(len(a)):
       elem = a[i]
       # Find place
       place = 0
       while elem > a[place]:
           place += 1
       # Move larger elements
       for j in range(i, place, -1):
           a[j] = a[j-1]
       # Move current element
       a[place] = elem

var p: procedure;

procedure use_proc(q: procedure);
begin
    p := q
end;

procedure global;
    var n: integer;
    procedure local;
    begin
        n := n + 1
    end;
begin
    use_proc(@local)
end;

procedure big_process;
begin
    global;
    ...
    p { ой... }
end;

 PROCEDURE QuickSort(VAR a: ARRAY OF INTEGER);
  PROCEDURE QSort (l, r: INTEGER);
    VAR i, j, x, t: INTEGER;
  BEGIN
    i := l; j := r; x := a[(l + r) DIV 2];
    REPEAT
      WHILE a[i] < x DO INC(i) END;
      WHILE a[j] > x DO DEC(j) END;
      IF i <= j THEN
        t := a[i];
        a[i] := a[j]; a[j] := t;
        INC(i); DEC(j)
      END
    UNTIL i > j;
    IF l < j THEN QSort(l, j) END;
    IF i < r THEN QSort(i, r) END
  END QSort;
BEGIN
  QSort(0, LEN(a) - 1);
END QuickSort;

  PROCEDURE QSort (VAR a: ARRAY OF INTEGER; l, r: INTEGER);
    VAR i, j, x, t: INTEGER;
  BEGIN
    i := l; j := r; x := a[(l + r) DIV 2];
    REPEAT
      WHILE a[i] < x DO INC(i) END;
      WHILE a[j] > x DO DEC(j) END;
      IF i <= j THEN
        t := a[i];
        a[i] := a[j]; a[j] := t;
        INC(i); DEC(j)
      END
    UNTIL i > j;
    IF l < j THEN QSort(l, j) END;
    IF i < r THEN QSort(i, r) END
  END QSort;

PROCEDURE QuickSort*(VAR a: ARRAY OF INTEGER);
BEGIN
  QSort(a, 0, LEN(a) - 1);
END QuickSort;

procedure GlobalProcWithContext;
var x,y,z... //контекст

  procedure MyProc(p:pItem);
  begin
    ... //работаем с p в контексте x,y,z
  end;

begin
  ...
  SomeCollectionOrList.ForEach(@MyProc);
  ...
end;