-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) };

-- ход противника
chess state = do move <- getChannel c
                 chess2 (applyMove state move)

-- наш ход
chess2 state = do let move = calcOurMove state
                  putChannel c move
                  chess (applyMove state move)

BZ>а на пальцах показать? с чистыми данными такая проблема — это и есть данные. хочешь — шахматную доску передавай, хочешь — состояние ядерного реактора. "не будет ни радио, ни газет, ни кино — одно сплощное телевидение"

-module( my_object ).

-record( this, { member1 = "a", member2 = 1, ... } ).

new() ->spawn( fun dispatch/1, #members{} ).

set( This, Attribute, Value ) -> This ! { set, Attribute, Value }.
get( This, Attribute, Value ) ->
   This ! { get, Attribute, self() },
   receive { return, This, Value } -> Value end.

dispatch( Members ) ->
   NewState = receive
      { set, member1, Value } -> Members#this{ member1 = Value };
      { get, member1, Caller } -> Caller ! { return, self(), Members#this.member1 }, Members;
   ...
   end,
   dispatch( NewState ).

-module( caller ).
...
   Obj = my_object:new(),
   "a" = my_object:get( Obj, member1 )
   my_object:set( Obj, member1, "b" ),
...
   "a" = my_object:get( Obj, member1 ), %% Ой! Эксцепшн bad_match! Значение то у нас вернулось - "b"!

evaluate(expression(), Ref->Value ) -> Value.

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

create( string() ) -> expression().

refs(expression()) -> [ Ref ].
evaluate(expression(), dictionary() ) -> Val.

Т>module( expression ).
Т>-export( [ create/1, evaluate/2, refs/1 ] ).

Т>create( string() ) -> expression().

Т>refs(expression()) -> [ Ref ].
Т>evaluate(expression(), dictionary() ) -> Val.
Т>

-module( sheet ).

evaluate( Ref, Sheet ) ->
   Value = get_cell( Ref, Sheet ), % цыклы не ловим, ломает. Понятно, как, но лень
   { Context, NewSheet }= mapfoldl( fun evaluate/2, Sheet, cell:dependency_list( Value ) ),
   NewValue = cell:evaluate( Value, Context ),
   { NewValue, set_cell( Ref, NewValue ) }.
...

-module( cell ). %% как-то больно тупо стал выглядеть этот модуль. :)
depencency_list( { expression, Expr } ) -> expression:depencency_list( Expr );
depencency_list( _ ) -> [].

evaluate( { expression, Expr }, Context ) -> expression:evaluate( Expr, Context );
evaluate( Value, [] ) -> Value.

...

-module( expression ).

depencency_list( { _Expr, Refs } ) -> Refs.
evaluate( { ref, _ }, [ Value | Rest ] ) -> { Value, Context }
...
evaluate( Num, Context ) -> { Num, Context }
...

G>-module( sheet ).

G>evaluate( Ref, Sheet ) ->
G>   Value = get_cell( Ref, Sheet ), % цыклы не ловим, ломает. Понятно, как, но лень
G>   { Context, NewSheet }= mapfoldl( fun evaluate/2, Sheet, cell:dependency_list( Value ) ),
G>   NewValue = cell:evaluate( Value, Context ),
G>   { NewValue, set_cell( Ref, NewValue ) }.
G>...
G>

evaluate( Ref, Sheet ) ->
   Value = get_cell( Ref, Sheet ),
   Context = lists:map( fun ( R ) -> get_cell( R, Sheet ) end, cell:dependency_list(Value) ),
   cell:evaluate( Value, Context ).

evaluate( Sheet ) ->
  DepGraph = build_depgraph(Sheet), 
  case digraph_utils:is_acyclic(DepGraph) of
  true ->  
      RefList = digraph_utils:topsort(DepGraph),
      lists:foldl( fun evaluate/2, Sheet, RefList);
  false -> 
      ...
  end.

Т>evaluate( Sheet ) ->
Т>  DepGraph = build_depgraph(Sheet), 
Т>  case digraph_utils:is_acyclic(DepGraph) of
Т>  true ->  
Т>      RefList = digraph_utils:topsort(DepGraph),
Т>      lists:foldl( fun evaluate/2, Sheet, RefList);
Т>  false -> 
Т>      ...
Т>  end.
Т>

RefList = digraph_utils:topsort(DepGraph)

RefList = lists:reverse(digraph_utils:topsort(DepGraph))

evaluate(Sheet)->
  ...
  false ->
    CycPart=digraph_utils:reaching(lists:append(digraph_utils:cyclic_strong_components(DepGraph))),
    Sheet1=lists:foldl(fun(Ref,Sheet)->set_cell(Ref,cell:make_error('#cycle'),Sheet) end,Sheet,CycPart),
    digraph:del_vertices(DepGraph,CycPart),
      ...

C>>Так ведь все просто: предложи лучшее решение

Маленький Эксель
----------------

Необходимо реализовать простую электронную таблицу в виде программы, выполняющейся
из командной строки. Она должна уметь обрабатывать ячейки таблицы как и более
продвинутые аналоги, только с упрощенным синтаксисом выражений. Каждая ячейка
может содержать:
— Ничего
— Неотрицательное целое число
— Текстовые строки, которые начинаются с символа '
— Строки-выражения, которые начинаются с символа '=' и могут содержать
неотрицательные целые числа, ссылки на ячейки и простые арифметические
выражения. Скобки запрещены, у всех операций одинаковый приоритет.
Ссылки на ячейки состоят из одной латинской буквы и следующей за ней
цифры.

Эти ограничения введены для упрощения разбора выражений, поскольку разбор
выражений не является основной частью проблемы. Вы можете спокойно
положиться на эти ограничения. Вот грамматика содержимого ячейки:

expression ::= '=' term {operation term}*
term ::= cell_reference | nonnegative_number
cell_reference ::= [A-Za-z][0-9] --
operation ::= '+' | '-' | '*' | '/'
text ::= '\'' {printable_character}

Процесс обработки:
— Все выражения должны быть заменены на вычисленный результат.
— Все вычисления выполняются с помощью целочисленной арифметики со знаком.
— Ячейки с текстом должны быть вычислены как соответствующий текст без
префикса '.
— Операции над строками текста запрещены.
— В случае любой ошибки вычисления формулы, вычисляемая ячейка должна содержать
слово-сообщение об ошибке, начинающееся с символа '#'. Используйте короткие,
ясные сообщения. Не надо предоставлять подробности об ошибках в выводе.

Программа должна использовать только стандартные библиотеки и классы и не должна
вызывать сторонние программы, библиотеки или системные компоненты.


Ввод и вывод
------------

Программа получает описание таблицы с формулами из стандартного ввода,
вычисляет ее и печатает полученный результат в стандартный вывод. Входные
данные представлены таблицей, элементы строк которой разделены табуляциями.
Первая строка содержит пару чисел, разделенных табуляцией — высоту и
ширину таблицы, соответственно. Затем идут строки с ячейками таблицы,
в грамматике, приведенной выше.


Выход должен содержать только ожидаемую информацию, включая сообщения об
ошибках, и никакой другой информации в выводе не должно быть, включая и
welcome text. Выход должен быть отформатирован в соответствии с приведенным
ниже примером.

Пример данных:
3 4
12 =C2 3 'Sample
=A1+B1*C1/5 =A2*B1 =B3-C3 'Spread
'Test =4-3 5 'Sheet

Ожидаемый вывод:
12 -4 3 Sample
4 -16 -4 Spread
Test 1 5 Sheet


Указания по решению
-------------------
Необходимо промышленное качество кода. Более короткое и читаемое решение
предпочтительней. Решение должно содержать тестовые примеры и код, использованные
в процессе создания решения. Не забудьте откомментировать код в ключевых
местах. Код должен быть устойчив к ошибкам.

Представьте, что это требования к первой фазе проекта. Необходимо реализовать
только то, что нужно на этой фазе. Однако, известно, что планируется вторая
фаза, в которой требования будут расширены следующими:
— Расширить формулы операциями над строками,
— Оптимизировать производительность для громадных таблиц.

Вам необходимо будет указать, какие изменения необходимо сделать для
реализации второй фазы проекта.

Т>evaluate(expression(), Ref->Value ) -> Value.
Т>

sheet_obj( Sheet ) -> fun
   ( get, Ref ] ) ->
       get_cell( Ref, Sheet );
   ( set, { Ref, Value } ) ->
       sheet_obj( set_cell( Ref, Value, Sheet ) );
   ( return, _ ) ->
       Sheet
