Oz (linguagem de programação)

Funções são valores de primeira classe, permitindo a programação de ordem superior funcional:

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}) % Não existe estouro de inteiros em Oz (a não ser que não haja memória restando)
end

fun {SumList List}
   case List of nil then 0
   [] H|T then H+{SumList T}
   end
end

Quando o programa encontra uma variável unbound (fora dos limites) ele espera por um valor:

thread
   Z = X+Y     % irá esperar até que ambos X e Y são ligados a um valor.
   {Browse Z}  % Mostra o valor de Z.
end
thread X = 40 end
thread Y = 2 end

Não é possível alterar o valor de uma variável de fluxo de dados, uma vez que é ligada:

X = 1
X = 2 % erro

Variáveis ​​de fluxo de dados tornam mais fácil a criação de agentes de fluxo concorrentes:

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

Devido à maneira como as variáveis ​​de fluxo de dados funcionam, é possível colocar threads em qualquer parte do programa e garante-se que ele terá o mesmo resultado. Isto faz com que a programação concorrente seja muito fácil. Threads são muito baratas: é possível ter centenas de milhares de threads em execução de uma só vez.[1]

Esse exemplo calcula um fluxo de números primos usando o algoritmo Trial division, através da criação recursiva de agentes concorrentes de fluxo que filtram números não primos:

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 faz uso de eager evaluation por padrão, mas lazy evaluation também é possível:

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 % the value of X is needed and fact is computed
end

O modelo declarativo concorrente pode ser estendido com a passagem de mensagens através da semântica simples:

declare
local Stream Port in
   Port = {NewPort Stream}
   {Send Port 1} % Stream is now 1|_ ('_' indicates an unbound and unnamed variable)
   {Send Port 2} % Stream is now 1|2|_
   ...
   {Send Port n} % Stream is now 1|2| .. |n|_
end

Com uma porta e uma thread o programador pode definir agentes assíncronos:

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

É novamente possível estender o modelo declarativo para apoiar a programação orientada a objetos e a estado com uma semântica muito simples; nós criamos uma nova estrutura de dados mutável chamada Cells:

local A X in
   A = {NewCell 0}
   A := 1  % changes the value of A to 1
   X = @A  % @ is used to access the value of A
end

Com essas simples mudanças de semântica, podemos apoiar o paradigma orientado a objetos. Com um pouco de açúcar sintático (syntactic sugar) a programação orientada a objetos torna-se bem integrada em Oz.

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