Т>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 ) ].