Як перевірити тип змінної в Elixir

Як у Elixir ви перевіряєте тип типу Python:

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

Я читаю в Elixir, є такі перевірки типу, як 'is_bitstring', 'is_float', 'is_list', 'is_map' і т. Д., Але що робити, якщо ви не маєте поняття, яким може бути тип?

Немає прямого способу отримати тип змінної в Elixir / Erlang.

Зазвичай ви хочете знати тип змінної, щоб діяти відповідно; Ви можете використовувати is_*функції, щоб діяти на основі типу змінної.

Learn You Some Erlang має хорошу главу про введення тексту в Erlang (і, отже, в Elixir).

Найбільш ідіоматичним способом використання is_*сімейства функцій, мабуть, було б використання їх у відповідності шаблонів:

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

Починаючи з elixir 1.2, iв iex є команда, яка перелічить тип і більше будь-якої змінної 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

Якщо ви заглянете в код iкоманди, ви побачите, що це реалізується через протокол.

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

Якщо ви хочете реалізувати функцію для будь-якого типу даних в Elixir, спосіб зробити це - визначити протокол та реалізацію протоколу для всіх типів даних, над якими ви хочете функціонувати. На жаль, ви не можете використовувати функцію протоколу в охоронців. Однак простий протокол "типу" було б дуже просто реалізувати.

Також для налагодження, якщо ви не в iex, ви можете зателефонувати йому безпосередньо:

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

Іншим підходом є використання відповідності шаблонів. Скажіть, ви використовуєте Timex, який використовує %DateTime{}структуру, і ви хочете побачити, чи є елемент. Ви можете знайти збіг, використовуючи відповідність шаблонів у методі.

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

def is_a_datetime?(_) do
  false
end

Я просто залишу це тут заради того, щоб хтось, сподіваюся, з'ясував дійсно здорову версію. Наразі немає хороших відповідей на це, що з'являється в 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

Для повноти тестові справи:

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

Ось рішення з протоколами; Я не впевнений, чи швидші вони (я сподіваюся, що вони не роблять циклу для всіх типів), але це досить некрасиво (і крихке; якщо вони додадуть або видалять основний тип або перейменують, це порушить його).

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

Я просто вставляю код з https://elixirforum.com/t/just-create-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

Я зіткнувся з ситуацією, що потрібно перевірити, чи потрібно параметр певного типу. Можливо, може діяти кращий спосіб.

Подобається це:

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

Використання:

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

Просто тому, що ніхто цього не згадував

IO.inspect/1

Виходи для консолідації об'єкта ... його майже дорівнюють JSON.stringify

Дуже корисно, коли ви просто не можете все життя зрозуміти, як виглядає об’єкт у тесті.