anchor.diff:      TypedClosure = type(Closure),
       #fix{ closure=TypedClosure, type=#typeFun{return=int, arguments=[int]}};
   
  -
  +%% typing for cond:
  +%%  * ensure that cond is boolean
  +%%  * get type of second expr
  +%%  * ensure that third has same type
  +%%  * set cond to that type
   type(#call{ target=Target=#name{name='cond' }, arguments=[Cond, Left, Right]} = Expr) ->
       TypedCond = ensure_type(Cond,bool),
       TypedLeft = type(Left),
  
positive.code:             precompile(Child)
          ]
          | lists:map(fun precompile/1, Parameters) ];
  precompile(List) when is_list(List) ->
      lists:map(fun  precompile/1,List);
  precompile(Other) ->
      Other.
  
  
  %% renaming of functions
  
  split_env([ 'lambda', Definitions, Child], OldEnv) ->
      Ref = make_ref(),
      Prefix = compil_table:newEnv(Ref, OldEnv),
  
negative.code:             [ StoreTrueCode | [ContinueCode | [LabelFalseCode | lists:reverse(FalseCodes)]]] ++
              [StoreFalseCode, ContinueCode,  LabelContinueCode, LoadCode ])};
  
  %% calls are handeled in one clause with cases
  codegen(#call{ type=RetType, target = Target,  arguments = Args }) ->
  
      %% common stuff for calls to all targets  (produce code for args)
      CodeArgs = lists:map(fun(Arg) ->  codegen(Arg) end, Args),
      {Vars, ArgCodes}  = lists:unzip(CodeArgs),
      ArgCodeLines =  lists:concat(ArgCodes),
      case Target of
          %% calls to build in primitives
          #name{ name=Primitiv, primitiv=true } ->
              MyVar = compil_table:newTemp(),
              [VarA, VarB] = Vars,
              MyOp = ?LIN([MyVar,"=", decode(Primitiv), edt(hd(Args)), VarA,",",VarB]),
              {MyVar, [ MyOp | ArgCodeLines ]};
  
          %% direct calls to lambdas (more efficient than producing a closure)
          #lambda{ type=#typeFun {arguments=ArgTypes} } = Lambda ->
              {LambdaVar, _ } = codegen(Lambda),
              MyVar = compil_table:newTemp(),
  