anchor.diff:  
   
   -record(closure,{
  -        lambda              :: #lambda{},  % anonymous function
  +        lambda              :: #lambda{},   % anonymous function
           type                :: #typeCl{},
  -        captures = []       :: [ #name{} ] % names captured from outer env
  +        captures = []       :: [ #name{} ]  % names captured from outer env
       }).
   
   -record(fix,{
  -        closure             :: #closure{}, % recursiv function
  +        closure             :: #closure{},  % recursiv function
  +        cltype              :: #typeCl{},   % type of compiled fixpoint
           type                :: #typeFun{}
       }).
   
  
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: %%      and throws an exception if types do not match. It is the core of type
  %%      inference.
  
  
  -spec ensure_type(ast(),type_def()) -> ast().
  
  ensure_type(Expr = #name{ name=Name },Type) ->
  