-module( operation ).
-export( [ tokens/0, create/1, execute/3 ] ).

%% tokens() -> [ char() ].
%% binary operators' token list...
tokens() -> "+-*/".

%% create( char() ) -> bin_op()
%% create binary operator...
create( $+ ) -> fun add/2;
create( $- ) -> fun sub/2;
create( $* ) -> fun mult/2;
create( $/ ) -> fun divd/2.

%% execute( bin_op(), term(), term() ) -> term() | { error, atom() }.
%% Execute binary operation...
execute( Op, A, B ) when is_integer( A ), is_integer( B ) -> Op( A, B );
execute( _, _, _ ) -> { error, '#evaluation' }.

%% Binary operations implementation... 
add( X, Y )  -> X + Y.
mult( X, Y ) -> X * Y.
sub( X, Y ) -> X - Y.

divd( _, 0 ) -> { error, '#division by zero' };
divd( X, Y ) -> X / Y.

-module( operation ).
-export( [ tokens/0, create/1, execute/3 ] ).
%% Бинарная операция. Можно ее создать, можно выполнить.

tokens() -> [ char() ].
%% binary operators' token list...

create( char() ) -> bin_op()
%% create binary operator...

execute( bin_op(), term(), term() ) -> term() | { error, atom() }.
%% Execute binary operation...

-module( expression ).
-export( [ create/1, evaluate/3 ] ).
%% Выражение. Можно его создать, можно вычислить. Вычисление выражения изменяет таблицу.
%% uses: operation, sheet, cell

create( string() ) -> expression().
%% create expression from string...
%% uses: operation
    
evaluate( Ref, Expression, Sheet ) -> { Value, UpdatedSheet }.
%% evaluate expression...
%% uses: operation, sheet, cell

-module( cell ).
-export( [    create/1, to_string/1, evaluate/2, %% внешний интерфейс 
             eval_and_get/2 ] ). %% Интерфейс для expression
%% Ячейка таблицы
%% uses: expression, sheet

create( string() ) -> cell()
%% create cell from text representation
%% uses: expression

to_string( value() ) -> string().
%% get text representation for the given cell value. Can't handle expressions.

evaluate( Ref, sheet() ) -> sheet().
%% Evaluate cell for the given reference.

eval_and_get( Ref, sheet() ) -> { Value, sheet() }.
%% Evaluate cell and get its value...
%% uses: sheet, expression

-module( sheet ). %% главный модуль - АТД для спредшыта. Его по-хорошему надо на два побить.
-export( [    new/0, set_cell/3, get_cell/2, %% Это интерфейс для нашего вычислительного движка.
        update_row/3, get_row/3, evaluate/1 ] ). %% Это внешний интерфейс для всего спредшыта

new() -> sheet()
%% construct new sheet...

set_cell( Ref, cell(), sheet() ) -> sheet().
%% Ref = { Row, Col }
%% Row = Col = integer()

get_cell( Ref, sheet() ) -> Value.

evaluate( sheet() ) -> sheet().
%% evaluate all expressions...

update_row( Row, [ string() ], sheet() ) -> sheet()
%% update row with a given list of cells

get_row( Row, Cols, sheet() ) -> [ string() ]

main -> sheet <-> cell <-> expression -> operation
          ^-------------------+

G>main -> sheet <-> cell <-> expression -> operation
G>          ^-------------------+
G>

main -> sheet -> cell -> expression -> operation

Т>main -> sheet -> cell -> expression -> operation
Т>

-module( expression ).
-export( [ create/1, evaluate/3 ] ).

%% create( string() ) -> expression().
%% create expression from text...
create( Expr ) ->
    Pos = string:cspan( Expr, operation:tokens() ),
    case lists:split( Pos, Expr ) of
        { Val, [ Op | Rest ] } ->
            { create_arg( Val ), operation:create( Op ), create( Rest ) };
        { Val, [] } -> create_arg( Val )
    end.

%% create_arg( string() ) -> Ref | integer() | Error
%% Ref = { integer(), integer() }
%% Error = { error, atom() }
create_arg( [ Row, Col ] ) when Row >= $a, Row =< $z, Col >= $0, Col =< $9 ->
    { ref, { Row - $a + 1, Col - $0 } };
create_arg( Number ) -> cell:create_number( Number ).
    
%% evaluate( Ref, Expression, Sheet ) -> { Value, UpdatedSheet }.
%% evaluate expression...
evaluate( _, updating, Sheet ) -> { { error, '#cycle' }, Sheet };
evaluate( Ref, Expr, Sheet ) ->
    Sheet_1 = sheet:set_cell( Ref, updating, Sheet ),
    { Value, Sheet_2 } = evaluate( Expr, Sheet_1 ),
    { Value, sheet:set_cell( Ref, Value, Sheet_2 ) }.

%% evaluate( Expression, Sheet ) -> { Value, Sheet }
%% Evaluate expression. Forces evaluation of all referenced cells...
evaluate( { A, Op, B }, Sheet ) ->
    { ResA, Sheet_1 } = evaluate( A, Sheet ),
    { ResB, Sheet_2 } = evaluate( B, Sheet_1 ),
    { operation:execute( Op, ResA, ResB ), Sheet_2 };
evaluate( { ref, Ref }, Sheet ) -> cell:eval_and_get( Ref, Sheet );
evaluate( Val, Sheet ) -> { Val, Sheet }.

-module( cell ).
-export( [    create/1, create_number/1, to_string/1,
            evaluate/2, eval_and_get/2 ] ).

