anchor.diff:  
           new() =
               { Id = newId(); OutOfDateValue = true; 
  -              LevelValue = 0; Outputs = VolatileCollection<IAdaptiveObject>(); WeakThis = null;
  +              LevelValue = 0; Outputs = VolatileCollection(); WeakThis = null;
                 ReaderCountValue = 0; Reevaluate = false }
   
           static member inline private markTime() =
  
positive.code:     /// to be represented by Weak references in order to allow for
      /// unused parts of the graph to be garbage collected.
      /// </summary>
      abstract member Outputs : VolatileCollection<IAdaptiveObject>
  
  
      abstract member InputChanged : obj * IAdaptiveObject -> unit
  
negative.code:         else
              set.Remove value
  
  [<StructLayout(LayoutKind.Explicit)>]
  type MultiPtr =
      struct
          [<FieldOffset(0)>]
          val mutable public Single : WeakReference<IAdaptiveObject>
          [<FieldOffset(0)>]
          val mutable public List : List<WeakReference<IAdaptiveObject>>
          [<FieldOffset(0)>]
          val mutable public Set : HashSet<WeakReference<IAdaptiveObject>>
          [<FieldOffset(0)>]
          val mutable public Collection : ICollection<WeakReference<IAdaptiveObject>>
      end
  
  /// <summary>
  /// Collection of WeakReferences using a switching internal representation: Single(0-1), List (2-8), HashSet(>8)
  /// This collection has improved performance to VolatileCollectionOld in cases where there are 0 or 1 references
  /// NOTE: using mode switch omits using types checks to determine used implementation
  ///       using matches instead of downcasts uses OpCode "isinst" instead of "unbox.any" and avoids code to be able to throw exception
  /// </summary>
  type VolatileCollection() =
      let mutable handles : MultiPtr = Unchecked.defaultof<_>
      let mutable mode : byte = 0uy // using mode to avoid "expensive" type checks
  
      member x.IsEmpty = 
          if isNull handles.Single then true
          elif mode = 0uy then false
          else handles.Collection.Count = 0
          
      member x.Count = 
          if isNull handles.Single then 0
          elif mode = 0uy then 1
          else handles.Collection.Count
              
      member x.Consume(arr : byref<array<IAdaptiveObject>>) : int =
          let mutable length = 0
          if not (isNull handles.Single) then 
              let mutable v : IAdaptiveObject = Unchecked.defaultof<_>
              if mode = 0uy then
                  if arr.Length < 1 then
                      arr <- Array.zeroCreate 8
                  if handles.Single.TryGetTarget(&v) then
                      arr.[0] <- v
                      length <- 1
                  handles.Single <- Unchecked.defaultof<_>
              elif mode = 1uy then
                  let list = handles.List
                  if arr.Length < list.Count then
                      arr <- Array.zeroCreate 8
                  for i in 0..list.Count-1 do // NOTE: using indexer seems to be faster than foreach
  