将功能列表应用于球拍中的值列表

Question

I'm new to Racket and scheme language in general and I'm having a hard time implementing my ideas.

Basically, I have a list of functions (lets call it List f ) and a list of strings (lets call it List s ). What I need to do is, for each function in f, execute the function and store the value in another list (lets call is List done ).

For example: say I have List A = (f1 f2) and List B = (abc) , I would execute:

f1 a
f1 b
f1 c
f2 a
f2 b
f2 c

and they would all append their values into List done

I can also not use any form of set in racket.

I understand how this is suppose to work and could easily code this in C or java, but scheme is giving me trouble.

Answer 1

In Racket, there are lots of built-in procedures that make it easy to solve problems that involve manipulating lists. For your example, you're looking for for*/list :

(define A (list string-upcase string-downcase))
(define B (list "Aa" "Bb" "Cc"))

(define done
  (for*/list ([f A] [s B])
    (f s)))

It iterates over all the elements in A , assigning each one in turn to the variable f . And in a nested loop, it also iterates over all the elements in B , assigning each one in turn to the variable s . In the body of the loop it applies each f to all s , and collects everything in an output list. Now done contains the expected values:

done
=> '("AA" "BB" "CC" "aa" "bb" "cc")

If we were to do this by hand using recursion, it'd be more work. A possible implementation would be to have a procedure to do the "outer" loop, which would call another procedure to do the "inner" loop. A third procedure would start the recursion and combine the results:

(define (outer-loop funcs params)
  (if (null? funcs)
      '()
      (cons (inner-loop (car funcs) params)
            (outer-loop (cdr funcs) params))))

(define (inner-loop f params)
  (if (null? params)
      '()
      (cons (f (car params))
            (inner-loop f (cdr params)))))

(define (apply-funcs funcs params)
  (apply append ; required to "flatten" the list of lists
         (outer-loop funcs params)))

We'd use it like this:

(define done (apply-funcs A B))

At first you should learn how to solve list problems by hand, implementing your own loops. Once you're confident that you understand what you're doing, spend some time learning about the existing list procedures and iterations and comprehensions , the idiomatic way to use the language in real life.