Oz (programovací jazyk)

Oz je multiparadigmatický programovací jazyk vyvinutý v laboratoři programovacích systémů na Katolické univerzitě v Lovani pro výuku programovacích jazyků. Má vlastní kanonickou učebnici: Koncepty, techniky a modely počítačového programování.

Oz poprvé vyvinul Gert Smolka spolu se svými studenty v roce 1991. Na dalším vývoji se v roce 1996 podíleli Seif Haridi a Peter Van Roy ve Švédském institutu informatiky. Od roku 1999 byl Oz v nepřetržitém vývoji mezinárodní skupiny Mozartovo konsorcium, které se skládalo ze Sárské univerzity, Švédského institutu informatiky a Katolické univerzity v Lovani. V roce 2005 byla odpovědnost za řízení vývoje Mozarta převedena na základní skupinu Mozart Board s výslovným cílem otevřít vývoj větší komunitě.

Mozartův programovací systém je primární implementací Oze. Je vydán s open-source licencí od Mozartova konsorcia. Mozart byl portován na Unix, FreeBSD, Linux, Windows a macOS.

Vlastnosti jazyka

Oz obsahuje většinu konceptů hlavních programovacích paradigmat včetně logického, funkcionálního, imperativního, objektově orientovaného, omezeného, distribuovaného a souběžného programování. Oz má jak jednoduchou formální sémantiku tak efektivní implementaci. Je souběžně orientovaný jazyk, jak ho představil Joe Armstrong, hlavní vývojář jazyka Erlang (programovací jazyk). Díky Tomu je jeho použití efektivní. Oz podporuje kanonický jazyk QTk v grafickém uživatelském rozhraní (GUI).

Kromě programování s více paradigmaty jsou jeho hlavní silnou stránkou omezené programování a distribuované programování. Díky svému zapracovanému designu je Oz schopen úspěšně implementovat síťové transparentní modely distribuovaného programování. Tento model usnadňuje programování otevřených aplikací v systému odolném proti selhání v daném jazyce. Pro omezené programování představil Oz myšlenku výpočetních prostorů, které umožňují uživatelem definované strategie vyhledávání a distribuce ortogonálně k doméně omezení.

Přehled

Datové struktury

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ů, které vždy začínají malým písmenem.

Funkce

Funkce 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.

Programování vyšších řádů

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]

Anonymní funkce

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.

Procedury

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. 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.

Proměnné v toku dat a deklarativní souběžnost

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.

Příklad: Zkušební dělicí síto

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

Odložené vyhodnocování

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 v nekonečném seznamu. Skutečná čísla se počítají pouze, když jsou potřeba.

Souběžnost předávání zpráv

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

Stav a objekty

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

Rychlost provedení

Rychlost provádění programu vytvořeného překladačem Mozart (verze 1.4.0 implementující Oz 3) je velmi pomalá. Na sadě benchmarků je v průměru asi 50krát pomalejší než GNU Compiler Collection (GCC) pro jazyk C, přičemž řeší benchmarky - úkoly.

Související články

• Alice (programovací jazyk) současný funkční omezující jazyk ze Sárské univerzity
• Data Flow Diagram
• Funkcionální a logické programování
  • Prolog (programovací jazyk) objektově orientovaný, funkční, logický jazyk
  • Mercury (programovací jazyk)

Reference

V tomto článku byl použit překlad textu z článku Oz (programming language) na anglické Wikipedii.

• Peter Van Roy and Seif Haridi (2004). Koncepty, techniky a modely počítačového programování. MIT Press. Dostupné online. (anglicky)

Externí odkazy

• Oficiální webové stránky Mozart Dostupné online (anglicky)
• Výukový program pro Oz Dostupné online (anglicky)
• Výzkum programovacích jazyků na Katolické univerzitě v Lovani Dostupné online: Hlavní skupina vývojářů Mozarta/Oze (anglicky)
• Programování v Oz Dostupné online (anglicky)
• Základy Oze Dostupné online (anglicky)