如何在Clojure中使用地图功能？

Question

I have a function named f which supposed to be mapped onto a vector in my main function. However when I lein run my code nothing happens...

(ns my-proj.core
  (:gen-class))

(def f
  (fn
    [x]
    (println x)))

(def -main
  (fn
    [& args]
    (map f args)))

(-main [1 2 3 4 5])

The code seems correct according to the docs . But what am I missing? Plz help.

Answer 1

Since map is lazy, you'll need to use a different approach if you want side effects. In this case, you could use run! :

(run! println [1 2 3 4 5])
;; 1
;; 2
;; 3
;; 4
;; 5
;;=> nil

Answer 2

Your function f is returning nil because println returns nil . The function identity returns the value that it is given. Here I have commented out your println call so that f effectively becomes identity :

(def f
  (fn
    [x]
    ;(println x)
    x
    ))

(defn -main [& args]
  (apply map f args))

(defn so []
  (-main [1 2 3 4 5])) 

To test the above just call (so) . I added in apply to get rid of the double wrapping of the result. You could substitute identity for the above call to f (ie (apply map identity args) ).

If you do want to println and return a value you can do that as well:

(defn probe
  ([x]
   (println x)
   x)
  ([x msg]
    (println msg x)
    x))

Just call probe instead of f or identity (ie (apply map probe args) ). probe is a side-effecting identity function, where the side effect is to print the return value.

As a side note, if you do ever suspect that laziness is causing problems then wrap the return value in seq , or use mapv instead of map .

Answer 3

There are several problems with your code:

1. -main is variadic, and the variadic variable ( args ) is what you're passing to map . But you're calling -main as (-main [1 2 3 4 5]) . So args will be ([1 2 3 4 5]) . So you are map ing not over a vector, but over a sequence containing a vector.

   Either define -main to take a single argument, or call -main as (-main 1 2 3 4 5) .

2. You make the classic error of mixing side-effects and laziness. Sometimes this is useful, but often it's a mistake. In your case, it's a mistake -- nothing will happen, because you never realize any of the values (which will all be nil , but the println will at least be executed as a side-effect).

   You can force the sequence via do-all . However, since the result is a sequence of nil s, you are really only interested in performing the side-effects rather than the actual values produced. So dorun probably makes more sense. But the most idiomatic way would be to use doseq instead of map . doseq is similar to for (which is basically logically equivalent to some syntactic sugar around map ), except doseq is not lazy and does not produce a sequence -- it's purely for side-effects.

Answer 4

My code was incorrect, for starters I should not have passed a vector into the main; then all I had to do was add doall . So here's what I wanted in case you also need the map to work.

(ns my-proj.core
  (:gen-class))

(defn f
  [x]
  (println (+ x 1)))

(defn -main
  [& args]
  (doall
    (map f args)))

(-main 1 2 3 4 5)

I think what happens is: a vector will be passed as a single argument, so if you add doall the map will work but it will only print out your vector as one thing. I thought it would be unwrapped by the map.