end.

И тогда

%% evaluate( Ref, Expression, Sheet ) -> { Value, UpdatedSheet }.
%% evaluate expression...
evaluate( _, updating, Sheet ) -> { { error, '#cycle' }, Sheet };
evaluate( Ref, Expr, Sheet ) ->
    Sheet_1 = Sheet( set, { Ref, updating } ),
    { Value, Sheet_2 } = evaluate( Expr, Sheet_1 ),
    { Value, Sheet( set, { Ref, Value } ) }.

    a          b

1  'b1        'No ref
2  =get("a1") =get(a1)

    a          b

1  b1         b2
2  b1         No ref

    a          b

1  b1         No ref
2  b1         No ref

R>    a          b

R>1  'b1        'No ref
R>2  =get("a1") =get(a1)
R>

R>    a          b

R>1  b1         b2
R>2  b1         No ref
R>

-module( ref ).
-export( create/1, create/2, row_range/3 ).

%% create( integer(), integer() ) -> ref().
create( Row, Col ) -> { Row, Col }.

%% create( string() ) -> ref() | throws value:error().
create( [ Row, Col ] ) when Row >= $a, Row =< $z, Col >= $0, Col =< $9 ->
    { Row - $a + 1, Col - $0 };
create( _ ) -> value:throw_error( 'invalid ref' ).

