Erlang: Primo elemento in una lista che corrisponde ad alcune condizioni (senza valutare il resto degli elementi)

Question

Come un semplice esempio, supponiamo di avere un elenco di numeri L e voglio trovare il primo elemento che è maggiore di un numero specifico X. Potrei farlo con list comprehension come questo:

(mynode@127.0.0.1)24> L = [1, 2, 3, 4, 5, 6].    
[1,2,3,4,5,6] 
(mynode@127.0.0.1)25> X = 2.5. 
2.5 
(mynode@127.0.0.1)26> [First | _] = [E || E <- L, E > X]. 
[3,4,5,6] 
(mynode@127.0.0.1)27> First. 
3 

ma questo sembra potenzialmente molto inefficiente, dal momento che l'elenco potrebbe essere molto lungo e la prima partita potrebbe essere nella fase iniziale. Quindi mi chiedo se a) Esiste un modo efficace per fare ciò che non valuterà il resto degli elementi nella lista dopo che è stata trovata la prima corrispondenza? oppure b) Quando viene compilato, Erlang ottimizza comunque il resto dei confronti?

Questo è come vorrei ottenere ciò che sto cercando in C:

int first_match(int* list, int length_of_list, float x){ 
    unsigned int i; 
    for(i = 0; i < length_of_list, i++){ 
     if(x > list[i]){ return list[i]; } /* immediate return */ 
    } 
    return 0.0; /* default value */ 
} 

Answer 1

bene, qualcosa di simile a

firstmatch(YourList, Number) -> 
    case lists:dropwhile(fun(X) -> X =< Number end, YourList) of 
    [] -> no_solution; 
    [X | _] -> X 
    end. 

Answer 2

Ecco cosa ho stato in grado di elaborare. Mi piacerebbe ancora sapere se c'è una risposta migliore e/o se la cosa più semplice viene ottimizzata (più ci penso, più ne dubito).

-module(lazy_first). 

-export([first/3]). 

first(L, Condition, Default) -> 
    first(L, [], Condition, Default). 

first([E | Rest], Acc, Condition, Default) -> 
    case Condition(E) of 
    true -> E; 
    false -> first(Rest, [E | Acc], Condition, Default) 
    end; 

first([], _Acc, _Cond, Default) -> Default. 

Esempio:

14> lazy_first:first([1, 2, 3, 4, 5], fun(E) -> E > 2.5 end, 0.0). 
3 
15> lazy_first:first([1, 2, 3, 4, 5], fun(E) -> E > 5.5 end, 0.0). 
0.0 

Modifica

Ecco una versione senza un accumulatore.

first([E | Rest], Condition, Default) -> 
    case Condition(E) of 
    true -> E; 
    false -> first(Rest, Condition, Default) 
    end; 

first([], _Cond, Default) -> Default. 

Answer 3

Ecco una soluzione rapida:

first_greater([],_) -> undefined; 
first_greater([H|_], Num) when H > Num -> H; 
first_greater([_|T], Num) -> first_greater(T,Num).