使用排序与球拍中的键排序功能列表

Question

(functionsort functionlist value)

functionsort takes 2 argument, list of functions and a single value. return same list of function sorted in increasing order when given "value".

for example : here is my list of function

(define myfunctions (list (lambda (x) (+ x 3)) 
                     (lambda (x) (- 100 x))
                     (lambda (x) (* x 2))))
(define fs 
    (function-sort myfunctions
                   5))

should return the following

((first fs) 6)   ; (first fs) is (lambda (x) (+ x 3))
9
((second fs) 6)  ; (second fs) is (lambda (x) (* x 2))
12
((third fs) 6)   ; (third fs) is (lambda (x) (- 100 x))   
94

here is what i got so far:

define (function-sort functions value )
   (map (lambda (y) (y value)) functions))

which compute the value , 9 94 12 un sorted. and I try to use

 (sort myfunctions #:key (function-sort myfunctions 10) <)

which gives me error

. . sort: contract violation
expected: (any/c . -> . any/c)
given: '(13 90 20).

Any suggestion ? thanks in advance

Answer 1

Your attempt was on the right track, but you have to pass an adequate argument for #:key - we want to evaluate each function with the given value, and the sort procedure will sort the input list of functions according to the result returned by each function, when applied to the value. Try this:

(define (function-sort functions value)
  (sort functions < #:key (lambda (f) (f value))))

For improving performance on large lists with expensive functions, pay attention to Will Ness' suggestion: using #:cache-keys? #t #:cache-keys? #t will prevent multiple evaluations for the same argument, and in fact will be similar to what you intended to do with map in the first place (that is: precomputing the values before sorting). Consider:

(define (function-sort functions value)
  (sort functions < #:cache-keys? #t #:key (lambda (f) (f value))))

Either way, it works as expected:

(define myfunctions (list (lambda (x) (+ x 3)) 
                          (lambda (x) (- 100 x))
                          (lambda (x) (* x 2))))

(define fs (function-sort myfunctions 5))

((first fs) 6)
=> 9
((second fs) 6)
=> 12
((third fs) 6)
=> 94