Bagaimana Anda memeriksa jenis variabel di Elixir

Di Elixir bagaimana Anda memeriksa jenis seperti di Python:

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

Saya membaca di Elixir ada jenis checker seperti 'is_bitstring', 'is_float', 'is_list', 'is_map' dll, tetapi bagaimana jika Anda tidak tahu apa jenisnya?

Tidak ada cara langsung untuk mendapatkan jenis variabel di Elixir / Erlang.

Anda biasanya ingin mengetahui jenis variabel untuk bertindak sesuai; Anda bisa menggunakan is_*fungsi untuk bertindak berdasarkan tipe variabel.

Learn You Some Erlang memiliki bab yang bagus tentang mengetik di Erlang (dan karenanya dalam Elixir).

Cara paling idiomatis untuk menggunakan is_*keluarga fungsi mungkin adalah menggunakannya dalam pencocokan pola:

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

Mulai di elixir 1.2 ada iperintah dalam iex yang akan mencantumkan jenis dan lebih dari variabel 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

Jika Anda melihat dalam kode untuk iperintah Anda akan melihat bahwa ini diimplementasikan melalui Protokol.

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

Jika Anda ingin mengimplementasikan fungsi untuk tipe data apa pun di Elixir, cara untuk melakukannya adalah dengan mendefinisikan Protokol dan implementasi Protokol untuk semua tipe data yang Anda inginkan fungsi berfungsi. Sayangnya, Anda tidak dapat menggunakan fungsi Protokol dalam penjaga. Namun, protokol "tipe" sederhana akan sangat mudah diimplementasikan.

Juga untuk tujuan debugging, jika Anda tidak di iex, Anda dapat memanggilnya langsung:

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

Pendekatan lain adalah menggunakan pencocokan pola. Katakanlah Anda menggunakan Timex, yang menggunakan %DateTime{}struct, dan Anda ingin melihat apakah suatu elemen adalah satu. Anda dapat menemukan kecocokan menggunakan pencocokan pola dalam metode ini.

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

def is_a_datetime?(_) do
  false
end

Saya hanya akan meninggalkan ini di sini demi seseorang semoga mencari tahu versi yang benar-benar waras. Saat ini tidak ada jawaban yang baik untuk ini di 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

Demi kelengkapan, uji kasus:

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

Inilah solusi dengan protokol; Saya tidak yakin apakah mereka lebih cepat (saya yakin berharap mereka tidak melakukan loop atas semua jenis), tetapi itu cukup jelek (dan rapuh; jika mereka menambah atau menghapus tipe dasar atau mengganti nama, itu akan merusaknya).

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

Saya hanya menempelkan kode dari 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

Saya menemukan situasi perlu memeriksa parameter perlu jenis tertentu. Mungkin bisa aktif dengan cara yang lebih baik.

Seperti ini:

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

Pemakaian:

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

Hanya karena tidak ada yang menyebutkannya

IO.inspect/1

Output untuk menghibur objek ... hampir sama dengan JSON.stringify

Sangat membantu ketika Anda tidak bisa seumur hidup mencari tahu seperti apa suatu benda dalam sebuah tes.