
Schwartzian Transform - licorna
https://en.wikipedia.org/wiki/Schwartzian_transform
======
dang
I like the Arc idiom for this. Here's how to sort a list (say of stories) by
some computed value (say a function called score):

    
    
      (sort (compute > score) stories)
    

If score is expensive, you just wrap it in memo:

    
    
      (sort (compare > (memo score)) stories)
    

Now it will compute each score once, save them in a table, and throw the table
away when done.

~~~
pvg
This also pops up in SICP, first in an exercise (a re-tread of fibonacci,
SICP's fizzbuzz) and in several other places later.

It seems like an example of the importance and influence of notation - many
commonly used languages these days have first class functions but nobody using
a lisp-2 variant would have thought to give this particular thing a special
name.

~~~
dang
I don't follow the connection to Lisp-2. Can you explain?

~~~
pvg
There isn't one, I fatfingered my 1 into a 2 and it's too late to fix it,
sorry. I just meant it ends up being the shortest, least weird notation for
function composition. Clearly, the meta-notation has some problems...

------
twotwotwo
A possibly counterintuitive case where "the key...is expensive to compute" can
be when accessing the key just requires following a pointer to something not
in cache. It's not the same thing syntactically, but, for example, Postgres
sped up collation by packing bytes into integers:

[http://pgeoghegan.blogspot.com/2015/01/abbreviated-keys-
expl...](http://pgeoghegan.blogspot.com/2015/01/abbreviated-keys-exploiting-
locality-to.html)

I've also seen speedups sorting strings by first sorting prefixes of them
packed into uint64s (rather than sorting pointer/length references to string
data), and in an application where a friend needed to sort a lot of indices
into an array, it turned out to greatly speed the sort (by avoiding
indirections) to copy the whole array, sort the indices and the copy of the
array together, then toss out the copy.

------
paulsutter
tl/dr, a sort optimization: avoid recomputing the sort keys by temporarily
associating them with the input items.

Wouldn't it be embarrassing to have one's name in the title of a long winded
Wikipedia article for a super simple and obvious optimization.

