-spec abs(Float) -> float() when Float :: float();
         (Int) -> non_neg_integer() when Int :: integer().

返回一个整数或浮点数，它是 Float 或 Int 的算术绝对值。

例如

> abs(-3.33).
3.33
> abs(-3).
3

-spec append_element(Tuple1, Term) -> Tuple2 when Tuple1 :: tuple(), Tuple2 :: tuple(), Term :: term().

返回一个新元组，它比 Tuple1 多一个元素，并包含 Tuple1 中的元素，后跟 Term 作为最后一个元素。

在语义上等同于 list_to_tuple(tuple_to_list(Tuple1) ++ [Term])，但速度更快。

例如

> erlang:append_element({one, two}, three).
{one,two,three}

-spec atom_to_binary(Atom) -> binary() when Atom :: atom().

等效于 atom_to_binary(Atom, utf8)。

-spec atom_to_binary(Atom, Encoding) -> binary()
                        when Atom :: atom(), Encoding :: latin1 | unicode | utf8.

返回与 Atom 的文本表示形式相对应的二进制数据。

如果 Encoding 是 latin1，则文本表示形式中的每个字符都存在一个字节。如果 Encoding 是 utf8 或 unicode，则字符将使用 UTF-8 编码，其中字符可能需要多个字节。

变更

从 Erlang/OTP 20 开始，原子可以包含任何 Unicode 字符，并且如果 Atom 的文本表示形式包含 Unicode 字符 > 255，则 atom_to_binary(Atom, latin1) 可能会失败。

示例

> atom_to_binary('Erlang', latin1).
<<"Erlang">>

-spec atom_to_list(Atom) -> string() when Atom :: atom().

返回与 Atom 的文本表示形式相对应的 Unicode 代码点列表。

例如

> atom_to_list('Erlang').
"Erlang"

> atom_to_list('你好').
[20320,22909]

有关如何将结果列表转换为不同格式的信息，请参见 unicode。

-spec binary_part(Subject, PosLen) -> binary()
                     when
                         Subject :: binary(),
                         PosLen :: {Start :: non_neg_integer(), Length :: integer()}.

提取由 PosLen 描述的二进制部分。

可以使用负长度来提取二进制末尾的字节。

例如

1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.
2> binary_part(Bin,{byte_size(Bin), -5}).
<<6,7,8,9,10>>

失败: 如果 PosLen 以任何方式引用二进制之外的内容，则返回 badarg。

Start 是基于零的，即

1> Bin = <<1,2,3>>
2> binary_part(Bin,{0,2}).
<<1,2>>

有关 PosLen 语义的详细信息，请参见 binary。

-spec binary_part(Subject, Start, Length) -> binary()
                     when Subject :: binary(), Start :: non_neg_integer(), Length :: integer().

等效于 binary_part(Subject, {Start, Length})。

-spec binary_to_atom(Binary) -> atom() when Binary :: binary().

等效于 binary_to_atom(Binary, utf8)。

-spec binary_to_atom(Binary, Encoding) -> atom()
                        when Binary :: binary(), Encoding :: latin1 | unicode | utf8.

返回文本表示形式为 Binary 的原子。如果 Encoding 为 utf8 或 unicode，则二进制数据必须包含有效的 UTF-8 序列。

变更

从 Erlang/OTP 20 开始，binary_to_atom(Binary, utf8) 能够解码任何 Unicode 字符。早期版本如果二进制数据包含大于 255 的 Unicode 字符，则会失败。

注意

原子名称中允许的字符数量是有限制的。默认限制可以在效率指南（系统限制部分）中找到。

注意

可以存在的原子数量有一个可配置的限制，并且原子不会被垃圾回收。因此，建议考虑 binary_to_existing_atom/2 是否比 binary_to_atom/2 更好的选择。默认限制可以在效率指南（系统限制部分）中找到。

示例

> binary_to_atom(<<"Erlang">>, latin1).
'Erlang'

> binary_to_atom(<<1024/utf8>>, utf8).
'Ѐ'

-spec binary_to_existing_atom(Binary) -> atom() when Binary :: binary().

等效于 binary_to_existing_atom(Binary, utf8)。

-spec binary_to_existing_atom(Binary, Encoding) -> atom()
                                 when Binary :: binary(), Encoding :: latin1 | unicode | utf8.

与 binary_to_atom/2 相同，但原子必须存在。

