%%%%% Declarative Concurrency %%%%%

% Demonstration done at FLOPS 2006

% Author: Peter Van Roy

% Declarative concurrency in Oz using
% producer/consumer example.
% See talk and book for more explanation.
% Book: "Concepts, Techniques, and Models of Computer
% Programming", chapter 4, MIT Press, 2004.

% Open browser window
{Browse 1}

%%%%% 1. Eager version
% Concurrency makes results incremental
% Note: both Ints and Sum are tail-recursive!
declare
fun {Ints N Max}
   if N<Max then
	  {Delay 1000}
	  N|{Ints N+1 Max}
   else nil end
end

fun {Sum A Xs}
   case Xs of X|Xr then
	  A|{Sum A+X Xr}
   [] nil then nil end
end

% "Batch": sequential computation
declare Xs Ys in
{Browse Xs}
{Browse Ys}
Xs={Ints 1 10}
Ys={Sum 0 Xs}

% "Incremental": concurrent computation
declare Xs Ys in
{Browse Xs}
{Browse Ys}
thread Xs={Ints 1 10} end
thread Ys={Sum 0 Xs} end

%%%%% 2. Lazy version
% First add annotation and recompile:
%   fun lazy {Ints N Max}
%   fun lazy {Sum A X}
% Lazy annotation uses WaitNeeded to
% trigger calculation of each function.
% Threads are not needed.

declare
fun lazy {LazyInts N Max}
   if N<Max then
	  {Delay 1000}
	  N|{LazyInts N+1 Max}
   else nil end
end

fun lazy {LazySum A Xs}
   case Xs of X|Xr then
	  A|{LazySum A+X Xr}
   [] nil then nil end
end

% Lazy: no calculation until requested
declare Xs Ys in
{Browse Xs}
{Browse Ys}
Xs={LazyInts 1 10}
Ys={LazySum 0 Xs}

% Request a result triggers calculation
{Browse Ys.2.1}

{Browse Ys.2.2.2.1}

%%%%% 3. Combining concurrency and laziness:
% Bounded buffer example of Chapter 4
% (page 291, Figure 4.27)
declare
fun {Buffer Xs N}
   End=thread {List.drop Xs N} end
   fun lazy {Loop Xs End}
	  case Xs of X|Xr then
		 X|{Loop Xr thread End.2 end}
	  end
   end
in
   {Loop Xs End}
end

% Buffer requests three elements
declare
{Browse Xs}
{Browse Ys}
Xs={LazyInts 1 10}
Ys={Buffer Xs 3}

% Request second element
{Browse Ys.2.1}