Erlang: Erstes Element in einer Liste, die eine Bedingung erfüllt (ohne den Rest der Elemente zu bewerten)

Question

Angenommen, ich habe eine Liste von Zahlen L und möchte das erste Element finden, das größer als eine bestimmte Zahl ist X. Ich konnte dies mit Listenkomprehensionen wie folgt aus:

(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 

Dies scheint aber potenziell sehr ineffizient, da die Liste sehr lang sein könnte, und das erste Spiel früh sein könnte. Also frage ich mich, ob entweder a) Gibt es eine effiziente Möglichkeit, dies zu tun, die den Rest der Elemente in der Liste nicht bewerten wird, nachdem das erste Spiel gefunden wurde? oder b) Wenn das kompiliert wird, optimiert Erlang den Rest der Vergleiche sowieso weg?

Dies ist, wie ich das erreichen, was für in C Ich suche nach:

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

gut, so etwas wie

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

Answer 2

Hier ist, was ich der Lage war, mit zu kommen. Ich würde immer noch gerne wissen, ob es eine bessere Antwort gibt und/oder ob die einfachste Sache optimiert wird (je mehr ich darüber nachdenke, desto mehr bezweifle ich das).

-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. 

Beispiel:

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 

bearbeiten

Hier ist eine Version ohne einen Akkumulator.

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

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

Answer 3

Hier ist eine schnelle Lösung:

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