Erlang 系统对可以存在的原子总数有一个可配置的限制，并且原子不会被垃圾回收。因此，从来自不受信任来源的二进制数据（例如，从 Internet 获取的文件）创建大量原子是不安全的，例如，使用 binary_to_atom/2。因此，当输入二进制数据来自不受信任的来源时，此函数是合适的选择。

当包含在已加载的 Erlang 模块中或以编程方式创建时（例如，通过 binary_to_atom/2），原子存在于 Erlang 系统中。请参阅下一个注释，了解原子存在于 Erlang 模块的源代码中，但不存在于同一模块的编译版本中的示例。

失败：如果原子不存在，则返回 badarg。

注意

请注意，编译器可能会优化掉原子。例如，编译器会将 atom_to_list(some_atom) 重写为 "some_atom"。如果该表达式是包含模块中唯一提及原子 some_atom 的地方，则在加载模块时不会创建该原子，并且随后调用 binary_to_existing_atom(<<"some_atom">>, utf8) 将失败。

注意

原子名称中允许的字符数量是有限制的。默认限制可以在效率指南（系统限制部分）中找到。

-spec binary_to_float(Binary) -> float() when Binary :: binary().

返回文本表示形式为 Binary 的浮点数。

例如

> binary_to_float(<<"2.2017764e+0">>).
2.2017764

浮点数字符串格式与 Erlang 浮点数文字的格式相同，只是不允许使用下划线。

失败：如果 Binary 包含错误的浮点数表示，则返回 badarg。

-spec binary_to_integer(Binary) -> integer() when Binary :: binary().

返回文本表示形式为 Binary 的整数。

例如

> binary_to_integer(<<"123">>).
123

binary_to_integer/1 接受与 list_to_integer/1 相同的字符串格式。

失败：如果 Binary 包含错误的整数表示，则返回 badarg。

-spec binary_to_integer(Binary, Base) -> integer() when Binary :: binary(), Base :: 2..36.

返回以 Base 为基数的文本表示形式为 Binary 的整数。

例如

> binary_to_integer(<<"3FF">>, 16).
1023

binary_to_integer/2 接受与 list_to_integer/2 相同的字符串格式。

失败：如果 Binary 包含错误的整数表示，则返回 badarg。

-spec binary_to_list(Binary) -> [byte()] when Binary :: binary().

返回与 Binary 的字节相对应的整数列表。

-spec binary_to_list(Binary, Start, Stop) -> [byte()]
                        when Binary :: binary(), Start :: pos_integer(), Stop :: pos_integer().

与 binary_to_list/1 相同，但返回一个整数列表，该列表对应于 Binary 中从位置 Start 到位置 Stop 的字节。二进制数据中的位置从 1 开始编号。

注意

此函数使用的基于 1 的二进制索引已弃用。 新代码应使用 STDLIB 中的 binary:bin_to_list/3。模块 binary 中的所有函数都一致地使用基于 0 的索引。

-spec binary_to_term(Binary) -> term() when Binary :: ext_binary().

返回 Erlang 术语，它是解码二进制对象 Binary 的结果，该对象必须按照 Erlang 外部术语格式进行编码。

> Bin = term_to_binary(hello).
<<131,100,0,5,104,101,108,108,111>>
> hello = binary_to_term(Bin).
hello

警告

当从不受信任的来源解码二进制数据时，不受信任的来源可能会以创建无法垃圾回收并导致拒绝服务攻击的资源（例如原子和远程引用）的方式提交数据。在这种情况下，请考虑使用带有 safe 选项的 binary_to_term/2。

另请参阅 term_to_binary/1 和 binary_to_term/2。

-spec binary_to_term(Binary, Opts) -> term() | {term(), Used}
                        when
                            Binary :: ext_binary(),
                            Opt :: safe | used,
                            Opts :: [Opt],
                            Used :: pos_integer().

等效于 binary_to_term(Binary)，但可以配置为适合特殊用途。

允许的选项是

