How do I multiply all elements in one collection with all the elements in another collection?

Say I have:

(def s1 [1 2 3 4 5])
(def s2 [1 2 3 4 5])

For every x in s1, I want to multiply it with every y in s2.

To clarify, I basically want the Cartesian product, so I don't think map works here.

(for [x1 s1
      x2 s2]
  (* x1 x2))

While solution using for is nicer, here is a map-only version if you have troubles understanding for:

(map #(map (partial * %) s2) s1)

for above expands to something similar, except it would use another anonymous function instead of partial, something like this:

(map (fn [x] (map (fn [y] (* x y)) s2)) s1)

or, neatly formated:

(map
  (fn [x]
    (map
      (fn [y]
        (* x y))
      s2))
  s1)

A simple, visual demonstration of the basic functionality of for:

user=> (pprint 
         (for [tens (range 10) 
               ones (range 10)]
           [tens ones]))
([0 0]
 [0 1]
 [0 2]
 [0 3]
 [0 4]
 [0 5]
 [0 6]
 [0 7]
 [0 8]
 [0 9]
 [1 0]
 [1 1]
 [1 2]
 [1 3]
 [1 4]
 [1 5]
 [1 6]
 [1 7]
 [1 8]
 [1 9]
 [2 0]
 [2 1]
 [2 2]
 [2 3]
 [2 4]
 [2 5]
 [2 6]
 [2 7]
 [2 8]
 [2 9]
 [3 0]
 [3 1]
 [3 2]
 [3 3]
 [3 4]
 [3 5]
 [3 6]
 [3 7]
 [3 8]
 [3 9]
 [4 0]
 [4 1]
 [4 2]
 [4 3]
 [4 4]
 [4 5]
 [4 6]
 [4 7]
 [4 8]
 [4 9]
 [5 0]
 [5 1]
 [5 2]
 [5 3]
 [5 4]
 [5 5]
 [5 6]
 [5 7]
 [5 8]
 [5 9]
 [6 0]
 [6 1]
 [6 2]
 [6 3]
 [6 4]
 [6 5]
 [6 6]
 [6 7]
 [6 8]
 [6 9]
 [7 0]
 [7 1]
 [7 2]
 [7 3]
 [7 4]
 [7 5]
 [7 6]
 [7 7]
 [7 8]
 [7 9]
 [8 0]
 [8 1]
 [8 2]
 [8 3]
 [8 4]
 [8 5]
 [8 6]
 [8 7]
 [8 8]
 [8 9]
 [9 0]
 [9 1]
 [9 2]
 [9 3]
 [9 4]
 [9 5]
 [9 6]
 [9 7]
 [9 8]
 [9 9])

Here is the java 1.5 (or newer) equivalent of Michal's code:

List<Integer> numbers = new ArrayList<Integer>();    

for(int x1 : s1) {
  for(int x2 : s2) {
    numbers.add(x1 * x2);
  }
}

The difference is that for loops in java don't return a sequence like they do in clojure, so you need to use a mutable ArrayList to construct the result.

Definitely not as pretty as the clojure version, but much better than what you would have had to do in Java 1.4.

As simple as it can get:

(map * '(1 2) '(3 4))

will yield:

(3 8)