anchor.diff:  
   % types
   
  -%% TODO:
  -%
  -% * function types
  -
  -
   -record(typeFun,{arguments=[],return}).
  -
  +-record(typeCl,{lambda,captures=[]}).
   
   type(#closure{lambda=Lambda, captures=Captures} = Closure) ->
       TypedLambda = type(Lambda),
  -    TypedCaptures = lists:map(
  +    {TypedCaptures, CaptureTypes}  = lists:unzip(lists:map(
           fun
  -            (#nameDef{ name=Name}=Def) ->
  +            (#name{ name=Name}=Def) ->
                   Type = compil_table:getType(Name),
  -                Def#name{type=Type}
  -        end, Captures),
  -    Closure#closure{ lambda=TypedLambda, captures=TypedCaptures };
  +                {Def#name{type=Type},Type}
  +        end, Captures)),
  +    Closure#closure{ type=#typeCl{ lambda = TypedLambda#lambda.type, captures=CaptureTypes }, lambda=TypedLambda, captures=TypedCaptures };
   
   type(#lambda{definitions = Definitions, child = Child} = Lambda) ->
       TypedChild = type(Child),
  
positive.code: type(#literal{} = Lit) ->
      Lit.
  
  
  
  ensure_type(Expr = #name{ name=Name },Type) ->
  
negative.code:             VarString = string:join(ArgsStr,", "),
              MyCall = ?LIN([MyVar,"=","call",decode_type(RetType), LambdaVar, "(", VarString ,")"]),
              {MyVar, [ MyCall | ArgCodeLines ]};
          Other -> % callee must be a closure
              ClType = #typeCl{ } = extract_type(Other),
              % FIXME: dropping importand code (if the other was a function eg)
              { StructPointer, PrevCodes} = codegen(Other),
  
              FunctionPointerPointer = compil_table:newTemp(),
              FunctionPointer = compil_table:newTemp(),
              BindPointer = compil_table:newTemp(),
              Binding = compil_table:newTemp(),
  
              ComputeFPPCode = ?LIN([FunctionPointerPointer,"=","getelementptr", decode_type(ClType),StructPointer ++ ",","i32 0,","i32 0"]),
              ComputeBPCode = ?LIN([BindPointer,"=","getelementptr",decode_type(ClType),StructPointer ++ ",","i32 0,","i32 2"]),
  
              LoadFPCode = ?LIN([FunctionPointer,"=","load","i32(i32,i32)**",FunctionPointerPointer]),
              LoadBCode = ?LIN([Binding,"=","load","i32*",BindPointer]),
  
              % FIXME: dirty hack [int]
              ArgsStr = lists:map( fun({Var, Type}) -> decode_type(Type) ++ " " ++  Var end, lists:zip(Vars, [int])),
              VarString = string:join(ArgsStr,", "),
              MyVar = compil_table:newTemp(),
              CallCode = ?LIN([MyVar,"=","call",decode_type(RetType),FunctionPointer,"(",VarString,", i32",Binding,")"]),
  
              { MyVar, lists:reverse([ComputeFPPCode,ComputeBPCode,LoadFPCode,LoadBCode,CallCode]) ++ PrevCodes }
  
      end;
  
  codegen(#name{ name=Var}) ->
      { "%" ++ Var, ?NOCODE};
  
  
  % TODO:
  % * introduce clojure type
  % * parameterize for different sizes of bindings
  % * write cll code for clojure
  
  codegen(#closure{ lambda = Lambda = #lambda { type=Type },type = ClType,  captures=  [ #name{name=CaptureName, type=CaptureType }]}) ->
      { FunctionName, _ } = codegen(Lambda),
      % Typedef := { Pointer to Function, Number of Bindings, Binding }
      compil_emitter:function(?LIN(["%closure","=","type","{","i32(i32,i32)*,", "i32,","i32","}"])),
      StructPointer = compil_table:newTemp(),
      FunctionPointer = compil_table:newTemp(),
  
      ClojureStructType = decode_type(ClType),
      AllocCode = ?LIN([StructPointer,"=","alloca","%closure"]),
      GetFPCode = ?LIN([FunctionPointer,"=","getelementptr",ClojureStructType,StructPointer++ ",","i32 0,","i32 0"]),
      StoFPCode = ?LIN(["store","i32(i32,i32)*",FunctionName ++ "," ,"i32(i32,i32)**",FunctionPointer]),
  
      BindPointer = compil_table:newTemp(),
      GetBPCode = ?LIN([BindPointer,"=","getelementptr",ClojureStructType,StructPointer++",","i32 0,","i32 2"]),
      StoBPCode = ?LIN(["store","i32","%"++CaptureName ++ ",","i32*",BindPointer]),
  
      {StructPointer, lists:reverse([AllocCode, GetFPCode, StoFPCode, GetBPCode, StoBPCode])};
  
  
  
  
  codegen(#literal{type=int, value=Val}) ->
      MyVar = integer_to_list(Val),
  