• safe - 从不受信任的来源接收二进制数据时使用此选项。

  启用后，它会阻止解码可用于攻击 Erlang 运行时的的数据。如果收到不安全的数据，解码将失败并返回 badarg 错误。

  这可以防止直接创建新原子、间接创建新原子（因为它们嵌入在某些结构中，例如进程标识符、引用和 fun）以及创建新的外部函数引用。所有这些资源都不会被垃圾回收，因此未经检查地创建它们可能会耗尽可用内存。

  > binary_to_term(<<131,100,0,5,"hello">>, [safe]).
  ** exception error: bad argument
  > hello.
  hello
  > binary_to_term(<<131,100,0,5,"hello">>, [safe]).
  hello

  警告

  safe 选项确保 Erlang 运行时安全地处理数据，但它不能保证数据对您的应用程序是安全的。您必须始终验证来自不受信任来源的数据。如果二进制数据存储在不受信任的来源中或通过不受信任的来源传输，您还应考虑对其进行加密签名。

• used - 将返回值更改为 {Term, Used}，其中 Used 是实际从 Binary 读取的字节数。

  > Input = <<131,100,0,5,"hello","world">>.
  <<131,100,0,5,104,101,108,108,111,119,111,114,108,100>>
  > {Term, Used} = binary_to_term(Input, [used]).
  {hello, 9}
  > split_binary(Input, Used).
  {<<131,100,0,5,104,101,108,108,111>>, <<"world">>}

失败：如果指定了 safe 并且解码了不安全的数据，则返回 badarg。

另请参阅 term_to_binary/1、binary_to_term/1 和 list_to_existing_atom/1。

-spec bit_size(Bitstring) -> non_neg_integer() when Bitstring :: bitstring().

返回一个整数，该整数是 Bitstring 的位大小。

例如

> bit_size(<<433:16,3:3>>).
19
> bit_size(<<1,2,3>>).
24

-spec bitstring_to_list(Bitstring) -> [byte() | bitstring()] when Bitstring :: bitstring().

返回与 Bitstring 的字节相对应的整数列表。

如果二进制数据中的位数不能被 8 整除，则列表的最后一个元素是一个包含剩余 1-7 位的位串。

例如

> bitstring_to_list(<<433:16>>).
[1,177]

> bitstring_to_list(<<433:16,3:3>>).
[1,177,<<3:3>>]

-spec byte_size(Bitstring) -> non_neg_integer() when Bitstring :: bitstring().

返回一个整数，该整数是包含 Bitstring 所需的字节数。也就是说，如果 Bitstring 中的位数不能被 8 整除，则结果字节数将向上取整。

例如

> byte_size(<<433:16,3:3>>).
3
> byte_size(<<1,2,3>>).
3

-spec ceil(Number) -> integer() when Number :: number().

返回不小于 Number 的最小整数。

例如

> ceil(5.5).
6

-spec decode_packet(Type, Bin, Options) -> {ok, Packet, Rest} | {more, Length} | {error, Reason}
                       when
                           Type ::
                               raw | 0 | 1 | 2 | 4 | asn1 | cdr | sunrm | fcgi | tpkt | line | http |
                               http_bin | httph | httph_bin,
                           Bin :: binary(),
                           Options :: [Opt],
                           Opt :: {packet_size, non_neg_integer()} | {line_length, non_neg_integer()},
                           Packet :: binary() | HttpPacket,
                           Rest :: binary(),
                           Length :: non_neg_integer() | undefined,
                           Reason :: term(),
                           HttpPacket :: HttpRequest | HttpResponse | HttpHeader | http_eoh | HttpError,
                           HttpRequest :: {http_request, HttpMethod, HttpUri, HttpVersion},
                           HttpResponse :: {http_response, HttpVersion, integer(), HttpString},
                           HttpHeader ::
                               {http_header,
                                integer(),
                                HttpField,
                                UnmodifiedField :: HttpString,
                                Value :: HttpString},
                           HttpError :: {http_error, HttpString},
                           HttpMethod ::
                               'OPTIONS' | 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' |
                               HttpString,
                           HttpUri ::
                               '*' |
                               {absoluteURI,
                                http | https,
                                Host :: HttpString,
                                Port :: inet:port_number() | undefined,
                                Path :: HttpString} |
                               {scheme, Scheme :: HttpString, HttpString} |
                               {abs_path, HttpString} |
                               HttpString,
                           HttpVersion :: {Major :: non_neg_integer(), Minor :: non_neg_integer()},
                           HttpField ::
                               'Cache-Control' | 'Connection' | 'Date' | 'Pragma' |
                               'Transfer-Encoding' | 'Upgrade' | 'Via' | 'Accept' | 'Accept-Charset' |
                               'Accept-Encoding' | 'Accept-Language' | 'Authorization' | 'From' |
                               'Host' | 'If-Modified-Since' | 'If-Match' | 'If-None-Match' |
                               'If-Range' | 'If-Unmodified-Since' | 'Max-Forwards' |
                               'Proxy-Authorization' | 'Range' | 'Referer' | 'User-Agent' | 'Age' |
                               'Location' | 'Proxy-Authenticate' | 'Public' | 'Retry-After' | 'Server' |
                               'Vary' | 'Warning' | 'Www-Authenticate' | 'Allow' | 'Content-Base' |
                               'Content-Encoding' | 'Content-Language' | 'Content-Length' |
                               'Content-Location' | 'Content-Md5' | 'Content-Range' | 'Content-Type' |
                               'Etag' | 'Expires' | 'Last-Modified' | 'Accept-Ranges' | 'Set-Cookie' |
                               'Set-Cookie2' | 'X-Forwarded-For' | 'Cookie' | 'Keep-Alive' |
                               'Proxy-Connection' | HttpString,
                           HttpString :: string() | binary().

