Como você verifica o tipo de variável no Elixir

No Elixir, como você verifica tipos, como em Python:

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

Li no Elixir que existem verificadores de tipos como 'is_bitstring', 'is_float', 'is_list', 'is_map' etc.

Não existe uma maneira direta de obter o tipo de uma variável no Elixir / Erlang.

Você geralmente deseja saber o tipo de uma variável para agir em conformidade; você pode usar as is_*funções para agir com base no tipo de uma variável.

Aprenda você Alguns Erlang tem um bom capítulo sobre como digitar Erlang (e, portanto, Elixir).

A maneira mais idiomática de usar a is_*família de funções provavelmente seria usá-las em correspondências de padrões:

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 partir do elixir 1.2, existe um icomando no iex que lista o tipo e mais de qualquer variável do Elixir.

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 você procurar no código o icomando, verá que isso é implementado por meio de um protocolo.

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

Se você deseja implementar uma função para qualquer tipo de dados no Elixir, a maneira de fazer isso é definir um protocolo e a implementação do protocolo para todos os tipos de dados nos quais você deseja que a função trabalhe. Infelizmente, você não pode usar uma função de protocolo nos guardas. No entanto, um protocolo "tipo" simples seria muito simples de implementar.

Também para fins de depuração, se você não estiver no iex, pode chamá-lo diretamente:

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

Outra abordagem é usar a correspondência de padrões. Digamos que você esteja usando o Timex, que usa uma %DateTime{}estrutura, e deseja ver se um elemento é um. Você pode encontrar uma correspondência usando a correspondência de padrões no método

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

def is_a_datetime?(_) do
  false
end

Vou deixar isso aqui por causa de alguém, com sorte, descobrir uma versão realmente sã. No momento, não há boas respostas para isso chegando no 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

Por uma questão de integridade, casos de teste:

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

Aqui está uma solução com protocolos; Não tenho certeza se eles são mais rápidos (espero que eles não estejam fazendo um loop em todos os tipos), mas é muito feio (e frágil; se eles adicionarem ou removerem um tipo básico ou renomearem, isso será interrompido).

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

Acabei de colar o código em 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

Me deparei com uma situação precisa verificar o parâmetro precisa ser de determinado tipo. Talvez possa ativar uma maneira melhor.

Como isso:

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

Uso:

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

Só porque ninguém mencionou

IO.inspect/1

Saídas para consolar o objeto ... é quase equivalente ao JSON.stringify

Muito útil quando você simplesmente não consegue descobrir como é um objeto em um teste.