Esiste un equivalente Elixir della funzione `try` di Rails?

Question

In Rails si può fare qualcosa di simile:

@user.try(:contact_info).try(:phone_number)

che restituirà il phone_number se il @user e contact_info sono entrambi non nullo. Se uno di questi è zero, l'espressione restituirà zero.

voglio sapere qual è il modo più idiomatico per fare questo in Elixir, sapendo che @user e contact_info sono struct.

Answer 1

Probabilmente no, l'elisir non è orientato agli oggetti, quindi si chiamano funzioni note su moduli definiti (se la funzione/modulo non è definita, il codice non viene nemmeno compilato).

Per chiamate successive su funzioni con l'operatore di condotte, in cui il risultato può essere nil in qualsiasi passaggio, penso che sia sufficiente un unico grande blocco try. Oppure si può provare le pipe_while macro da questa libreria https://github.com/batate/elixir-pipes

Answer 2

Penso che un modo per farlo è di andare con pattern matching quindi sarebbe qualcosa di simile:

case user do 
    %{contact_info: %{phone_number: phone_number}} when phone_number != nil -> 
    #do something when the phone number is present 
    _ -> 
    #do something when the phone number is absent 
end 

Answer 3

Sembra che non ci sono al forno in soluzione in elisir. Così ho arrotolato il mio.

defmodule Maybe do 
    def and_then(nil, _), do: nil 
    def and_then(val,fnc), do: fnc.(val) 
    def and_get(struct, key), do: struct |> and_then(&(Map.get(&1, key))) 
end 

no_user = nil 
without_contact_info = %{contact_info: nil} 
with_contact_info = %{contact_info: %{address: "here"}} 

no_user |> Maybe.and_then(&(Map.get(&1, :contact_info))) |> Maybe.and_then(&(Map.get(&1, :address))) 
#> nil 
without_contact_info |> Maybe.and_then(&(Map.get(&1, :contact_info))) |> Maybe.and_then(&(Map.get(&1, :address))) 
#> nil 
with_contact_info |> Maybe.and_then(&(Map.get(&1, :contact_info))) |> Maybe.and_then(&(Map.get(&1, :address))) 
#> "here" 

# or with the less generic `and_get` 

with_contact_info |> Maybe.and_get(:contact_info) |> Maybe.and_get(:address) 
#> "here" 

Probabilmente non è un elisir idiomatico, ma pulisce il mio codice.

Answer 4

È possibile utilizzare get_in da Kernel:

iex(2)> user = %{contact_info: %{name: "Bob"}} 
%{contact_info: %{name: "Bob"}} 
iex(3)> get_in(user, [:contact_info, :name]) 
"Bob" 
iex(4)> user2 = %{} 
%{} 
iex(5)> get_in(user2, [:contact_info, :name]) 
nil 
iex(6)> user3 = %{contact_info: %{}} 
%{contact_info: %{}} 
iex(7)> get_in(user3, [:contact_info, :name]) 
nil 

Si noti che questo non funziona con i modelli Ecto/le strutture, ma le mappe semplici vanno bene.

Answer 5

Modifica: test del mio suggerimento per utilizzare with, mi rendo conto che non funzionerà come cortocircuiti sull'errore di corrispondenza, ma avrete UndefinedFunctionError su zero. Quindi ho rimosso quella parte. Andrei con la corrispondenza dei pattern, come suggerito da @JustMichael.

Se si controlla la definizione delle strutture, può essere utile un valore predefinito nella struttura.

defmodule ContactInfo do 
    defstruct phone_number: nil 
end 

defmodule User do 
    defstruct contact_info: %ContactInfo{} 
end 

iex> user = %User{} 
%User{contact_info: %ContactInfo{phone_number: nil}} 
iex> user.contact_info.phone_number 
nil 

Qualcuno potrebbe ancora volutamente impostato :contact_info a zero, ma prendere in considerazione solo lasciando che il crash ... :)

Answer 6

defmodule ContactInfo do 
    defstruct phone_number: nil 
end 

defmodule User do 
    defstruct contact_info: nil 
end 

defmodule Test do 
    def extract_phone_number(%User{contact_info: contact_info}) do 
    case contact_info do 
     %ContactInfo{phone_number: phone_number} -> phone_number 
     _ -> nil 
    end 
    end 
end 

iex(1)> user = %User{} 
%User{contact_info: nil} 
iex(2)> Test.extract_phone_number user 
nil 
iex(3)> user = %User{contact_info: nil} 
%User{contact_info: nil} 
iex(4)> Test.extract_phone_number user 
nil 
iex(5)> user = %User{contact_info: %ContactInfo{phone_number: nil}} 
%User{contact_info: %ContactInfo{phone_number: nil}} 
iex(6)> Test.extract_phone_number user 
nil 
iex(7)> user = %User{contact_info: %ContactInfo{phone_number: 1234567}} 
%User{contact_info: %ContactInfo{phone_number: 1234567}} 
iex(8)> Test.extract_phone_number user 
1234567 

non funziona come una monade Forse, ma è un modo per utilizzare modello corrispondente per estrarre un valore dalle strutture nidificate durante la gestione di nil. Da quello che ho letto fino ad ora (sono abbastanza nuovo per Elisir in persona), l'uso di pattern matching come questo sembra essere un elisir più idiomatico.

Answer 7

Il più vicino che posso ottenere finora è con con ok_jose applicazione:

use OkJose 

defmodule Person do 
    defstruct [:name, :address] 
end 

defmodule Address do 
    defstruct [:locale, :state] 
end 

defmodule Locale do 
    defstruct [:number, :street, :city] 
end 

defmodule Main do 
    def main do 
    person = %Person{ 
     name: "Homer", 
     address: %Address{ 
     locale: %Locale{ 
      number: 742, 
      street: "Evergreen Terrace", 
      city: "Springfield", 
     }, 
     state: "???" 
     } 
    } 

    person 
    |> case do %{address: %{locale: %{city: city}}} -> city; _ -> nil end 
    |> String.upcase 
    |> String.reverse 
    |> Pipe.if(&(!is_nil(&1))) 
    |> IO.inspect 
    end 
end 

Main.main