anchor.diff:  (buf/read buffer myspec)
   ;; => ["hello", "world!"]
   ----
  +
  +
  +=== Vectors
  +
  +This is a very similar abstraction to the previously explained repeating pattern.
  +The main difference with it is that this one represents an rabitrary size repetition
  +of one spec and allows store an array like datastructures.
  +
  +.Example storing two arrays in a buffer
  +[source, clojure]
  +----
  +(def spec (buf/spec
  +            (buf/vector* buf/int32)
  +            (buf/vector* buf/int32)))
  +(def buffer (buf/into spec [[1 2 3] [4 5 6 7 8]])
  +
  +(buf/get-capacity buffer)
  +;; => 40
  +
  +(buf/read buffer spec)
  +[[1 2 3] [4 5 6 7 8]]
  +----
  +
  +Behind the scenes, an vector is represented with as `int32 + type*N`, that means
  +that it has always an overhead of 4 bytes for store the length of the vector.
   
   
   === Read and write spec to multiple byte buffers
  
positive.code: 
  Also, you can perform the same operation, but using a associative spec:
  
  [source, clojure]
  ----
  (buf/read buffer my-spec2)
  
negative.code: 
  === Read & Write repeatedly
  
  Sometimes you will want read some spec repeatedly, for that purpose _octet_ comes
  with `repeat` composition function:
  
  .Example for read and write using repeat composed spec
  [source, clojure]
  ----
  (def spec (buf/repeat 5 buf/int32))
  (buf/write buffer [1 2 3 4 5] spec)
  ;; => 20
  
  (buf/read buffer spec)
  ;; => [1 2 3 4 5]
  ----
  
  
  === Using arbitrary size type specs
  