Come si controlla il tipo di variabile in Elisir?

In Elisir come si controlla il tipo come in Python:

>>> a = "test"
>>> type(a)
<type 'str'>
>>> b =10
>>> type(b)
<type 'int'>

Ho letto su Elisir che ci sono controlli di tipo come 'is_bitstring', 'is_float', 'is_list', 'is_map' ecc, ma cosa succede se non hai idea di quale tipo potrebbe essere?

Non esiste un modo diretto per ottenere il tipo di variabile in Elisir / Erlang.

Di solito vuoi conoscere il tipo di una variabile per agire di conseguenza; puoi usare le is_*funzioni per agire in base al tipo di una variabile.

Impara un po 'di Erlang ha un bel capitolo su come scrivere in Erlang (e quindi in Elisir).

Il modo più idiomatico di usare la is_*famiglia di funzioni sarebbe probabilmente quello di usarli nelle corrispondenze dei modelli:

def my_fun(arg) when is_map(arg), do: ...
def my_fun(arg) when is_list(arg), do: ...
def my_fun(arg) when is_integer(arg), do: ...
# ...and so on

A partire da elisir 1.2 c'è un icomando in iex che elencherà il tipo e altro di ogni variabile elisir.

iex> foo = "a string" 
iex> i foo 
Term
 "a string"
Data type
 BitString
Byte size
 8
Description
 This is a string: a UTF-8 encoded binary. It's printed surrounded by
 "double quotes" because all UTF-8 encoded codepoints in it are        printable.
Raw representation
  <<97, 32, 115, 116, 114, 105, 110, 103>>
Reference modules
  String, :binary

Se cerchi il codice per il icomando vedrai che questo è implementato tramite un protocollo.

https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/info.ex

Se desideri implementare una funzione per qualsiasi tipo di dati in Elisir, il modo per farlo è quello di definire un protocollo e l'implementazione del protocollo per tutti i tipi di dati su cui vuoi che la funzione funzioni. Sfortunatamente, non è possibile utilizzare una funzione Protocol in guards. Tuttavia, un semplice protocollo di "tipo" sarebbe molto semplice da implementare.

Anche per scopi di debug, se non sei in iex, puoi chiamarlo direttamente:

IEx.Info.info(5)
=> ["Data type": "Integer", "Reference modules": "Integer"]

Un altro approccio consiste nell'utilizzare la corrispondenza dei modelli. Supponiamo che tu stia utilizzando Timex, che utilizza una %DateTime{}struttura e che vuoi vedere se un elemento è uno. Puoi trovare una corrispondenza usando la corrispondenza del modello nel metodo.

def is_a_datetime?(%DateTime{}) do
  true
end

def is_a_datetime?(_) do
  false
end

Lascio questo qui per il gusto di qualcuno che spera di trovare una versione davvero sana. Al momento non ci sono buone risposte a questo in arrivo su Google ...

defmodule Util do
    def typeof(self) do
        cond do
            is_float(self)    -> "float"
            is_number(self)   -> "number"
            is_atom(self)     -> "atom"
            is_boolean(self)  -> "boolean"
            is_binary(self)   -> "binary"
            is_function(self) -> "function"
            is_list(self)     -> "list"
            is_tuple(self)    -> "tuple"
            true              -> "idunno"
        end    
    end
end

Per completezza, casi di test:

cases = [
    1.337, 
    1337, 
    :'1337', 
    true, 
    <<1, 3, 3, 7>>, 
    (fn(x) -> x end), 
    {1, 3, 3, 7}
]

Enum.each cases, fn(case) -> 
    IO.puts (inspect case) <> " is a " <> (Util.typeof case)
end

Ecco una soluzione con protocolli; Non sono sicuro che siano più veloci (spero sicuramente che non stiano eseguendo un ciclo su tutti i tipi), ma è piuttosto brutto (e fragile; se aggiungono o rimuovono un tipo di base o rinominano, lo romperanno).

defprotocol Typeable, do: def typeof(self)
defimpl Typeable, for: Atom, do: def typeof(_), do: "Atom"
defimpl Typeable, for: BitString, do: def typeof(_), do: "BitString"
defimpl Typeable, for: Float, do: def typeof(_), do: "Float"
defimpl Typeable, for: Function, do: def typeof(_), do: "Function"
defimpl Typeable, for: Integer, do: def typeof(_), do: "Integer"
defimpl Typeable, for: List, do: def typeof(_), do: "List"
defimpl Typeable, for: Map, do: def typeof(_), do: "Map"
defimpl Typeable, for: PID, do: def typeof(_), do: "PID"
defimpl Typeable, for: Port, do: def typeof(_), do: "Port"
defimpl Typeable, for: Reference, do: def typeof(_), do: "Reference"
defimpl Typeable, for: Tuple, do: def typeof(_), do: "Tuple"

IO.puts Typeable.typeof "Hi"
IO.puts Typeable.typeof :ok

Ho appena incollato il codice da https://elixirforum.com/t/just-created-a-typeof-module/2583/5 :)

defmodule Util do
  types = ~w[function nil integer binary bitstring list map float atom tuple pid port reference]
  for type <- types do
    def typeof(x) when unquote(:"is_#{type}")(x), do: unquote(type)
  end
end

Mi sono imbattuto in una situazione necessaria per verificare il parametro deve essere di un certo tipo. Forse puoi attivare un modo migliore.

Come questo:

@required [{"body", "binary"},{"fee", "integer"}, ...]
defp match_desire?({value, type}) do
  apply(Kernel, :"is_#{type}", [value])
end

Uso:

Enum.map(@required, &(match_desire?/1))

Solo perché nessuno lo ha menzionato

IO.inspect/1

Output per console l'oggetto ... è quasi equivalente a JSON.stringify

Molto utile quando proprio non riesci a capire come appare un oggetto in un test.