anchor.diff:          static member Coerce<'a when 'a : unmanaged>(buffer : Buffer) =
               Buffer<'a>(buffer.Device, buffer.Handle, buffer.Memory, buffer.Size / int64 sizeof<'a>)
   
  -    type BufferVector<'a when 'a : unmanaged>(b : Buffer<'a>, offset : int64, delta : int64, size : int64) =
  -        member x.Buffer = b
  -        member x.Offset = offset
  -        member x.Delta = delta
  -        member x.Size = size
  -
  -        member x.Skip(n : int64) =
  -            BufferVector<'a>(b, offset + n * delta, delta, size - n)
  -
  -        member x.Strided(n : int64) =
  -            BufferVector<'a>(b, offset, n * delta, 1L + (size - 1L) / n)
  -
  -        new(b : Buffer<'a>) = BufferVector<'a>(b, 0L, 1L, b.Count)
  -
       module ScanImpl = 
       
           [<Literal>]
  
positive.code:         // generate random data
          let cnt = 1 <<< 24
          let rand = RandomSystem()
          let inputData = Array.init cnt (fun _ -> M44f.Rotation(rand.UniformV3dDirection() |> V3f, rand.UniformFloat() * float32 Constant.PiTimesTwo))
  
          // compile a scan using (+) as accumulation function
          let scanner = app.Runtime.CompileScan <@ (*) @>
  
          // create buffers holding the in-/output
          let input   = device.CreateBuffer<M44f>(inputData)
          let output  = device.CreateBuffer<M44f>(int64 cnt)
  
          // perform the scan once
          device.perform {
  
negative.code: 
          member x.Download(dst : 'a[]) =
              x.Download(0L, dst, 0L, min count dst.LongLength)
          
          interface IBufferVector<'a> with
              member x.Buffer = x
              member x.Offset = 0L
              member x.Delta = 1L
              member x.Size = count
  
      and IBufferVector<'a when 'a : unmanaged> =
          abstract member Buffer : Buffer<'a>
          abstract member Offset : int64
          abstract member Delta : int64
          abstract member Size : int64
  
      and private BufferVector<'a when 'a : unmanaged>(b : Buffer<'a>, offset : int64, delta : int64, size : int64) =
          member x.Buffer = b
          member x.Offset = offset
          member x.Delta = delta
          member x.Size = size
  
          interface IBufferVector<'a> with
              member x.Buffer = x.Buffer
              member x.Offset = x.Offset
              member x.Delta = x.Delta
              member x.Size = x.Size
  
          member x.Skip(n : int64) =
              BufferVector<'a>(b, offset + n * delta, delta, size - n)
  
          member x.Strided(n : int64) =
              BufferVector<'a>(b, offset, n * delta, 1L + (size - 1L) / n)
              
  
          new(b : Buffer<'a>) = BufferVector<'a>(b, 0L, 1L, b.Count)
  
  
      [<AbstractClass; Sealed; Extension>]
      type DeviceTypedBufferExtensions private() =
  