Oz (programovací jazyk)

Oz je založen na základním jazyce s velmi malým počtem datových typů, které lze ale rozšířit pomocí syntaktického cukru.

Základní datové struktury:

• Čísla: reálná nebo celá čísla
• Záznamy: pro seskupování údajů: circle(x:0 y:1 radius:3 color:blue style:dots). Zde se prvky x,y, rádius atd. nazývají prvky a data s nimi spojená (v tomto případě 0, 1, 3 atd. jsou hodnoty).
• N-tice: Záznam celého čísla je k dispozici ve vzestupném pořadí: circle(1:0 2:1 3:3 4:blue 5:dots) .
• Seznamy: jednoduchá lineární struktura

'|'(2 '|'(4 '|'(6 '|'(8 nil)))) % prostý záznam
2|(4|(6|(8|nil))) % s trochou syntaktického cukru
2|4|6|8|nil % více syntaktického cukru
[2 4 6 8] % ještě více syntaktického cukru

Těmito datovými strukturami jsou hodnoty (konstantní), kontrola první třídy a dynamického typu. Názvy proměnných začínají velkým písmenem, aby se odlišily od literálů,[3] které vždy začínají malým písmenem.

Funkce[4] jsou hodnoty první třídy, které umožňují funkční programování vyššího řádu:

fun {Fact N}
   if N =< 0 then 1 else N*{Fact N-1} end
end

fun {Comb N K}
   {Fact N} div ({Fact K} * {Fact N-K}) % celá čísla nemohou přetékat (nezbyla by žádná paměť)
end

fun {SumList List}
   case List of nil then 0
   [] H|T then H+{SumList T} % párování vzorů v seznamech
   end
end

Funkce lze použít s volnými i vázanými proměnnými. Hodnoty volných proměnných jsou nalezeny pomocí statického lexikálního rozsahu.[5]

Funkce jsou jako ostatní objekty. Mohou být předány jako atribut jiným funkcím nebo mohou být vráceny ve funkci.

fun {Square N}  % obecná funkce
   N*N
end

fun {Map F Xs}  % F je zde funkce - programování vyššího řádu
   case Xs
      of nil then nil
      [] X|Xr then {F X}|{Map F Xr}
   end
end

% použití
{Browse {Map Square [1 2 3]}}  % procházení [1 4 9]

Stejně jako mnoho jiných funkcionálních jazyků podporuje i Oz použití anonymních funkcí (tj. funkcí, které nemají název) při programování vyšších řádů. K jejich označení se používá symbol $.

Níže je funkce čtverce definována anonymně a předána, což způsobí [1 4 9] procházení.

{Browse {Map fun {$ N} N*N end [1 2 3]}}

Protože anonymní funkce nemají jména, není možné definovat rekurzivní anonymní funkce.

Funkce mají vrátit hodnotu při posledním příkazu nalezeném v těle funkce během jejího provádění. V níže uvedeném příkladu funkce Ret vrátí 5, pokud X>0 a jinak -5.

declare
fun {Ret X}
   if X > 0 then 5 else ~5 end
end

Dále je Oz ošetřen pro případ, že funkce nesmí vracet hodnoty. Takovým funkcím se říká procedury.[6] Procedury jsou definovány pomocí konstruktu "proc" následovně:

declare
proc {Ret X}
   if X > 0 then {Browse 5} else {Browse ~5} end
end

Výše uvedený příklad nevrací žádnou hodnotu, pouze vytiskne 5 nebo -5 v prohlížeči Oz v závislosti na znaménku X.

Když program narazí na nevázanou proměnnou, čeká na hodnotu. Například níže bude vlákno čekat, dokud nebudou X a Y vázány s hodnotou, než se zobrazí hodnota Z.

thread 
   Z = X+Y
   {Browse Z}
end
thread X = 40 end
thread Y = 2 end

Hodnotu proměnné toku dat nelze měnit, pokud je proměnná vázána:

X = 1
X = 2 % chyba

