anchor.diff:              {MyVar, [ MyCall | ArgCodeLines ]};
   
           %% call to fix point operators (complex stuff ;)
  -        #fix{ closure=Closure } ->
  -            #closure{ lambda = Lambda =  #lambda{ type=Type}} = Closure,
  +        #fix{ closure=Closure, cltype = ClType = #typeCl{ name=ClosureTypeName}, type=FixType} ->
  +            #closure{ lambda = Lambda =  #lambda{ type=Type, label=Label}} = Closure,
  +            #typeFun{ return = ReturnType0, arguments=[ArgType0] } = FixType,
  +            ReturnType = decode_type(ReturnType0),
  +            ArgType = decode_type(ArgType0),
  +            FunType = decode_type(FixType),
  +            emit_closure_struct(ClType),
               {FunctionName,_} = codegen(Lambda),
               StructPointer = compil_table:newTemp(),
  -            ClosureTypeName = "clojure_fix",
  -            ClosureType = "%" ++ ClosureTypeName ++"*",
  -
  -            FixName =  "@fix",
  +
  +            ClosureType = "%" ++ ClosureTypeName ++ "*",
  +            FixName =  "@fix_" ++ Label,
               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]),
  +            FixHeader = ?LIN(["define",ReturnType,FixName,"(",ArgType,ValueName,")"]),
  +            FixCall =  ?LIN([RetValueName,"=","call",ReturnType,FunctionName,"(", ClosureType ,StructPointer,
  +                    ",",ArgType,ValueName,")"]),
  +            FixReturn = ?LIN(["ret",ReturnType,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]),
  +            StoFPCode = ?LIN(["store",FunType, FixName ++ "," ,FunType ++ "*",FunctionPointer]),
   
               Code = ?FUNCTION([ FixHeader, AllocCode, GetFPCode, StoFPCode, FixCall, FixReturn]),
               compil_emitter:function(Code),
  
positive.code: 
  
  -record(closure,{
          lambda              :: #lambda{},  % anonymous function
          type                :: #typeCl{},
          captures = []       :: [ #name{} ] % names captured from outer env
      }).
  
  -record(fix,{
          closure             :: #closure{}, % recursiv function
          type                :: #typeFun{}
      }).
  
  
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) ->
  