%% row_range( Row, From, To ) -> [ ref() ]
%% Row = From = To = integer()
row_range( Row, From, To ) -> [ ref( Row, Col ) || Col <- lists:seq( From, To ) ].

-module( value ).
-compile( export_all ).

%% Public data type
%% value() = integer() | string() | error() | empty.
create( [ $', String ] ) -> String;
create( [ $#, String ] ) -> error( list_to_atom( String ) );
create( "" ) -> empty;
create( Int ) -> catch integer( Int ).

%% to_string( value() ) -> string().
%% get text representation for the given cell value
as_string( Int ) when is_integer( Int ) -> integer_to_list( Int );
as_string( { error, Msg } ) -> "#" ++ atom_to_list( Msg );
as_string( empty ) -> "";
as_string( String ) is_list( String ) -> String.

%% error( atom() ) -> error() = { error, Code }
error( Code ) when is_atom( Code ) -> { error, Code }.
throw_error( Msg ) when is_atom( Msg ) -> throw( error( Msg ) ).

%% integer( String ) -> integer() | throw error()
integer( String ) ->
    case string:to_integer( T ) of
        { Int, [] } -> Int;
        { error, no_integer } -> throw_error( 'not a number' ).
    end.

as_integer( empty ) -> 0;
as_integer( Int ) when is_integer( Int ) -> Int;
as_integer( _ ) -> throw_error( 'not a number' ).

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

%% create( char() ) -> Operation
%% Operation = fun( value(), value() ) -> value() | throws error()
%% create binary operator...
create( $+ ) -> fun add/2;
create( $- ) -> fun sub/2;
create( $* ) -> fun mult/2;
create( $/ ) -> fun divd/2.

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

%% Binary operations implementation... 
%%______________________________________
add( X, Y ) when is_list( X ), is_list( Y ) -> X ++ Y;
add( X, Y ) -> value:as_number( X ) + value:as_number( Y ).

mult( X, Y ) -> value:as_number( X ) * value:as_number( Y ).

sub( X, Y ) -> value:as_number( X ) - value:as_number( Y ).

divd( X, Y ) ->
    X_1 = value:as_number( X ),
    Y_1 = case value:as_number( Y ) of
        0 -> value:throw_error( 'division by zero' );
        Y -> Y
    end,
    X_1 / Y_1.

-module( expression ).
-export( [ create_expr/1 ] ).

%% create_expr( string() ) -> { Expression, [ ref() ] } | value().
%% Expression = fun( [ value() ] ) -> value()
create_expr( String ) -> catch
        { Expr, Refs } = create( String ),
        F = fun( Args ) -> catch
            { Res, [] } = evaluate( Expr, Args ),
            Res
        end,
        { F, Refs }

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

update_refs( { ref, Ref }, Refs ) -> [ Ref | Refs ];
update_refs( _, Refs ) -> Refs. 

%% create_arg( string() ) -> Ref | integer()
%% Ref = { integer(), integer() }
create_arg( Arg ) ->
    case catch value:integer( Arg ) of
        { error, _ } -> ref:create( Arg );
        Number -> Number
    end.

%% evaluate( Expression, Args ) -> { Value, [] }.
%% Evaluate expression.
evaluate( { A, Op, B }, Args ) ->
    { ResA, Args_1 } = evaluate( A, Args ),
    { ResB, Args_2 } = evaluate( B, Args_1 ),
    { Op( ResA, ResB ), Args_2 };
evaluate( { ref, _ }, [ Arg | Rest ] ) -> { Arg, Rest };
evaluate( Val, Args ) -> { Val, Args }.

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

%% create( String ) -> value() | Formula
%% Formula = { expression(), [ ref() ] }
%% create cell from text representation
create( [ $= | Expr ] ) -> expression:create( Expr );
create( Value ) -> value:create( Value ).

%% evaluate( ref(), sheet() ) -> sheet().
evaluate( Ref, Sheet ) ->
    { _, Sheet_1 } = eval_and_get( Ref, Sheet ),
    Sheet_1.

%% eval_and_get( ref(), sheet() ) -> { value(), sheet() }.
eval_and_get( Ref, Sheet ) ->
    case sheet:get_cell( Ref, Sheet ) of
        updating -> { value:error( 'cyclic reference' ), Sheet };
        { Expr, Refs } ->
            Sheet_1 = sheet:set_cell( Ref, updating, Sheet ),
            { Args, Sheet_2 } = lists:mapfoldl( fun eval_and_get/2, Sheet_1, Refs ),
            Value = Expr( Args ),
            { Value, sheet:set_cell( Ref, Value ) };
        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().

get_refs() -> gb_trees:keys( Sheet ).

%% set_cell( ref(), cell(), sheet() ) -> sheet().
set_cell( _, empty, Sheet ) -> Sheet; %%% do NOT store empty values...
set_cell( Ref, Value, Sheet ) -> gb_trees:enter( Ref, Value, Sheet ).

%% set_cell( { ref(), cell() }, sheet() ) -> sheet().
set_cell( { Ref, Value }, Sheet ) -> set_cell( Ref, Value, Sheet ).

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

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

%% update_row( Row, [ string() ], sheet() ) -> sheet()
%% update row 
create_row( Row, TextCells, Sheet ) ->
    Cells = [ cell:create( String ) || String <- TextCells ],
    Refs = ref:row_range( Row, 1, lists:length( Cells ) ),
    lists:foldl( fun set_cell/2, Sheet, lists:zip( Refs, Cells ) ).

%% get_row( Row, Length, sheet() ) -> [ string() ]
row_as_text( Row, Cols, Sheet ) ->
    [ value:as_string( get_cell( Ref, Sheet ) ) || Ref <- ref:row_range( Row, 1, Length ) ].

create_expr( string() ) -> { Expression, Arguments } | value().
%% Формулы получаются из строк.
%% возвращает либо конкретное значение, если его можно вычислить сразу, либо функцию, его вычисляющую.
%% Expression = fun( [ value() ] ) -> value()
%% Функция, вычисляющая значение. Берет список значений аргументом.
%% Arguments = [ ref() ]
%% Список ссылок на аргументы.
%% Пример использования: Expression( [ calc_argument( X ) || X <- Arguments ) -> value().