根据 Type 指定的数据包协议解码二进制数据 Bin。类似于带有选项 {packet,Type} 的套接字所做的数据包处理。

如果整个数据包都包含在 Bin 中，则会将其与二进制数据的其余部分一起作为 {ok,Packet,Rest} 返回。

如果 Bin 不包含整个数据包，则返回 {more,Length}。Length 是数据包的预期总大小，如果预期数据包大小未知，则为 undefined。decode_packet 可以再次调用，并添加更多数据。

如果数据包不符合协议格式，则返回 {error,Reason}。

Types

• raw | 0 - 不进行数据包处理。除非二进制数据为空，否则返回整个二进制数据。

• 1 | 2 | 4 - 数据包由一个指定数据包中字节数的标头组成，后跟该数量的字节。标头的长度可以是一个、两个或四个字节；字节的顺序为大端。当返回数据包时，会剥离标头。

• line - 数据包是以分隔符字节结尾的一行，默认分隔符是 latin-1 换行符。分隔符字节包含在返回的数据包中，除非根据选项 line_length 截断了行。

• asn1 | cdr | sunrm | fcgi | tpkt - 标头不会被剥离。

  数据包类型的含义如下

  • asn1 - ASN.1 BER

  • sunrm - Sun 的 RPC 编码

  • cdr - CORBA (GIOP 1.1)

  • fcgi - Fast CGI

  • tpkt - TPKT 格式 [RFC1006]

• http | httph | http_bin | httph_bin - 超文本传输协议。返回的数据包的格式与前面描述的 HttpPacket 一致。数据包可以是请求、响应、标头或标头结束标记。无效的行作为 HttpError 返回。

  识别的请求方法和标头字段作为原子返回。其他则作为字符串返回。未识别的标头字段字符串的格式仅为首字母和连字符后的字母大写，例如 "Sec-Websocket-Key"。标头字段名称也以 UnmodifiedField 中的字符串形式返回，不进行任何转换或格式化。

  协议类型 http 仅用于预期 HttpRequest 或 HttpResponse 的第一行。后续调用应使用 httph 来获取 HttpHeader，直到返回 http_eoh，这标记着标头的结束和任何后续消息体的开始。

  变体 http_bin 和 httph_bin 返回字符串 (HttpString) 作为二进制数据而不是列表。

  自 OTP 26.0 起，Host 可以是用 [] 括起来的 IPv6 地址，如 RFC2732 中定义的那样。

选项

• {packet_size, integer() >= 0} - 设置数据包主体允许的最大大小。如果数据包头指示数据包的长度大于允许的最大长度，则认为该数据包无效。默认为 0，表示没有大小限制。

• {line_length, integer() >= 0} - 对于数据包类型 line，超过指示长度的行将被截断。

  如果未设置 packet_size，则选项 line_length 也适用于 http* 数据包类型，作为选项 packet_size 的别名。此用法仅用于向后兼容。

• {line_delimiter, 0 =< byte() =< 255} - 对于数据包类型 line，设置分隔字节。默认值为拉丁字符 $\n。

示例

> erlang:decode_packet(1,<<3,"abcd">>,[]).
{ok,<<"abc">>,<<"d">>}
> erlang:decode_packet(1,<<5,"abcd">>,[]).
{more,6}

-spec delete_element(Index, Tuple1) -> Tuple2
                        when Index :: pos_integer(), Tuple1 :: tuple(), Tuple2 :: tuple().

