;; Function composition.
(define (f<g= f g)
(expand (fn (a b) (f (g a) (g b))) 'f 'g))
((f<g= < last) '(a 2) '(b 3))
==> true
((f<g= < last) '(b 3) '(a 2))
==> nil
(set 'lst '((b 5) (a 2)))
(sort lst (f<g= < last))
==> ((a 2) (b 5))
(set 'lst '((a 2) (b 5)))
(sort lst (f<g= < last))
==> ((a 2) (b 5))
(set 'lst '((c 4) (b 5) (a 2)))
(sort lst (f<g= < last))
[ crashes ]
This happens when the sorting function gets generated at sort execution.
This is fixed for the next version here:
http://www.newlisp.org/downloads/development/inprogress/
as a workaround make the function first, then pass it to 'sort':
(sort lst fun)
Thanks for the fast and helpful reply.
Function composition is a powerful and fun technique.
I'm hoping that
won't be slower than
The
I just tested the speed using Lutz's 'fun workaround.
The composed function is just as fast as the lambda
Perhaps I should explain the name
If I remember correctly, J (descended from APL) gives names to its operators that compose functions like
f
/
g g
| |
a b
The name looks somewhat like the diagram rotated 90 degrees counterclockwise.
Another example:
f
/
g h
/
a
This could be used to calculate the average of a list of numbers.
It seems rather nice to program without explicit, named parameters.