`IO.puts "Hello world!"
接触elixir时, 学会的第一行代码是 IO.puts "Hello world!". 出于好奇, 我观察了一下 IO.puts 函数的实现.
IO
我们先到elixir源文件中的IO模块里看看.
IO 模块中 IO.puts 的定义
@doc """
Writes `item` to the given `device`, similar to `write/2`,
but adds a newline at the end.
"""
@spec puts(device, chardata | String.Chars.t) :: :ok
def puts(device \\ :stdio, item) do
:io.put_chars map_dev(device), [to_chardata(item), ?\n]
end首先看它的类型, 这里我们需要先了解一点, 在erlang和elixir中, 字符串的类型是不同的.
比如 erlang 中 [97] 等同于 "a", 而 elixir 中 <<97>> 等同于 "a".
类型 device, chardata 的定义
@type device :: atom | pid
@type chardata() :: :unicode.chardata()定义内联函数 map_dev/1, to_chardata/1.
内联函数的作用是在编译时, 调用内联函数的地方会被替换成该函数的函数体.
@compile {:inline, map_dev: 1, to_chardata: 1}
# Map the Elixir names for standard IO and error to Erlang names
defp map_dev(:stdio), do: :standard_io
defp map_dev(:stderr), do: :standard_error
defp map_dev(other) when is_atom(other) or is_pid(other) or is_tuple(other), do: other
defp to_chardata(list) when is_list(list), do: list
defp to_chardata(other), do: to_string(other)Kernel
Kernel 模块中 to_string/1 函数的定义
@doc """
Converts the argument to a string according to the
`String.Chars` protocol.
This is the function invoked when there is string interpolation.
## Examples
iex> to_string(:foo)
"foo"
"""
defmacro to_string(arg) do
quote do: String.Chars.to_string(unquote(arg))
end String.Chars protocol 对不同类型的参数的实现
import Kernel, except: [to_string: 1]
defprotocol String.Chars do
@moduledoc ~S"""
The `String.Chars` protocol is responsible for
converting a structure to a binary (only if applicable).
The only function required to be implemented is
`to_string` which does the conversion.
The `to_string/1` function automatically imported
by `Kernel` invokes this protocol. String
interpolation also invokes `to_string` in its
arguments. For example, `"foo#{bar}"` is the same
as `"foo" <> to_string(bar)`.
"""
def to_string(term)
end
defimpl String.Chars, for: Atom do
def to_string(nil) do
""
end
def to_string(atom) do
Atom.to_string(atom)
end
end
defimpl String.Chars, for: BitString do
def to_string(term) when is_binary(term) do
term
end
def to_string(term) do
raise Protocol.UndefinedError,
protocol: @protocol,
value: term,
description: "cannot convert a bitstring to a string"
end
end
defimpl String.Chars, for: List do
def to_string(charlist), do: List.to_string(charlist)
end
defimpl String.Chars, for: Integer do
def to_string(term) do
Integer.to_string(term)
end
end
defimpl String.Chars, for: Float do
def to_string(term) do
IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
end
end注意这里使用了一个神奇的 erlang 函数 -- :io_lib_format.fwrite_g 用来转换 Float, 我看了一下 erlang 的源代码, 发现了一段注释
%% Writes the shortest, correctly rounded string that converts
%% to Float when read back with list_to_float/1.
%%
%% See also "Printing Floating-Point Numbers Quickly and Accurately"
%% in Proceedings of the SIGPLAN '96 Conference on Programming
%% Language Design and Implementation.具体的实现挺复杂的, 有兴趣的朋友可以去看看 https://github.com/erlang/otp...
IO.iodata_to_binary/1 的定义
@doc """
Converts iodata (a list of integers representing bytes, lists
and binaries) into a binary.
The operation is Unicode unsafe.
Notice that this function treats lists of integers as raw bytes
and does not perform any kind of encoding conversion. If you want
to convert from a charlist to a string (UTF-8 encoded), please
use `chardata_to_string/1` instead.
If this function receives a binary, the same binary is returned.
Inlined by the compiler.
## Examples
iex> bin1 = <<1, 2, 3>>
iex> bin2 = <<4, 5>>
iex> bin3 = <<6>>
iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4 | bin3])
<<1, 2, 3, 1, 2, 3, 4, 5, 4, 6>>
iex> bin = <<1, 2, 3>>
iex> IO.iodata_to_binary(bin)
<<1, 2, 3>>
"""
@spec iodata_to_binary(iodata) :: binary
def iodata_to_binary(item) do
:erlang.iolist_to_binary(item)
end总结
内联函数的作用是在编译时, 调用内联函数的地方会被替换成该函数的函数体, 适用于短小的函数. 定义的内联函数的方法是使用模块属性
@compile {:inline, fun_a: 1, fun_b: 1}.使用
defprotocal来定义协议. 使用defimpl .., for: ..来为某种数据类型实现协议.quote do:中间没有逗号