返回一个新元组，该元组的 Index 处的元素已从元组 Tuple1 中删除。

例如

> erlang:delete_element(2, {one, two, three}).
{one,three}

-spec display(Term) -> true when Term :: term().

在标准输出上打印 Term 的文本表示形式。

警告

此 BIF 仅用于调试。打印的表示可能包含与 Erlang 中术语的高级表示不匹配的内部细节。

-spec element(N, Tuple) -> term() when N :: pos_integer(), Tuple :: tuple().

返回 Tuple 的第 N 个元素（从 1 开始编号）。

例如

> element(2, {a, b, c}).
b

-spec external_size(Term) -> non_neg_integer() when Term :: term().

在不进行编码的情况下，计算以 Erlang 外部术语格式编码的术语的最大字节大小。

以下条件始终适用

> Size1 = byte_size(term_to_binary(Term)),
> Size2 = erlang:external_size(Term),
> true = Size1 =< Size2.
true

这等效于调用

erlang:external_size(Term, [])

-spec external_size(Term, Options) -> non_neg_integer()
                       when
                           Term :: term(),
                           Options ::
                               [compressed |
                                {compressed, Level :: 0..9} |
                                deterministic |
                                {minor_version, Version :: 0..2} |
                                local].

在不进行编码的情况下，计算以 Erlang 外部术语格式编码的术语的最大字节大小。

以下条件始终适用

> Size1 = byte_size(term_to_binary(Term, Options)),
> Size2 = erlang:external_size(Term, Options),
> true = Size1 =< Size2.
true

选项 {minor_version, Version} 指定浮点数的编码方式。有关详细描述，请参阅 term_to_binary/2。

-spec float(Number) -> float() when Number :: number().

通过将 Number 转换为浮点数来返回浮点数。

例如

> float(55).
55.0

注意

如果在 guard 中的顶层使用，它会测试参数是否为浮点数；为清楚起见，请改用 is_float/1。

当 float/1 在 guard 的表达式中使用时，例如 'float(A) == 4.0'，它会按照前面描述的方式转换数字。

-spec float_to_binary(Float) -> binary() when Float :: float().

等效于 float_to_binary(Float, [{scientific, 20}])。

-spec float_to_binary(Float, Options) -> binary()
                         when
                             Float :: float(),
                             Options :: [Option],
                             Option ::
                                 {decimals, Decimals :: 0..253} |
                                 {scientific, Decimals :: 0..249} |
                                 compact | short.

返回与 Float 的文本表示形式相对应的二进制数据，使用固定小数点格式。

Options 的行为方式与 float_to_list/2 相同。

例如

> float_to_binary(7.12, [{decimals, 4}]).
<<"7.1200">>
> float_to_binary(7.12, [{decimals, 4}, compact]).
<<"7.12">>
> float_to_binary(7.12, [{scientific, 3}]).
<<"7.120e+00">>
> float_to_binary(7.12, [short]).
<<"7.12">>
> float_to_binary(0.1+0.2, [short]).
<<"0.30000000000000004">>
> float_to_binary(0.1+0.2)
<<"3.00000000000000044409e-01">>

-spec float_to_list(Float) -> string() when Float :: float().

等效于 float_to_list(Float, [{scientific, 20}])。

-spec float_to_list(Float, Options) -> string()
                       when
                           Float :: float(),
                           Options :: [Option],
                           Option ::
                               {decimals, Decimals :: 0..253} |
                               {scientific, Decimals :: 0..249} |
                               compact | short.

返回与 Float 的文本表示形式相对应的字符串，使用固定小数点格式。

可用选项

• 如果指定了选项 decimals，则返回值最多包含小数点后的 Decimals 位数字。如果数字不适合 256 字节的内部静态缓冲区，则该函数抛出 badarg。
• 如果指定了选项 compact，则列表末尾的尾随零将被截断。此选项仅在与选项 decimals 一起使用时才有意义。
• 如果指定了选项 scientific，则浮点数将使用科学计数法格式化，精度为 Decimals 位。
• 如果指定了选项 short，则浮点数将使用最小的位数进行格式化，同时仍然保证 F =:= list_to_float(float_to_list(F, [short]))。当浮点数在范围 (-2⁵³, 2⁵³) 内时，将使用产生最小字符数的表示法（科学计数法或普通十进制表示法）。超出范围 (-2⁵³, 2⁵³) 的浮点数始终使用科学计数法进行格式化，以避免在执行算术运算时产生令人困惑的结果。
• 如果 Options 为 []，则该函数的行为与 float_to_list/1 相同。

