When I was reading Steele's history of common  lisp, published  in the
90s one thing  that struck  me as maaaaybe  obviously  true but that I
still need to understand  is that a central regret of common  lisp was
that the standard included the inefficient data structures vectors and
arrays. Arrays in common lisp are like this: 

> (setq *foo* #(1 2 3 4))

#(1 2 3 4)
> (setq *bar* (adjust-array (make-array '2) '2 :displaced-to *foo*))

#(1 2)
> *bar*

#(1 2)
> (setf (aref *bar* 0) 5)

5
> *foo*

#(5 2 3 4)
>

One criticism was that it was too hard to write  a Sufficiently  Smart
Compiler   to  make array displacement  like that efficient   and  the
overhead of nested array displacements was too high. 

Simple vectors are one-dimensional arrays

> (vector 1 2 3 4)

#(1 2 3 4)

But they are not in general simple.

> *foo*

#(5 2)
> (vector-push-extend '4
(adjust-array  (make-array 1 :adjustable t
 :fill-pointer 0)
 '1 :displaced-to *foo*))

0
> *foo*

#(4 2)

Vectors are clearly featureful and feel very fast.

> (loop for x across (vector 1 2 3) summing (/ x 5))

6/5

So  what's  wrong with them?  How are they inefficient?   Hash  tables
spring to mind 

> (with-hash-table-iterator (iter *foo*)
(loop (multiple-value-bind  (entry-p key value) (funcall iter)
       (unless entry-p (return))
       (format t "~s : ~s~%"  key value))))
FOO : 3/2
BAR : 5/2
NIL

Whereas  an array with a fill pointer whether  or not adjustable  sits
with  unused  array addresses  just taking  up space,  lisp  compilers
generally implement weak datastructures as an extension: 

>      (setq     *foo*     (make-hash-table      :weakness      :key))
#<hash-table 0x..>

See the write-up from the 2005 European Lisp Symposium

haible.de/bruno/papers/cs/weak/WeakDatastructures-writeup.html

which  treats weak (partial  garbage collectionable)  data structures,
the gist being that a lisp implementation should implement 

-Weak pointers
-Weak :key mappings
-Weak hash-tables

which  is a ubiquitous  extension  in the usual common  lisp compilers
(and schemes and gnu / lucient elisps, smalltalk  and others evidently
by 2005) 

with the cost that weak datastructures are also less efficient because
they need additional information  to know when weak references  can be
garbage collected.