%% create( string() ) -> cell()
%% create cell from text representation
create( "" ) -> "";
create( [ $' | Text ] ) -> Text;
create( [ $= | Expr ] ) -> { expr, expression:create( Expr ) };
create( Number ) -> create_number( Number ).

%% create_number( string() ) -> integer() | { error, '#nan' }.
%% create number from string...
create_number( Number ) -> 
    case string:to_integer( Number ) of
        { Value, [] } -> Value;
        _ -> { error, '#nan' }
    end.

%% to_string( value() ) -> string().
%% get text representation for the given cell value
to_string( Int ) when is_integer( Int ) -> integer_to_list( Int );
to_string( { error, Msg } ) -> atom_to_list( Msg );
to_string( Text ) -> Text.

%% evaluate( Ref, sheet() ) -> sheet().
%% Evaluate cell value for the given reference
evaluate( Ref, Sheet ) -> 
    { _, Sheet_1 } = eval_and_get( Ref, Sheet ),
    Sheet_1.

%% eval_and_get( Ref, sheet() ) -> { Value, sheet() }.
%% Evaluate cell and get its value...
eval_and_get( Ref, Sheet ) ->
    case sheet:get_cell( Ref, Sheet ) of
        { expr, Expr } -> expression:evaluate( Ref, Expr, Sheet );
        Value -> { Value, Sheet }
    end.

-module( sheet ).
-export( [    new/0, set_cell/3, get_cell/2, 
            update_row/3, get_row/3, create_cell/2, cell_as_string/2, evaluate/1 ] ).

%% new() -> sheet()
%% construct new sheet...
new() -> gb_trees:empty().

%% set_cell( Ref, cell(), sheet() ) -> sheet().
%% Ref = { Row, Col }
%% Row = Col = integer()
set_cell( _, "", Sheet ) -> Sheet; %%% do NOT store empty values...
set_cell( Ref, Value, Sheet ) -> gb_trees:enter( Ref, Value, Sheet ).

%% get_cell( Ref, sheet() ) -> Value.
get_cell( Ref, Sheet ) -> 
    case gb_trees:lookup( Ref, Sheet ) of
        { value, Value } -> Value;
        _ -> ""
    end.

%% evaluate( sheet() ) -> sheet().
%% evaluate all expressions...
evaluate( Sheet ) -> lists:foldl( fun cell:evaluate/2, Sheet, gb_trees:keys( Sheet ) ).

%% update_row( Row, [ string() ], sheet() ) -> sheet()
%% update row 
update_row( Row, Cells, Sheet ) ->
    Refs = [ { Row, Col } || Col <- lists:seq( 1, lists:length( Cells ) ) ],
    lists:foldl( fun create_cell/2, Sheet, lists:zip( Refs, Cells ) ).

%% get_row( Row, Cols, sheet() ) -> [ string() ]
get_row( Row, Cols, Sheet ) ->
    [ cell_as_string( { Row, Col }, Sheet ) || Col <- lists:seq( 1, Cols ) ].

%% get_cell_text( Ref, sheet() ) -> string().
cell_as_string( Ref, Sheet ) -> cell:to_string( get_cell( Ref, Sheet ) ).

%% create_cell( { Ref, string() }, sheet() ) -> sheet().
create_cell( { Ref, Text }, Sheet ) -> set_cell( Ref, cell:create( Text ), Sheet ).

cell() = Value | { expression, expression() }
Value = integer() | string() | { error, atom() }

%% eval_and_get( Ref, sheet() ) -> { Value, sheet() }.
%% Evaluate cell and get its value...
eval_and_get( Ref, Sheet ) ->
    case sheet:get_cell( Ref, Sheet ) of
        { expr, Expr } -> expression:evaluate( Ref, Expr, Sheet );
        Value -> { Value, Sheet }
    end.

Только зная внутреннюю структуру типа cell, мы сможем понять, что внутри лежит формула. Перенеся этот код в модуль sheet, мы получим более сильную связность - потому что человек, разбирающийся в устройстве sheet, не сможет понять его, не разобравшись в деталях cell. А это именно то, чего мы хотим избежать.

Почему при этом вы отдельный модуль вынесен expression? Потому, что вычисление выражений - это отдельная песня, это можно делать очень по разному. И мы хотим иметь возможность изменять способ вычисления выражений, не затрагивая остальной код. expression - скрывает внутри себя другой тип:

[code]
expression() =  BinaryOp | Ref | integer()
BinaryOp = { expression(), operation(), expression() }
Ref = { integer(), integer() }

G>%% eval_and_get( Ref, sheet() ) -> { Value, sheet() }.
G>%% Evaluate cell and get its value...
G>eval_and_get( Ref, Sheet ) ->
G>    case sheet:get_cell( Ref, Sheet ) of
G>        { expr, Expr } -> expression:evaluate( Ref, Expr, Sheet );
G>        Value -> { Value, Sheet }
G>    end.
G>

-module(expression).
evaluate( { ref, Ref }, Sheet ) -> table:evaluate( Ref, Sheet );
-module(table).
evaluate(Ref,Sheet)->cell:evaluate(Ref,get_cell(Ref,Sheet)).
-module(cell).
evaluate(Ref,Cell)->и т.д.

-module(table).
%% make_ref::(integer(),integer())->ref()
make_ref(X,Y)->{X,Y}.
-module(expression).
create_arg( [ Row, Col ] ) when Row >= $a, Row =< $z, Col >= $0, Col =< $9 ->
    { ref, table:make_ref(Row - $a + 1, Col - $0) };