ebb/include/flow_graph.hrl

% operation A B = A |->| B
% task B = operation () B = () |->| B

% operation ::= func  | value    | dynamic  | route
%             | pipe  | parallel | sequence
%             | split | merge    | switch   | loop

% func (A_1 * ... * A_n) B ::=
%   { in = n : number, code : fun(A_1, ..., A_n) -> B }
-record(func, {in, code}).

% value () B ::= { value : B }
-record(value, {value}).

% dynamic (A_1 * ... * A_n) (operation () B) ::=
%   { in = n : number, code : fun(A_1, ..., A_n) -> operation () B }
-record(dynamic, {in, code}).

% route_R A (route_map R A) ::=
%   { in = size(A) : number, out = length(R) : number,
%     map = R : [ (1..size(A)) ] }
-record(route, {in, out, map}).

% pipe (A_1 * ... * A_n) (B_1 * ... * B_m) ::=
%   { in = n : number, out = m : number,
%     ops : [ operation (A_1_1 * ... * A_1_n1) (A_2_1 * ... * A_2_n2),
%             operation (A_2_1 * ... * A_2_n2) (A_3_1 * ... * A_3_n3),
%             ...,
%             operation (A_i_1 * ... * A_i_ni) (B_1 * ... * B_m) ] }
-record(pipe, {in, out, ops}).

% parallel (flatten([A_1, ..., A_n])) (flatten([B_1, ..., B_n])) ::=
%   { in = size(flatten([A_1, ..., A_n])) : number,
%     out = size(flatten([B_1, ..., B_n])) : number,
%     ops : [ operation A_1 B_1, ..., operation A_n B_n ] }
-record(parallel, {in, out, ops}).

% sequence (flatten([A_1, ..., A_n])) (flatten([B_1, ..., B_n])) ::=
%   { in = size(flatten([A_1, ..., A_n])) : number,
%     out = size(flatten([B_1, ..., B_n])) : number,
%     ops : [ operation A_1 B_1, ..., operation A_n B_n ] }
-record(sequence, {in, out, ops}).

% split (unit (A_1 * ... * A_n)) (A_1 * ... * A_n) ::= { size = n : number }
-record(split, {size}).

% merge (A_1 * ... * A_n) (unit (A_1 * ... * A_n)) ::= { size = n : number }
-record(merge, {size}).

% switch (A_1 * ... * A_n) (B_1 + ... + B_m) ::=
%   { in = n : number, out = m : number,
%     switch : operation (A_1, ..., A_n) (Tag_1 + ... + Tag_m),
%     map    : [ {Tag_1, operation (A_1 * ... * A_n) B_1},
%                ...,
%                {Tag_m, operation (A_1 * ... * A_n) B_m} ] }
-record(switch, {in, out, switch, map}).

% loop (A_1 * ... * A_n) (B_1 * ... * B_m) ::=
%   { in = n : number, out = m : number,
%     init : operation () (S_1 * ... * S_i),
%     op   : operation (A_1 * ... * A_n * S_1 * ... * S_i)
%                      (B_1 * ... * B_m * S_1 * ... * S_i) }
-record(loop, {in, out, init, op}).