Warnung: Die Verwendung des Operators '<' hat keine Wirkung?

Question

Ich bin neu in erlang und ich versuche, eine einfache Funktion zu implementieren, wie folgt:

% * ChatServers is a dictionary of usernames with tuples of the form: 
% {server, Pid, Reference,LoggedInUsers} 
get_chat_server([], _) ->   
    undefined; 

get_chat_server([Key|_], ChatServers) -> 
    {server, Pid, Reference,LoggedInUsers} = dict:fetch(Key,ChatServers), 
    LoggedInUsers < 100, 
    {server, Pid, Reference,LoggedInUsers}; 

get_chat_server([_|T], ChatServers) ->   
    get_chat_server(T, ChatServers). 

Im Grunde, was ich versuche, das erste Tupel von meinem Wörterbuch, dessen LoggedInUsers Zahl kleiner als 100

zu tun ist, finden

jedoch, sobald ich meinen Code kompilieren, erhalte ich die folgenden 2 Warnungen:

main_server_distributed.erl: 63: Warnung: Verwendung des Betreibers < 'hat keine Wirkung main_server_distributed.erl: 66: Wa rning: Diese Klausel kann nicht Spiel, weil eine frühere Klausel in Zeile 61 immer übereinstimmt

ich einige Erfahrung mit Prolog habe und soweit ich mich erinnere ist dies eine gültige Verwendung von Mustererkennung und Rekursion. Könntest du bitte darauf hinweisen, was ich hier falsch mache? Danke im Voraus.

Answer 1

Der Text einer Klausel (alles auf der rechten Seite der ->) ist keine Liste von Bedingungen zu erfüllen, sondern einfach eine Komma-getrennte Liste von Ausdrücken zu bewerten. Alle resultierenden Werte außer dem des letzten Ausdrucks werden verworfen. Daher wird der boolesche Wert Ihres Vergleichs < nirgends verwendet.

Answer 2

main_server_distributed.erl: 66: Achtung: Diese Klausel nicht mithalten können, weil eine frühere Klausel in Zeile 61 entspricht immer

Sie haben im Wesentlichen geschrieben:

get_chat_server(NonEmptyList, ChatServers) -> 
    {server, Pid, Reference,LoggedInUsers} = dict:fetch(Key,ChatServers), 
    LoggedInUsers < 100, 
    {server, Pid, Reference,LoggedInUsers}; 

get_chat_server(NonEmptyList, ChatServers) ->   
    get_chat_server(T, ChatServers). 

Daher ist die Die erste Klausel wird immer mit allem übereinstimmen, was mit der zweiten Klausel übereinstimmt. Genauer gesagt, in dem Muster:

[Key|_] 

Key wird alles akzeptiert und _ wird alles akzeptiert. Ebenso in dem Muster:

[_|T] 

_ wird alles akzeptiert, und T wird alles akzeptiert.

Riffing @ dsmith Antwort aus:

-module(my). 
-export([get_chat_server/3, get_chat_server_test/0]). 

get_chat_server(_MaxLoggedIn, []=_Keys, _ChatServers) ->   
    none; 
get_chat_server(MaxLoggedIn, [Key|Keys], ChatServers) -> 
    get_chat_server(MaxLoggedIn, Keys, ChatServers, dict:fetch(Key, ChatServers)). 

get_chat_server(MaxLoggedIn, _, _, {_,_,_,LoggedInUsers}=ChatServer) when LoggedInUsers < MaxLoggedIn -> 
    ChatServer; 
get_chat_server(MaxLoggedIn, [Key|Keys], ChatServers, _ChatServer) -> 
    get_chat_server(MaxLoggedIn, Keys, ChatServers, dict:fetch(Key, ChatServers)). 

%--------- 

get_chat_server_test() -> 
    Keys = [a, c], 
    ChatServers = [ 
     {a, {server, a, a_, 200}}, 
     {b, {server, b, b_, 100}}, 
     {c, {server, c, c_, 30}} 
    ], 
    ChatServerDict = dict:from_list(ChatServers), 

    none = get_chat_server(10, [], ChatServerDict), 
    {server, c, c_, 30} = get_chat_server(50, Keys, ChatServerDict), 
    {server, c, c_, 30} = get_chat_server(150, Keys, ChatServerDict), 
    PossibleResults = sets:from_list([{server,a,a_, 200},{server,c,c_,30}]), 
    true = sets:is_element(
      get_chat_server(250, Keys, ChatServerDict), 
      PossibleResults 
      ), 
    all_tests_passed.  

Sie auch Funktionen höherer Ordnung verwenden können, dh dict:fold(), eine Liste aller ChatServers zu erhalten, die Ihre Anforderungen erfüllen:

max_fun(Max, Keys) -> 
    fun(Key, {_,_,_,LoggedInUsers}=Server, Acc) -> 
      case lists:member(Key, Keys) andalso LoggedInUsers<Max of 
       true -> [Server | Acc]; 
       false -> Acc 
      end 
    end. 

In der Schale:

44>  ChatServers = [ 
44>   {a, {server, a, a_, 200}}, 
44>   {b, {server, b, b_, 100}}, 
44>   {c, {server, c, c_, 30}} 
44>  ]. 
[{a,{server,a,a_,200}}, 
{b,{server,b,b_,100}}, 
{c,{server,c,c_,30}}] 

45> ChatServerDict = dict:from_list(ChatServers). 
{dict,3,16,16,8,80,48, 
     {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}, 
     {{[], 
     [[a|{server,a,a_,200}]], 
     [[b|{server,b,b_,100}]], 
     [[c|{server,c,c_,30}]], 
     [],[],[],[],[],[],[],[],[],[],[],[]}}} 

46> Keys = [a,c]. 
[a,c] 

47> MaxLoggedIn = 150. 
150 

50> F = my:max_fun(MaxLoggedIn, Keys). 
#Fun<fl.0.128553666> 

51> dict:fold(F, [], ChatServerDict). 
[{server,c,c_,30}] 

Answer 3

Sie können so etwas tun ...

get_chat_server([], _) ->   
     undefined; 

    get_chat_server([Key|T], ChatServers) -> 
     {server, Pid, Reference,LoggedInUsers} = dict:fetch(Key,ChatServers), 
     if 
      LoggedInUsers < 100 -> 
       {server, Pid, Reference,LoggedInUsers}; 
      true -> 
       get_chat_server(T, ChatServers) 
     end. 

Oder diese

get_chat_server([], _) ->   
     undefined; 

    get_chat_server([Key|T], ChatServers) -> 
     Result = dict:fetch(Key,ChatServers), 
     case Result of 
      {_, _, _, LoggedInUsers} when LoggedInUsers < 100 -> 
      Result; 
      _ -> 
      get_chat_server(T, ChatServers) 
     end.