Devolver el primer elemento en un mapa/lista/secuencia que satisface una función que devuelve verdadero

Question

Estoy buscando una función que devuelva el primer elemento en una secuencia que evalúa un fn como verdadero. Por ejemplo:

(first-map (fn [x] (= x 1)) '(3 4 1)) 

La función falsa anterior debe devolver 1 (el último elemento en la lista). ¿Hay algo así en Clojure?

Answer 1

user=> (defn find-first 
     [f coll] 
     (first (filter f coll))) 
#'user/find-first 
user=> (find-first #(= % 1) [3 4 1]) 
1 

Editar: Una concurrencia. :) No. No aplica f a toda la lista. Solo a los elementos hasta la primera coincidencia debido a la pereza de filter.

Answer 2

creo some es la mejor herramienta para el trabajo:

(some #(if (= % 1) %) '(3 4 1)) 

Answer 3

En su caso, el lenguaje es

(some #{1} [1 2 3 4]) 

Cómo funciona: # {1} es un conjunto literal. Un conjunto también es una función que evalúa su arg si el arg está presente en el conjunto y, en caso contrario, nulo. Cualquier elemento de conjunto es un valor de "veracidad" (bueno, a excepción de un booleano falso, pero eso es una rareza en un conjunto). some devuelve el valor de retorno del predicado evaluado frente al primer miembro de la colección cuyo resultado fue verdadero.

Answer 4

Usando drop-while en lugar de filter debe abordar "sobre-aplicación" de f para secuencias fragmentados:

(defn find-first [f coll] 
    (first (drop-while (complement f) coll))) 
;;=> #'user/find-first 

(find-first #(= % 1) [3 4 1]) 
;;=> 1 

Answer 5

I probado varios métodos mencionados en este hilo (JDK 8 y Clojure 1.7), y que algunas pruebas de referencia :

repl> (defn find-first 
     [f coll] 
     (first (filter f coll))) 
#'cenx.parker.strategies.vzw.repl/find-first 

repl> (time (find-first #(= % 50000000) (range))) 
"Elapsed time: 5799.41122 msecs" 
50000000 

repl> (time (some #{50000000} (range))) 
"Elapsed time: 4386.256124 msecs" 
50000000 

repl> (time (reduce #(when (= %2 50000000) (reduced %2)) nil (range))) 
"Elapsed time: 993.267553 msecs" 
50000000 

los resultados muestran que reduce manera puede ser la solución más eficiente que en clojure 1.7.