anchor.diff:  
   -type env_ref() :: reference() | global.
   -record(lambda, {
  -	  ref                   :: env_ref(), % unique reference for symbol table
  +	  ref                   :: env_ref(),   % unique reference for symbol table
         label                 :: string(),    % name in llvm code
         type                  :: #typeFun{},
         definitions           :: #nameDef{},  % names introduced by this functions
  
positive.code:             {MyVar, [ MyCall | ArgCodeLines ]};
  
          %% call to fix point operators (complex stuff ;)
          #fix{ closure=Closure } ->
              #closure{ lambda = Lambda =  #lambda{ type=Type}} = Closure,
              {FunctionName,_} = codegen(Lambda),
              StructPointer = compil_table:newTemp(),
              ClosureTypeName = "clojure_fix",
              ClosureType = "%" ++ ClosureTypeName ++"*",
  
              FixName =  "@fix",
              ValueName = "%fix_value",
              RetValueName = "%fix_ret",
              FixHeader = ?LIN(["define","i32",FixName,"(i32",ValueName,")"]),
              FixCall =  ?LIN([RetValueName,"=","call","i32",FunctionName,"(", ClosureType ,StructPointer,
                      ",","i32",ValueName,")"]),
              FixReturn = ?LIN(["ret","i32",RetValueName]),
  
              ArgTypes = [int],
              ArgsStr = lists:map( fun({Var, Type}) -> decode_type(Type) ++ " " ++  Var end,
                  lists:zip(Vars, ArgTypes)),
              VarString = string:join(ArgsStr,", "),
  
  
              FunctionPointer = compil_table:newTemp(),
              AllocCode = ?LIN([StructPointer,"=","alloca","%" ++ ClosureTypeName]),
              GetFPCode = ?LIN([FunctionPointer,"=","getelementptr",ClosureType,StructPointer++ ",","i32 0,","i32 0"]),
              StoFPCode = ?LIN(["store","i32(i32)*", FixName ++ "," ,"i32(i32)*" ++ "*",FunctionPointer]),
  
              Code = ?FUNCTION([ FixHeader, AllocCode, GetFPCode, StoFPCode, FixCall, FixReturn]),
              compil_emitter:function(Code),
  
negative.code: 
      % FIXME: i am evil fixed typed code
      #closure{ lambda=Lambda }  = Closure,
      #lambda{ label = Label,
          definitions= [ NameDef = #nameDef{ name=SelfReference } | _Other ] } = Lambda,
      Type = #typeCl{
             lambda = #typeFun{ return=int, arguments=[int]},
              name   = "clojure_fix_"++Label,
              captures=[] %#typeFun{ return=int, arguments=[int]}
          },
      compil_table:setType(SelfReference, Type),
      TypedClosure = type(Closure),
      #fix{ closure=TypedClosure, cltype=Type, type=#typeFun{return=int, arguments=[int]}};
  
  %% typing for cond:
  %%  * ensure that cond is boolean
  