Proměnné toku dat usnadňují vytváření souběžných původců proudu:

fun {Ints N Max}
   if N == Max then nil
   else 
      {Delay 1000}
      N|{Ints N+1 Max}
   end
end

fun {Sum S Stream}
   case Stream
      of nil then S
      [] H|T then S|{Sum H+S T}
   end
end

local X Y in
   thread X = {Ints 0 1000} end
   thread Y = {Sum 0 X} end
   {Browse Y}
end

Z důvodu fungování toku proměnných je možné umístit vlákna komkoli v programu a zaručit, že bude mít stejný výsledek. Díky tomu je souběžné programování velmi snadné. Vlákna jsou velmi úsporná: je možné mít spuštěných 100 000 vláken najednou.[7]

Tento příklad počítá proud prvočísel pomocí algoritmu zkušebního dělení rekurzivním vytvářením souběžných původců proudu, kteří odfiltrují jiná než prvočísla:

fun {Sieve Xs}
   case Xs of nil then nil
   [] X|Xr then Ys in
      thread Ys = {Filter Xr fun {$ Y} Y mod X \= 0 end} end
      X|{Sieve Ys}
   end
end

Oz používá ve výchozím nastavení okamžité vyhodnocování, ale odložené vyhodnocování je možné také. Níže je skutečnost vypočítána pouze tehdy, když je pro výpočet hodnoty Y potřeba hodnota X.

fun lazy {Fact N}
   if N =< 0 then 1 else N*{Fact N-1} end
end
local X Y in
  X = {Fact 100} 
  Y = X + 1
end

Odložené vyhodnocování dává možnost ukládání skutečně nekonečných datových struktur. Síla odloženého vyhodnocování je patrná z následující ukázky kódu:

declare
fun lazy {Merge Xs Ys}
   case Xs#Ys
   of (X|Xr)#(Y|Yr) then
      if X < Y then X|{Merge Xr Ys}
      elseif X>Y then Y|{Merge Xs Yr}
      else X|{Merge Xr Yr}
      end
   end
end

fun lazy {Times N Xs}
   case Xs
   of nil then nil
   [] X|Xr then N*X|{Times N Xr}
   end
end

declare H
H = 1 | {Merge {Times 2 H} {Merge {Times 3 H} {Times 5 H}}}
{Browse {List.take H 6}}

Výše uvedený kód elegantně spočítá všechna regulární čísla[8] v nekonečném seznamu. Skutečná čísla se počítají pouze, když jsou potřeba.

Deklarativní souběžný model lze rozšířit o předávání zpráv pomocí jednoduché sémantiky:

declare
local Stream Port in
   Port = {NewPort Stream}
   {Send Port 1} % proud je nyní 1|_ ('_' označeno nevázanou a nepojmenovanou proměnnou)
   {Send Port 2} % proud je nyní 1|2|_ 
   ...
   {Send Port n} % proud je nyní 1|2| .. |n|_
end

S portem a vláknem lze definovat asynchronní původce:

fun {NewAgent Init Fun}
   Msg Out in
   thread {FoldL Msg Fun Init Out} end
   {NewPort Msg}
end

Je opět možné rozšířit deklarativní model o podporu stavového a objektově orientovaného programování (zkratka OOP) s velmi jednoduchou sémantikou. Vytvoření nové proměnlivé datové struktury s názvem buňky:

local A X in
   A = {NewCell 0}
   A := 1  % změní hodnotu A na 1
   X = @A  % @ použito k přístupu k hodnotě A
end

Pomocí těchto jednoduchých sémantických změn lze podpořit celé objektově orientované paradigma. S trochou syntaktického cukru se OOP dobře integruje.

class Counter
   attr val
   meth init(Value)
      val:=Value
   end
   meth browse
      {Browse @val}
   end
   meth inc(Value)
      val :=@val+Value
   end
end

local C in
   C = {New Counter init(0)}
   {C inc(6)}
   {C browse}
end