anchor.diff:  -type ast() :: #lambda{} | #closure{} | #call{} | #fix{} | #name{} | #literal{}.
   
   
  +%% -- the lfe-parser wrapper ---------------------------------------------------
  +%% As mentioned the parser is borrowed from lfe, here a simple wrappe
  +
  +-spec lexAndParse(string()) -> [ s_expr() ].
  +% returns list of all s_expr in that string 
  +lexAndParse(String) ->
  +    {ok, Tokens, _Lines} = lfe_scan:string(String),
  +    parseAllForms(Tokens).
  +
  +parseAllForms(Tokens) ->
  +    case lfe_parse:sexpr(Tokens) of
  +        {ok, _Count, Tree, []} ->
  +            [Tree];
  +        {ok, _Count, Tree, Cont} ->
  +            [ Tree | parseAllForms(Cont) ]
  +    end.
  +
  +
   %% -- the precompiler ---------------------------------------------------------
  -
  -precompile([ '+' | [ Arg1 | Args ]]) ->
  +%% The precompiler makes simple transformations on s-exprs
  +
  +-spec precompile(s_expr()) -> s_expr().
  +
  +% for +,-,*,/ fold if there are more that to arguments
  +% eg: ( + 1 2 3 ) -> ( + 1 ( + 2 3 ) )
  +precompile([ Op | [ Arg1 | Args ]])
  +    when Op =:= '+'; Op =:= '-'; Op =:= '/'; Op =:= '*' ->
       lists:foldl(
  -        fun(X,Y) ->  [ '+' , Y , precompile(X)] end,
  +        fun(X,Y) ->  [ Op , Y , precompile(X)] end,
           precompile(Arg1),
           Args);
  +
  +% replace let with lambda
   precompile([ 'let' , Definitions, Child]) ->
       { FormalArguments, Parameters } = lists:unzip(lists:map( fun erlang:list_to_tuple/1, Definitions)),
       [
  
positive.code: scan_free(_Other, _Env) ->
      done.
  
  
  add_free_var(Ref,Name) ->
      { _ , Members }  = lists:unzip(compil_table:getMembersEnv(Ref)),
  
negative.code:     Call#call{ target=NewTarget, arguments=NewArguments ++ FreeArguments };
  
  close_var(Call = #call{ arguments = Args, target=Target}) ->
      Call#call{
          target =  close_var(Target),
          arguments = lists:map( fun close_var/1, Args)
      };
  
  % If the lambda is not directly called transfrom it into a closure (introduces
  % closure into ast.
  close_var(Lambda = #lambda{ ref=Ref, definitions=Defs, child=Child}) ->
      NewChild = close_var(Child),
      Free = compil_table:getFreeEnv(Ref),
  