Как оценить последовательность чистых функций в Clojure

Question

Мой вопрос очень похож на этот: How to evaluate a sequence of impure functions in Clojure?, но вместо нечистых функций, как я могу оценить последовательность чистых функций и получить результаты в виде другой последовательности?

Давайте предположим, что мы имеем вектор функций, таких как:

[#(str "a" "b") #(str "c" "d") #(str "e" "f")] 

И нам нужен выход, как это:

("ab" "cd" "ef") 

Я пытался что-то похожее на это:

(map eval [#(str "a" "b") #(str "c" "d") #(str "e" "f")]) 

, но он просто возвращает вектор ссылок функций.

Answer 1

Существует несколько способов сделать то, что вы просите. Это зависит от того, хотите ли вы ленивую последовательность или нет (вам, вероятно, нужна ленивость, если нет побочных эффектов, но вам может потребоваться отсутствие лени, если есть интенсивное вычисление, которое вы хотите кэшировать), или если вы хотите вектор как выход (то же, что и ваш вход). Я постараюсь следовать тому, что вы пытались сделать.

Ваша карта с Eval делает следующее с каждой Fn:

user=> (eval #(str 1)) 
#<user$eval1332$fn__1333 user$eval1332$fn__1333@38747597> 

Но вы хотите что-то вроде следующего:

user=> (eval (#(str 1))) 
"1" 

Вы хотите Eval, чтобы иметь сноска применяется, то есть: fn должен быть первым элементом списка. Перечислим его в списке:

user=> (map (comp eval list) [#(str "a" "b") #(str "c" "d") #(str "e" "f")]) 
("ab" "cd" "ef") 

Прохладный. Но вместо eval вы, вероятно, захотите использовать применение:

user=> (apply #(str 1)) 
; ArityException Wrong number of args (1) 

Ups! Это не удалось. apply не перегружать 0-Arity, но мы можем передать пустой список:

user=> (apply #(str 1)()) 
"1" 

намного лучше. Давайте делать это с картой:

user=> (map #(apply %()) [#(str "a" "b") #(str "c" "d") #(str "e" "f")]) 
("ab" "cd" "ef") 

Или еще лучше, учитывая ваши функции не получают никаких аргументов, вы бы лучше сделать, как было предложено @Magos:

user=> (map #(%) [#(str "a" "b") #(str "c" "d") #(str "e" "f")])                    
("ab" "cd" "ef") 

Answer 2

Вы можете использовать (fn [f] (f)) или #(%) в своем map.

Answer 3

eval оценивает форму Clojure (то есть, список, содержащий «код»). У вас есть функции, а не формы.

Вам map с apply, но apply принимает как функцию и seq аргументов.Так как у вас нет аргументов, вы можете использовать пустой вектор:

(map apply 
    [#(str "a" "b") #(str "c" "d") #(str "e" "f")] 
    (repeat [])) 

Но было бы короче и, возможно, понятнее, если вы используете for:

(for [f [#(str "a" "b") #(str "c" "d") #(str "e" "f")]] 
    (f)) 

Answer 4

Примечание

Как Nathan Davis wrote, eval оценка clojure вид:

(eval '(+ 1 1)) ;=> 2 

Что он делает с функцией? Ничего!. eval рассматривает функцию как литералы:

((eval +) 1 1) ;=> 2 

В вашем случае:

(def stuff [#(str "a" "b") #(str "c" "d") #(str "e" "f")]) 

... мы имеем

(= stuff (map eval stuff)) ;=> true 

Хотя

(= [#(str "a" "b") #(str "c" "d") #(str "e" "f")] 
    (map eval [#(str "a" "b") #(str "c" "d") #(str "e" "f")])) 
;=> false 

... так как соответствующие функции a re различные объекты, хотя и идентичны в работе.

Вот почему eval бесполезно для вас. Итак, следуйте Magos's advice.

Answer 5

Может быть, это стоит того, чтобы посмотреть на pcalls и/или pvalues

(pcalls #(str "a" "b") #(str "c" "d") #(str "e" "f")) 
;=> ("ab" "cd" "ef") 

Обратите внимание, что pcalls использует future внутри!