Hash tables look better in Emacs 30

(let ((x (make-hash-table :test 'equal :size 26)))  ; with xht: (h-new 26)
  (puthash 'a 1 x)                                  ; with xht: (h-put! x 'a 1)
  (puthash 'b 2 x)
  ...
  (puthash 'z 26 x)
  (list :size (hash-table-size x)
        'x     x))
=> '(:size 26
     x #s(hash-table test equal data (a 1 b 2 ... z 26)))

When would you want to do that? When you already know how many pairs it'll have. This creates exactly one hash table of the exact size to fit your data.

Behind the scenes, xht's h* does that, too:

(hash-table-size (h*))                => 0
(hash-table-size (h* :a 1))           => 1
(hash-table-size (h* :a 1 :b 2))      => 2
(hash-table-size (h* :a 1 :b 2 :c 3)) => 3

Not specifying the size is necessarily less efficient, because it'll either create a few tables (that's what the "rehash" things do when starting from size 0); or create an oversized one (the native solution until Emacs 29, whose default size 65 had a large upfront cost when dealing with smaller tables).

When creating from scratch, notice the difference between these two:

(let ((x (make-hash-table :test 'equal)))  ; size = 0
  (puthash 'a 1 x)  ; a size-6 table is "rehashed" here to fit the pair
  (hash-table-size x))
=> 6

(let ((x (make-hash-table :test 'equal :size 1)))
  (puthash 'a 1 x)  ; size is 1 — so it already fits
  (hash-table-size x))
=> 1

Same as above but using xht:

(let ((x (h-new)))
  (h-put! x 'a 1)
  (h-prop x 'size))
=> 6

(let ((x (h-new 1)))
  (h-put! x 'a 1)
  (h-prop x 'size))
=> 1

(let ((x (h* 'a 1)))
  (h-prop x 'size))
=> 1

In the previous alphabet example, if we don't set the initial size of 26, the final size will be 96:

(let ((x (make-hash-table :test 'equal)))  ; with xht: (h-new)
  (puthash 'a  1 x)
  (puthash 'b  2 x)
  ...
  (puthash 'z 26 x)
  (hash-table-size x))
=> 96

This is because when we add:

• 'a 1, it rehashes to size 6
  
• 'g 7, it rehashes to size 24
  
• 'y 25, it rehashes to size 96
  

So four tables are created (allocation sizes 0, 6, 24, and 96); the first three are destroyed.

Whereas if we set the size, only one (allocation size 26) is created.

Will those gains be substantial? Probably not much. The elisp manual says:

‘:size SIZE’
     This specifies a hint for how many associations you plan to
     store in the hash table.  If you know the approximate number,
     you can make things a little more efficient by specifying it
     this way but since the hash table memory is managed
     automatically, the gain in speed is rarely significant.

But it doesn't hurt.

The previous default size of 65 for new hash tables seemed to assume that it'd be a bad idea to create one with fewer items than that.

The new default assumes nothing: it allocates no space. When one item is added, it rehashes to size 6, and stays like that until a seventh item is added, upon which it goes up to 24. It postpones the fixed costs of creation until it's unavoidable.