示例

> float_to_list(7.12, [{decimals, 4}]).
"7.1200"
> float_to_list(7.12, [{decimals, 4}, compact]).
"7.12"
> float_to_list(7.12, [{scientific, 3}]).
"7.120e+00"
> float_to_list(7.12, [short]).
"7.12"
> float_to_list(0.1+0.2, [short]).
"0.30000000000000004"
> float_to_list(0.1+0.2)
"3.00000000000000044409e-01"

在最后一个示例中，float_to_list(0.1+0.2) 的计算结果为 "3.00000000000000044409e-01"。 造成这种情况的原因在 浮点数表示问题 中进行了解释。

-spec floor(Number) -> integer() when Number :: number().

返回不大于 Number 的最大整数。

例如

> floor(-10.5).
-11

-spec fun_info(Fun) -> [{Item, Info}]
                  when
                      Fun :: function(),
                      Item ::
                          arity | env | index | name | module | new_index | new_uniq | pid | type | uniq,
                      Info :: term().

返回包含有关函数 Fun 的信息的列表。每个列表元素都是一个元组。元组的顺序未定义，并且可以在将来的版本中添加更多元组。

警告

此 BIF 主要用于调试，但有时在需要验证 fun 的元数（例如）的库函数中也很有用。

两种类型的 fun 具有略微不同的语义

• 由 fun M:F/A 创建的 fun 称为外部 fun。调用它将始终调用模块 M 最新代码中元数为 A 的函数 F。请注意，当创建 fun fun M:F/A 时，甚至不需要加载模块 M。
• 所有其他 fun 都称为本地 fun。当调用本地 fun 时，将调用创建该 fun 的相同版本的代码（即使已加载模块的较新版本）。

以下元素始终存在于本地和外部 fun 的列表中

• {type, Type} - Type 是 local 或 external。

• {module, Module} - Module (一个原子) 是模块名称。

  如果 Fun 是一个本地 fun，则 Module 是定义该 fun 的模块。

  如果 Fun 是一个外部 fun，则 Module 是该 fun 引用的模块。

• {name, Name} - Name (一个原子) 是函数名称。

  如果 Fun 是一个本地 fun，则 Name 是实现该 fun 的本地函数的名称。（此名称由编译器生成，仅供参考。由于它是一个本地函数，因此无法直接调用它。）如果当前未为该 fun 加载任何代码，则返回 [] 而不是原子。

  如果 Fun 是一个外部 fun，则 Name 是该 fun 引用的已导出函数的名称。

• {arity, Arity} - Arity 是调用该 fun 时使用的参数数量。

• {env, Env} - Env (一个列表) 是该 fun 的环境或自由变量。对于外部 fun，返回的列表始终为空。

如果 Fun 是本地 fun，则以下元素仅存在于列表中

• {pid, Pid} - Pid 是本地节点上 init 进程的进程标识符。

  变更

  从 Erlang/OTP 27 开始，无论 fun 最初是在哪个进程或节点上创建的，Pid 始终指向本地 init 进程。

  请参阅 即将到来的潜在不兼容性。

• {index, Index} - Index (一个整数) 是模块 fun 表中的索引。

• {new_index, Index} - Index (一个整数) 是模块 fun 表中的索引。

• {new_uniq, Uniq} - Uniq (一个二进制数据) 是此 fun 的唯一值。它从整个模块的编译代码中计算得出。

• {uniq, Uniq} - Uniq (一个整数) 是此 fun 的唯一值。从 Erlang/OTP R15 开始，此整数从整个模块的编译代码中计算得出。在 Erlang/OTP R15 之前，此整数仅基于 fun 的主体。

-spec fun_info(Fun, Item) -> {Item, Info}
                  when Fun :: function(), Item :: fun_info_item(), Info :: term().

以 {Item,Info} 的形式返回 Fun 的由 Item 指定的信息。

对于任何 fun，Item 可以是原子 module、name、arity、env 或 type 中的任何一个。

对于本地 fun，Item 也可以是原子 index、new_index、new_uniq、uniq 和 pid 中的任何一个。对于外部 fun，任何这些项的值始终是原子 undefined。