anchor.diff:  
   
   
  -    let nativeOptimized (maxArgs : int) (compileDelta : Option<'value> -> 'value -> IAdaptiveCode<NativeCall>) () : FragmentHandler<'i, 'value, NativeCall, CodeFragment>=
  +    let nativeDifferential (maxArgs : int) (compileDelta : Option<'value> -> 'value -> IAdaptiveCode<NativeCall>) () : FragmentHandler<'i, 'value, NativeCall, CodeFragment>=
           
           let dynamicArgs =
               if typeof<'i> = typeof<unit> then 0
  
positive.code:                 memory.Value.Dispose()
          }
  
      let nativeUnoptimized (maxArgs : int) (compile : 'value -> IAdaptiveCode<NativeCall>) ()  =
          let desc = nativeOptimized maxArgs (fun _ v -> compile v) ()
          { desc with compileNeedsPrev = false }
  
  
  
      [<AllowNullLiteral>]
  
negative.code:         }
  
      let managedSimple (compile : 'v -> IAdaptiveCode<'i -> unit>) () =
          { managedDifferential (fun _ v -> compile v) () with compileNeedsPrev = false }
  
  module AdaptiveProgram =
      
      let nativeDifferential (maxArgs : int) (comparer : IComparer<'k>) (compileDelta : Option<'v> -> 'v -> IAdaptiveCode<NativeCall>) (input : aset<'k * 'v>) =
          new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.nativeDifferential maxArgs compileDelta) :> IAdaptiveProgram<'i>
  
      let nativeSimple (maxArgs : int) (comparer : IComparer<'k>) (compile : 'v -> IAdaptiveCode<NativeCall>) (input : aset<'k * 'v>) =
          new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.nativeSimple maxArgs compile) :> IAdaptiveProgram<'i>
  
      let managedDifferential (comparer : IComparer<'k>) (compileDelta : Option<'v> -> 'v -> IAdaptiveCode<_>) (input : aset<'k * 'v>) =
          new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.managedDifferential compileDelta) :> IAdaptiveProgram<'i>
  
      let managedSimple (comparer : IComparer<'k>) (compile : 'v -> IAdaptiveCode<_>) (input : aset<'k * 'v>) =
          new GenericProgram.Program<_,_,_,_,_>(input, comparer, FragmentHandler.managedSimple compile) :> IAdaptiveProgram<'i>
  