Returns an integer or float that is the arithmetical absolute value of Float or Int, for example:

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

Allowed in guard tests.

Computes and returns the adler32 checksum for Data.

Continues computing the adler32 checksum by combining the previous checksum, OldAdler, with the checksum of Data.

The following code:

X = erlang:adler32(Data1),
Y = erlang:adler32(X,Data2).

assigns the same value to Y as this:

Y = erlang:adler32([Data1,Data2]).

Combines two previously computed adler32 checksums. This computation requires the size of the data object for the second checksum to be known.

The following code:

Y = erlang:adler32(Data1),
Z = erlang:adler32(Y,Data2).

assigns the same value to Z as this:

X = erlang:adler32(Data1),
Y = erlang:adler32(Data2),
Z = erlang:adler32_combine(X,Y,iolist_size(Data2)).

Create an alias which can be used when sending messages to the process that created the alias. When the alias has been deactivated, messages sent using the alias will be dropped. An alias can be deactivated using unalias/1. Currently available options for alias/1:

explicit_unalias

The alias can only be deactivated via a call to unalias/1. This is also the default behaviour if no options are passed or if alias/0 is called.

reply

The alias will be automatically deactivated when a reply message sent via the alias is received. The alias can also still be deactivated via a call to unalias/1.

Example:

server() ->
    receive
        {request, AliasReqId, Request} ->
            Result = perform_request(Request),
            AliasReqId ! {reply, AliasReqId, Result}
    end,
    server().

client(ServerPid, Request) ->
    AliasReqId = alias([reply]),
    ServerPid ! {request, AliasReqId, Request},
    %% Alias will be automatically deactivated if we receive a reply
    %% since we used the 'reply' option...
    receive
        {reply, AliasReqId, Result} -> Result
    after 5000 ->
            unalias(AliasReqId),
            %% Flush message queue in case the reply arrived
            %% just before the alias was deactivated...
            receive {reply, AliasReqId, Result} -> Result
            after 0 -> exit(timeout)
            end
    end.

Note that both the server and the client in this example must be executing on at least OTP 24 systems in order for this to work.

For more information on process aliases see the Process Aliases section of the Erlang Reference Manual.

Returns a new tuple that has one element more than Tuple1, and contains the elements in Tuple1 followed by Term as the last element. Semantically equivalent to list_to_tuple(tuple_to_list(Tuple1) ++ [Term]), but much faster. Example:

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

Calls a fun, passing the elements in Args as arguments.

If the number of elements in the arguments are known at compile time, the call is better written as Fun(Arg1, Arg2, ... ArgN).

Returns the result of applying Function in Module to Args. The applied function must be exported from Module. The arity of the function is the length of Args. Example:

> apply(lists, reverse, [[a, b, c]]).
[c,b,a]
> apply(erlang, atom_to_list, ['Erlang']).
"Erlang"

If the number of arguments are known at compile time, the call is better written as Module:Function(Arg1, Arg2, ..., ArgN).

Failure: error_handler:undefined_function/3 is called if the applied function is not exported. The error handler can be redefined (see process_flag/2). If error_handler is undefined, or if the user has redefined the default error_handler so the replacement module is undefined, an error with reason undef is generated.

The same as atom_to_binary (Atom, utf8).

Returns a binary corresponding to the text representation of Atom. If Encoding is latin1, one byte exists for each character in the text representation. If Encoding is utf8 or unicode, the characters are encoded using UTF-8 where characters may require multiple bytes.

Example:

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

Returns a list of unicode code points corresponding to the text representation of Atom, for example:

> atom_to_list('Erlang').
"Erlang"

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

See unicode(3) for how to convert the resulting list to different formats.

Extracts the part of the binary described by PosLen.

Negative length can be used to extract bytes at the end of a binary, for example:

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>>

Failure: badarg if PosLen in any way references outside the binary.

Start is zero-based, that is:

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

For details about the PosLen semantics, see binary(3).

Allowed in guard tests.

The same as binary_part(Subject, {Start, Length}).

Allowed in guard tests.

The same as binary_to_atom (Binary, utf8).

Returns the atom whose text representation is Binary. If Encoding is utf8 or unicode, the binary must contain valid UTF-8 sequences.

Examples:

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

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

The same as binary_to_existing_atom (Binary, utf8).

As binary_to_atom/2, but the atom must exist.

The Erlang system has a configurable limit for the total number of atoms that can exist, and atoms are not garbage collected. Therefore, it is not safe to create many atoms from binaries that come from an untrusted source (for example, a file fetched from the Internet), for example, using binary_to_atom/2. This function is thus the appropriate option when the input binary comes from an untrusted source.

An atom exists in an Erlang system when included in a loaded Erlang module or when created programmatically (for example, by binary_to_atom/2). See the next note for an example of when an atom exists in the source code for an Erlang module but not in the compiled version of the same module.

Failure: badarg if the atom does not exist.

Returns the float whose text representation is Binary, for example:

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

The float string format is the same as the format for Erlang float literals except for that underscores are not permitted.

Failure: badarg if Binary contains a bad representation of a float.

Returns an integer whose text representation is Binary, for example:

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

binary_to_integer/1 accepts the same string formats as list_to_integer/1.

Failure: badarg if Binary contains a bad representation of an integer.

Returns an integer whose text representation in base Base is Binary, for example:

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

binary_to_integer/2 accepts the same string formats as list_to_integer/2.

Failure: badarg if Binary contains a bad representation of an integer.

Returns a list of integers corresponding to the bytes of Binary.

As binary_to_list/1, but returns a list of integers corresponding to the bytes from position Start to position Stop in Binary. The positions in the binary are numbered starting from 1.

Returns an Erlang term that is the result of decoding binary object Binary, which must be encoded according to the Erlang external term format.

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

See also term_to_binary/1 and binary_to_term/2.

As binary_to_term/1, but takes these options:

safe

Use this option when receiving binaries from an untrusted source.

When enabled, it prevents decoding data that can be used to attack the Erlang runtime. In the event of receiving unsafe data, decoding fails with a badarg error.

This prevents creation of new atoms directly, creation of new atoms indirectly (as they are embedded in certain structures, such as process identifiers, refs, and funs), and creation of new external function references. None of those resources are garbage collected, so unchecked creation of them can exhaust available memory.

> 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

Warning

The safe option ensures the data is safely processed by the Erlang runtime but it does not guarantee the data is safe to your application. You must always validate data from untrusted sources. If the binary is stored or transits through untrusted sources, you should also consider cryptographically signing it.

used

Changes the return value to {Term, Used} where Used is the number of bytes actually read from 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">>}

Failure: badarg if safe is specified and unsafe data is decoded.

See also term_to_binary/1, binary_to_term/1, and list_to_existing_atom/1.

Returns an integer that is the size in bits of Bitstring, for example:

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

Allowed in guard tests.

Returns a list of integers corresponding to the bytes of Bitstring. If the number of bits in the binary is not divisible by 8, the last element of the list is a bitstring containing the remaining 1-7 bits. Examples:

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

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

This implementation-dependent function increments the reduction counter for the calling process. In the Beam emulator, the reduction counter is normally incremented by one for each function and BIF call. A context switch is forced when the counter reaches the maximum number of reductions for a process (4000 reductions in Erlang/OTP 19.2 and later).

Returns an integer that is the number of bytes needed to contain Bitstring. That is, if the number of bits in Bitstring is not divisible by 8, the resulting number of bytes is rounded up. Examples:

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

Allowed in guard tests.

Cancels a timer. The same as calling erlang:cancel_timer(TimerRef, []).

Cancels a timer that has been created by erlang:start_timer or erlang:send_after. TimerRef identifies the timer, and was returned by the BIF that created the timer.

Options:

{async, Async}

Asynchronous request for cancellation. Async defaults to false, which causes the cancellation to be performed synchronously. When Async is set to true, the cancel operation is performed asynchronously. That is, cancel_timer() sends an asynchronous request for cancellation to the timer service that manages the timer, and then returns ok.

{info, Info}

Requests information about the Result of the cancellation. Info defaults to true, which means the Result is given. When Info is set to false, no information about the result of the cancellation is given.

• When Async is false: if Info is true, the Result is returned by erlang:cancel_timer(). otherwise ok is returned.

• When Async is true: if Info is true, a message on the form {cancel_timer, TimerRef, Result} is sent to the caller of erlang:cancel_timer() when the cancellation operation has been performed, otherwise no message is sent.

More Options may be added in the future.

If Result is an integer, it represents the time in milliseconds left until the canceled timer would have expired.

If Result is false, a timer corresponding to TimerRef could not be found. This can be either because the timer had expired, already had been canceled, or because TimerRef never corresponded to a timer. Even if the timer had expired, it does not tell you if the time-out message has arrived at its destination yet.

See also erlang:send_after/4, erlang:start_timer/4, and erlang:read_timer/2.

Returns the smallest integer not less than Number. For example:

> ceil(5.5).
6

Allowed in guard tests.

Returns true if Module has old code, otherwise false.

See also code(3).

The same as check_process_code(Pid, Module, []) .

Checks if the node local process identified by Pid executes old code for Module.

Options:

{allow_gc, boolean()}

Determines if garbage collection is allowed when performing the operation. If {allow_gc, false} is passed, and a garbage collection is needed to determine the result of the operation, the operation is aborted (see information on CheckResult below). The default is to allow garbage collection, that is, {allow_gc, true}.

{async, RequestId}

The function check_process_code/3 returns the value async immediately after the request has been sent. When the request has been processed, the process that called this function is passed a message on the form {check_process_code, RequestId, CheckResult}.

If Pid equals self(), and no async option has been passed, the operation is performed at once. Otherwise a request for the operation is sent to the process identified by Pid, and is handled when appropriate. If no async option has been passed, the caller blocks until CheckResult is available and can be returned.

CheckResult informs about the result of the request as follows:

true

The process identified by Pid executes old code for Module. That is, the current call of the process executes old code for this module, or the process has references to old code for this module, or the process contains funs that references old code for this module.

false

The process identified by Pid does not execute old code for Module.

aborted

The operation was aborted, as the process needed to be garbage collected to determine the operation result, and the operation was requested by passing option {allow_gc, false}.

See also code(3).

Failures:

badarg

If Pid is not a node local process identifier.

badarg

If Module is not an atom.

badarg

If OptionList is an invalid list of options.

Converts the Time value of time unit FromUnit to the corresponding ConvertedTime value of time unit ToUnit. The result is rounded using the floor function.

Computes and returns the crc32 (IEEE 802.3 style) checksum for Data.

Continues computing the crc32 checksum by combining the previous checksum, OldCrc, with the checksum of Data.

The following code:

X = erlang:crc32(Data1),
Y = erlang:crc32(X,Data2).

assigns the same value to Y as this:

Y = erlang:crc32([Data1,Data2]).

Combines two previously computed crc32 checksums. This computation requires the size of the data object for the second checksum to be known.

The following code:

Y = erlang:crc32(Data1),
Z = erlang:crc32(Y,Data2).

assigns the same value to Z as this:

X = erlang:crc32(Data1),
Y = erlang:crc32(Data2),
Z = erlang:crc32_combine(X,Y,iolist_size(Data2)).

Returns the current date as {Year, Month, Day}.

The time zone and Daylight Saving Time correction depend on the underlying OS. The return value is based on the OS System Time. Example:

> date().
{1995,2,19}

Decodes the binary Bin according to the packet protocol specified by Type. Similar to the packet handling done by sockets with option {packet,Type}.

If an entire packet is contained in Bin, it is returned together with the remainder of the binary as {ok,Packet,Rest}.

If Bin does not contain the entire packet, {more,Length} is returned. Length is either the expected total size of the packet, or undefined if the expected packet size is unknown. decode_packet can then be called again with more data added.

If the packet does not conform to the protocol format, {error,Reason} is returned.

Types:

raw | 0

No packet handling is done. The entire binary is returned unless it is empty.

1 | 2 | 4

Packets consist of a header specifying the number of bytes in the packet, followed by that number of bytes. The length of the header can be one, two, or four bytes; the order of the bytes is big-endian. The header is stripped off when the packet is returned.

line

A packet is a line-terminated by a delimiter byte, default is the latin-1 newline character. The delimiter byte is included in the returned packet unless the line was truncated according to option line_length.

asn1 | cdr | sunrm | fcgi | tpkt

The header is not stripped off.

The meanings of the packet types are as follows:

asn1 - ASN.1 BER

sunrm - Sun's RPC encoding

cdr - CORBA (GIOP 1.1)

fcgi - Fast CGI

tpkt - TPKT format [RFC1006]

http | httph | http_bin | httph_bin

The Hypertext Transfer Protocol. The packets are returned with the format according to HttpPacket described earlier. A packet is either a request, a response, a header, or an end of header mark. Invalid lines are returned as HttpError.

Recognized request methods and header fields are returned as atoms. Others are returned as strings. Strings of unrecognized header fields are formatted with only capital letters first and after hyphen characters, for example, "Sec-Websocket-Key". Header field names are also returned in UnmodifiedField as strings, without any conversion or formatting.

The protocol type http is only to be used for the first line when an HttpRequest or an HttpResponse is expected. The following calls are to use httph to get HttpHeaders until http_eoh is returned, which marks the end of the headers and the beginning of any following message body.

The variants http_bin and httph_bin return strings (HttpString) as binaries instead of lists.

Options:

{packet_size, integer() >= 0}

Sets the maximum allowed size of the packet body. If the packet header indicates that the length of the packet is longer than the maximum allowed length, the packet is considered invalid. Defaults to 0, which means no size limit.

{line_length, integer() >= 0}

For packet type line, lines longer than the indicated length are truncated.

Option line_length also applies to http* packet types as an alias for option packet_size if packet_size itself is not set. This use is only intended for backward compatibility.

{line_delimiter, 0 =< byte() =< 255}

For packet type line, sets the delimiting byte. Default is the latin-1 character $\n.

Examples:

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

Returns a new tuple with element at Index removed from tuple Tuple1, for example:

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

Makes the current code for Module become old code and deletes all references for this module from the export table. Returns undefined if the module does not exist, otherwise true.

Failure: badarg if there already is an old version of Module.

If MonitorRef is a reference that the calling process obtained by calling monitor/2, this monitoring is turned off. If the monitoring is already turned off, nothing happens.

Once demonitor(MonitorRef) has returned, it is guaranteed that no {'DOWN', MonitorRef, _, _, _} message, because of the monitor, will be placed in the caller message queue in the future. However, a {'DOWN', MonitorRef, _, _, _} message can have been placed in the caller message queue before the call. It is therefore usually advisable to remove such a 'DOWN' message from the message queue after monitoring has been stopped. demonitor(MonitorRef, [flush]) can be used instead of demonitor(MonitorRef) if this cleanup is wanted.

Failure: It is an error if MonitorRef refers to a monitoring started by another process. Not all such cases are cheap to check. If checking is cheap, the call fails with badarg, for example if MonitorRef is a remote reference.

The returned value is true unless info is part of OptionList.

demonitor(MonitorRef, []) is equivalent to demonitor(MonitorRef).

Options:

flush

Removes (one) {_, MonitorRef, _, _, _} message, if there is one, from the caller message queue after monitoring has been stopped.

Calling demonitor(MonitorRef, [flush]) is equivalent to the following, but more efficient:

demonitor(MonitorRef),
receive
    {_, MonitorRef, _, _, _} ->
        true
after 0 ->
        true
end

info

The returned value is one of the following:

true

The monitor was found and removed. In this case, no 'DOWN' message corresponding to this monitor has been delivered and will not be delivered.

false

The monitor was not found and could not be removed. This probably because someone already has placed a 'DOWN' message corresponding to this monitor in the caller message queue.

If option info is combined with option flush, false is returned if a flush was needed, otherwise true.

Failures:

badarg

If OptionList is not a list.

badarg

If Option is an invalid option.

badarg

The same failure as for demonitor/1.

Forces the disconnection of a node. This appears to the node Node as if the local node has crashed. This BIF is mainly used in the Erlang network authentication protocols.

Returns true if disconnection succeeds, otherwise false. If the local node is not alive, ignored is returned.

Prints a text representation of Term on the standard output.

Get distribution channel data from the local node that is to be passed to the remote node. The distribution channel is identified by DHandle. If no data is available, the atom none is returned. One can request to be informed by a message when more data is available by calling erlang:dist_ctrl_get_data_notification(DHandle).

The returned value when there are data available depends on the value of the get_size option configured on the distribution channel identified by DHandle. For more information see the documentation of the get_size option for the erlang:dist_ctrl_set_opt/3 function.

This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.

Returns the value of the get_size option on the distribution channel identified by DHandle. For more information see the documentation of the get_size option for the erlang:dist_ctrl_set_opt/3 function.

This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.

Request notification when more data is available to fetch using erlang:dist_ctrl_get_data(DHandle) for the distribution channel identified by DHandle. When more data is present, the caller will be sent the message dist_data. Once a dist_data messages has been sent, no more dist_data messages will be sent until the dist_ctrl_get_data_notification/1 function has been called again.

This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.

Register an alternate input handler process for the distribution channel identified by DHandle. Once this function has been called, InputHandler is the only process allowed to call erlang:dist_ctrl_put_data(DHandle, Data) with the DHandle identifing this distribution channel.

This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.

Deliver distribution channel data from a remote node to the local node.

This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.

Sets the value of the get_size option on the distribution channel identified by DHandle. This option controls the return value of calls to erlang:dist_ctrl_get_data(DHandle) where DHandle equals DHandle used when setting this option. When the get_size option is:

false

and there are distribution data available, a call to erlang:dist_ctrl_get_data(DHandle) will just return Data to pass over the channel. This is the default value of the get_size option.

true

and there are distribution data available, a call to erlang:dist_ctrl_get_data(DHandle) will return Data to pass over the channel as well as the Size of Data in bytes. This is returned as a tuple on the form {Size, Data}.

All options are set to default when a channel is closed.

This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.

Returns the Nth element (numbering from 1) of Tuple, for example:

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

Allowed in guard tests.

Returns the process dictionary and deletes it, for example:

> put(key1, {1, 2, 3}),
put(key2, [a, b, c]),
erase().
[{key1,{1,2,3}},{key2,[a,b,c]}]

Returns the value Val associated with Key and deletes it from the process dictionary. Returns undefined if no value is associated with Key. The average time complexity for the current implementation of this function is O(1) and the worst case time complexity is O(N), where N is the number of items in the process dictionary. Example:

> put(key1, {merry, lambs, are, playing}),
X = erase(key1),
{X, erase(key1)}.
{{merry,lambs,are,playing},undefined}

Raises an exception of class error with the reason Reason. As evaluating this function causes an exception to be thrown, it has no return value.

The intent of the exception class error is to signal that an unexpected error has happened (for example, a function is called with a parameter that has an incorrect type). See the guide about errors and error handling for additional information. Example:

> catch error(foobar).
{'EXIT',{foobar,[{shell,apply_fun,3,
                        [{file,"shell.erl"},{line,906}]},
                 {erl_eval,do_apply,6,[{file,"erl_eval.erl"},{line,677}]},
                 {erl_eval,expr,5,[{file,"erl_eval.erl"},{line,430}]},
                 {shell,exprs,7,[{file,"shell.erl"},{line,687}]},
                 {shell,eval_exprs,7,[{file,"shell.erl"},{line,642}]},
                 {shell,eval_loop,3,[{file,"shell.erl"},{line,627}]}]}}

Raises an exception of class error with the reason Reason. Args is expected to be the list of arguments for the current function or the atom none. If it is a list, it is used to provide the arguments for the current function in the stack back-trace. If it is none, the arity of the calling function is used in the stacktrace. As evaluating this function causes an exception to be raised, it has no return value.

The intent of the exception class error is to signal that an unexpected error has happened (for example, a function is called with a parameter that has an incorrect type). See the guide about errors and error handling for additional information. Example:

test.erl:

-module(test).
-export([example_fun/2]).

example_fun(A1, A2) ->
    erlang:error(my_error, [A1, A2]).

Erlang shell:

6> c(test).
{ok,test}
7> test:example_fun(arg1,"this is the second argument").
** exception error: my_error
     in function  test:example_fun/2
         called as test:example_fun(arg1,"this is the second argument")
 

Raises an exception of class error with the reason Reason. Args is expected to be the list of arguments for the current function or the atom none. If it is a list, it is used to provide the arguments for the current function in the stack back-trace. If it is none, the arity of the calling function is used in the stacktrace. As evaluating this function causes an exception to be raised, it has no return value.

If the error_info option is given, the ErrorInfoMap will be inserted into the stacktrace. The information given in the ErrorInfoMap is to be used by error formatters such as erl_error to provide more context around an error.

The default module of the ErrorInfoMap is the module that the call to error/3 is made. The default function is format_error. See format_error/2 for more details on how this Module:Function/2 is to be used

The intent of the exception class error is to signal that an unexpected error has happened (for example, a function is called with a parameter that has an incorrect type). See the guide about errors and error handling for additional information.

Raises an exception of class exit with exit reason Reason. As evaluating this function causes an exception to be raised, it has no return value.

The intent of the exception class exit is that the current process should be stopped (for example when a message telling a process to stop is received).

This function differ from error/1,2,3 by causing an exception of a different class and by having a reason that does not include the list of functions from the call stack.

See the guide about errors and error handling for additional information.

Example:

> exit(foobar).
** exception exit: foobar
> catch exit(foobar).
{'EXIT',foobar}

Sends an exit signal with exit reason Reason to the process or port identified by Pid.

The following behavior applies if Reason is any term, except normal or kill, and P is the process or port identified by Pid:

• If P is not trapping exits, P exits with exit reason Reason.

• If P is trapping exits, the exit signal is transformed into a message {'EXIT', From, Reason}, where From is the process identifier of the process that sent the exit signal, and delivered to the message queue of P.

The following behavior applies if Reason is the term normal and Pid is the identifier of a process P which is not the same as the process that invoked erlang:exit(Pid, normal) (the behavior when a process sends a signal with the normal reason to itself is described in the warning):

• If P is trapping exits, the exit signal is transformed into a message {'EXIT', From, normal}, where From is the process identifier of the process that sent the exit signal, and delivered to P's message queue.
• The signal has no effect if P is not trapping exits.

If Reason is the atom kill, that is, if exit(Pid, kill) is called, an untrappable exit signal is sent to the process that is identified by Pid, which unconditionally exits with exit reason killed. The exit reason is changed from kill to killed to hint to linked processes that the killed process got killed by a call to exit(Pid, kill).

Calculates, without doing the encoding, the maximum byte size for a term encoded in the Erlang external term format. The following condition applies always:

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

This is equivalent to a call to:

erlang:external_size(Term, [])

Calculates, without doing the encoding, the maximum byte size for a term encoded in the Erlang external term format. The following condition applies always:

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

Option {minor_version, Version} specifies how floats are encoded. For a detailed description, see term_to_binary/2.

Returns a float by converting Number to a float, for example:

> float(55).
55.0

Allowed in guard tests.

The same as float_to_binary(Float,[{scientific,20}]).

Returns a binary corresponding to the text representation of Float using fixed decimal point formatting. Options behaves in the same way as float_to_list/2. Examples:

> 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">>

The same as float_to_list(Float,[{scientific,20}]).

Returns a string corresponding to the text representation of Float using fixed decimal point formatting.

Available options:

• If option decimals is specified, the returned value contains at most Decimals number of digits past the decimal point. If the number does not fit in the internal static buffer of 256 bytes, the function throws badarg.

• If option compact is specified, the trailing zeros at the end of the list are truncated. This option is only meaningful together with option decimals.

• If option scientific is specified, the float is formatted using scientific notation with Decimals digits of precision.

• If Options is [], the function behaves as float_to_list/1.

Examples:

> 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(0.1+0.2)
"3.00000000000000044409e-01"

In the last example, float_to_list(0.1+0.2) evaluates to "3.00000000000000044409e-01". The reason for this is explained in Representation of Floating Point Numbers.

Returns the largest integer not greater than Number. For example:

> floor(-10.5).
-11

Allowed in guard tests.

Returns a list with information about the fun Fun. Each list element is a tuple. The order of the tuples is undefined, and more tuples can be added in a future release.

Two types of funs have slightly different semantics:

• A fun created by fun M:F/A is called an external fun. Calling it will always call the function F with arity A in the latest code for module M. Notice that module M does not even need to be loaded when the fun fun M:F/A is created.

• All other funs are called local. When a local fun is called, the same version of the code that created the fun is called (even if a newer version of the module has been loaded).

The following elements are always present in the list for both local and external funs:

{type, Type}

Type is local or external.

{module, Module}

Module (an atom) is the module name.

If Fun is a local fun, Module is the module in which the fun is defined.

If Fun is an external fun, Module is the module that the fun refers to.

{name, Name}

Name (an atom) is a function name.

If Fun is a local fun, Name is the name of the local function that implements the fun. (This name was generated by the compiler, and is only of informational use. As it is a local function, it cannot be called directly.) If no code is currently loaded for the fun, [] is returned instead of an atom.

If Fun is an external fun, Name is the name of the exported function that the fun refers to.

{arity, Arity}

Arity is the number of arguments that the fun is to be called with.

{env, Env}

Env (a list) is the environment or free variables for the fun. For external funs, the returned list is always empty.

The following elements are only present in the list if Fun is local:

{pid, Pid}

Pid is the process identifier of the process that originally created the fun.

It might point to the init process if the Fun was statically allocated when module was loaded (this optimisation is performed for local functions that do not capture the environment).

{index, Index}

Index (an integer) is an index into the module fun table.

{new_index, Index}

Index (an integer) is an index into the module fun table.

{new_uniq, Uniq}

Uniq (a binary) is a unique value for this fun. It is calculated from the compiled code for the entire module.

{uniq, Uniq}

Uniq (an integer) is a unique value for this fun. As from Erlang/OTP R15, this integer is calculated from the compiled code for the entire module. Before Erlang/OTP R15, this integer was based on only the body of the fun.

Returns information about Fun as specified by Item, in the form {Item,Info}.

For any fun, Item can be any of the atoms module, name, arity, env, or type.

For a local fun, Item can also be any of the atoms index, new_index, new_uniq, uniq, and pid. For an external fun, the value of any of these items is always the atom undefined.

See erlang:fun_info/1.

Returns String that represents the code that created Fun.

String has the following form, if Fun was created by a fun expression of the form fun ModuleName:FuncName/Arity:

"fun ModuleName:FuncName/Arity"

The form of String when Fun is created from other types of fun expressions differs depending on if the fun expression was executed while executing compiled code or if the fun expression was executed while executing uncompiled code (uncompiled escripts, the Erlang shell, and other code executed by the erl_eval module):

compiled code

"#Fun<M.I.U>", where M, I and U correspond to the values named module, index and uniq in the result of erlang:fun_info(Fun).

uncompiled code

All funs created from fun expressions in uncompiled code with the same arity are mapped to the same list by fun_to_list/1.

Examples:

-module(test).
-export([add/1, add2/0, fun_tuple/0]).
add(A) -> fun(B) -> A + B end.
add2() -> fun add/1.
fun_tuple() -> {fun() -> 1 end, fun() -> 1 end}.

> {fun test:add/1, test:add2()}.
{fun test:add/1,#Fun<test.1.107738983>}

Explanation: fun test:add/1 is upgradable but test:add2() is not upgradable.

> {test:add(1), test:add(42)}.
{#Fun<test.0.107738983>,#Fun<test.0.107738983>}

Explanation: test:add(1) and test:add(42) has the same string representation as the environment is not taken into account.

>test:fun_tuple().
{#Fun<test.2.107738983>,#Fun<test.3.107738983>}

Explanation: The string representations differ because the funs come from different fun experssions.

> {fun() -> 1 end, fun() -> 1 end}. > 
{#Fun<erl_eval.45.97283095>,#Fun<erl_eval.45.97283095>}

Explanation: All funs created from fun expressions of this form in uncompiled code with the same arity are mapped to the same list by fun_to_list/1.

Returns true if the module Module is current and contains an exported function Function/Arity, or if there is a BIF (a built-in function implemented in C) with the specified name, otherwise returns false.

Forces an immediate garbage collection of the executing process. The function is not to be used unless it has been noticed (or there are good reasons to suspect) that the spontaneous garbage collection will occur too late or not at all.

The same as garbage_collect(Pid, []).

Garbage collects the node local process identified by Pid.

Option:

{async, RequestId}

The function garbage_collect/2 returns the value async immediately after the request has been sent. When the request has been processed, the process that called this function is passed a message on the form {garbage_collect, RequestId, GCResult}.

{type, 'major' | 'minor'}

Triggers garbage collection of requested type. Default value is 'major', which would trigger a fullsweep GC. The option 'minor' is considered a hint and may lead to either minor or major GC run.

If Pid equals self(), and no async option has been passed, the garbage collection is performed at once, that is, the same as calling garbage_collect/0. Otherwise a request for garbage collection is sent to the process identified by Pid, and will be handled when appropriate. If no async option has been passed, the caller blocks until GCResult is available and can be returned.

GCResult informs about the result of the garbage collection request as follows:

true

The process identified by Pid has been garbage collected.

false

No garbage collection was performed, as the process identified by Pid terminated before the request could be satisfied.

Notice that the same caveats apply as for garbage_collect/0.

Failures:

badarg

If Pid is not a node local process identifier.

badarg

If OptionList is an invalid list of options.

Returns the process dictionary as a list of {Key, Val} tuples. The items in the returned list can be in any order. Example:

> put(key1, merry),
put(key2, lambs),
put(key3, {are, playing}),
get().
[{key1,merry},{key2,lambs},{key3,{are,playing}}]

Returns the value Val associated with Key in the process dictionary, or undefined if Key does not exist. The expected time complexity for the current implementation of this function is O(1) and the worst case time complexity is O(N), where N is the number of items in the process dictionary. Example:

> put(key1, merry),
put(key2, lambs),
put({any, [valid, term]}, {are, playing}),
get({any, [valid, term]}).
{are,playing}

Returns the magic cookie of the local node if the node is alive, otherwise the atom nocookie.

Returns the magic cookie for node Node if the local node is alive, otherwise the atom nocookie.

Returns a list of all keys present in the process dictionary. The items in the returned list can be in any order. Example:

> put(dog, {animal,1}),
put(cow, {animal,2}),
put(lamb, {animal,3}),
get_keys().
[dog,cow,lamb]

Returns a list of keys that are associated with the value Val in the process dictionary. The items in the returned list can be in any order. Example:

> put(mary, {1, 2}),
put(had, {1, 2}),
put(a, {1, 2}),
put(little, {1, 2}),
put(dog, {1, 3}),
put(lamb, {1, 2}),
get_keys({1, 2}).
[mary,had,a,little,lamb]

Returns the process identifier of the group leader for the process evaluating the function.

Every process is a member of some process group and all groups have a group leader. All I/O from the group is channeled to the group leader. When a new process is spawned, it gets the same group leader as the spawning process. Initially, at system startup, init is both its own group leader and the group leader of all processes.

Sets the group leader of Pid to GroupLeader. Typically, this is used when a process started from a certain shell is to have another group leader than init.

The group leader should be rarely changed in applications with a supervision tree, because OTP assumes the group leader of their processes is their application master.

Setting the group leader follows the signal ordering guarentees described in the Processes Chapter in the Erlang Reference Manual.

See also group_leader/0 and OTP design principles related to starting and stopping applications.

The same as halt(0, []). Example:

> halt().
os_prompt%

The same as halt(Status, []). Example:

> halt(17).
os_prompt% echo $?
17
os_prompt%

Status must be a non-negative integer, a string, or the atom abort. Halts the Erlang runtime system. Has no return value. Depending on Status, the following occurs:

integer()

The runtime system exits with integer value Status as status code to the calling environment (OS).

Note

On many platforms, the OS supports only status codes 0-255. A too large status code is truncated by clearing the high bits.

string()

An Erlang crash dump is produced with Status as slogan. Then the runtime system exits with status code 1. The string will be truncated if longer than 200 characters.

Note

Before ERTS 9.1 (OTP-20.1) only code points in the range 0-255 was accepted in the string. Now any unicode string is valid.

abort

The runtime system aborts producing a core dump, if that is enabled in the OS.

For integer Status, the Erlang runtime system closes all ports and allows async threads to finish their operations before exiting. To exit without such flushing, use Option as {flush,false}.

For statuses string() and abort, option flush is ignored and flushing is not done.

Returns the head of List, that is, the first element, for example:

> hd([1,2,3,4,5]).
1

Allowed in guard tests.

Failure: badarg if List is the empty list [].

Puts the calling process into a wait state where its memory allocation has been reduced as much as possible. This is useful if the process does not expect to receive any messages soon.

The process is awaken when a message is sent to it, and control resumes in Module:Function with the arguments specified by Args with the call stack emptied, meaning that the process terminates when that function returns. Thus erlang:hibernate/3 never returns to its caller. The resume function Module:Function/Arity must be exported (Arity =:= length(Args)).

If the process has any message in its message queue, the process is awakened immediately in the same way as described earlier.

In more technical terms, erlang:hibernate/3 discards the call stack for the process, and then garbage collects the process. After this, all live data is in one continuous heap. The heap is then shrunken to the exact same size as the live data that it holds (even if that size is less than the minimum heap size for the process).

If the size of the live data in the process is less than the minimum heap size, the first garbage collection occurring after the process is awakened ensures that the heap size is changed to a size not smaller than the minimum heap size.

Notice that emptying the call stack means that any surrounding catch is removed and must be re-inserted after hibernation. One effect of this is that processes started using proc_lib (also indirectly, such as gen_server processes), are to use proc_lib:hibernate/3 instead, to ensure that the exception handler continues to work when the process wakes up.

Returns a new tuple with element Term inserted at position Index in tuple Tuple1. All elements from position Index and upwards are pushed one step higher in the new tuple Tuple2. Example:

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

Returns a binary corresponding to the text representation of Integer, for example:

> integer_to_binary(77).
<<"77">>

Returns a binary corresponding to the text representation of Integer in base Base, for example:

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

Returns a string corresponding to the text representation of Integer, for example:

> integer_to_list(77).
"77"

Returns a string corresponding to the text representation of Integer in base Base, for example:

> integer_to_list(1023, 16).
"3FF"

Returns an integer, that is the size in bytes, of the binary that would be the result of iolist_to_binary(Item), for example:

> iolist_size([1,2|<<3,4>>]).
4

Returns a binary that is made from the integers and binaries in IoListOrBinary, for example:

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6>>.
<<6>>
> iolist_to_binary([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6>>

Returns an iovec that is made from the integers and binaries in IoListOrBinary. This function is useful when you want to flatten an iolist but you do not need a single binary. This can be useful for passing the data to nif functions such as enif_inspect_iovec or do more efficient message passing. The advantage of using this function over iolist_to_binary/1 is that it does not have to copy off-heap binaries. Example:

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6>>.
<<6>>
%% If you pass small binaries and integers it works as iolist_to_binary
> erlang:iolist_to_iovec([Bin1,1,[2,3,Bin2],4|Bin3]).
[<<1,2,3,1,2,3,4,5,4,6>>]
%% If you pass larger binaries, they are split and returned in a form
%% optimized for calling the C function writev.
> erlang:iolist_to_iovec([<<1>>,<<2:8096>>,<<3:8096>>]).
[<<1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
   0,...>>,
 <<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
   ...>>,
 <<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,...>>]

Returns true if the local node is alive (that is, if the node can be part of a distributed system), otherwise false. A node is alive if it is started with:

1. "erl -name LONGNAME" or,
2. "erl -sname SHORTNAME".

A node can also be alive if it has got a name from a call to net_kernel:start/1 and has not been stopped by a call to net_kernel:stop/0.

Returns true if Term is an atom, otherwise false.

Allowed in guard tests.

Returns true if Term is a binary, otherwise false.

A binary always contains a complete number of bytes.

Allowed in guard tests.

Returns true if Term is a bitstring (including a binary), otherwise false.

Allowed in guard tests.

Returns true if Term is the atom true or the atom false (that is, a boolean). Otherwise returns false.

Allowed in guard tests.

This BIF is useful for builders of cross-reference tools.

Returns true if Module:Function/Arity is a BIF implemented in C, otherwise false.

Returns true if Term is a floating point number, otherwise false.

Allowed in guard tests.

Returns true if Term is a fun, otherwise false.

Allowed in guard tests.

Returns true if Term is a fun that can be applied with Arity number of arguments, otherwise false.

Allowed in guard tests.

Returns true if Term is an integer, otherwise false.

Allowed in guard tests.

Returns true if Term is a list with zero or more elements, otherwise false.

Allowed in guard tests.

Returns true if Term is a map, otherwise false.

Allowed in guard tests.

Returns true if map Map contains Key and returns false if it does not contain the Key.

The call fails with a {badmap,Map} exception if Map is not a map.

Example:

> Map = #{"42" => value}.
#{"42" => value}
> is_map_key("42",Map).
true
> is_map_key(value,Map).
false

Allowed in guard tests.

Returns true if Term is an integer or a floating point number. Otherwise returns false.

Allowed in guard tests.

Returns true if Term is a process identifier, otherwise false.

Allowed in guard tests.

Returns true if Term is a port identifier, otherwise false.

Allowed in guard tests.

Pid must refer to a process at the local node.

Returns true if the process exists and is alive, that is, is not exiting and has not exited. Otherwise returns false.

If process P1 calls is_process_alive(P2Pid) it is guaranteed that all signals, sent from P1 to P2 (P2 is the process with identifier P2Pid) before the call, will be delivered to P2 before the aliveness of P2 is checked. This guarantee means that one can use is_process_alive/1 to let a process P1 wait until a process P2, which has got an exit signal with reason kill from P1, is killed. Example:

exit(P2Pid, kill),
% P2 might not be killed
is_process_alive(P2Pid),
% P2 is not alive (the call above always return false)

See the documentation about signals and erlang:exit/2 for more information about signals and exit singnals.

Returns true if Term is a tuple and its first element is RecordTag. Otherwise returns false.

Allowed in guard tests, if RecordTag is a literal atom.

RecordTag must be an atom.

Returns true if Term is a tuple, its first element is RecordTag, and its size is Size. Otherwise returns false.

Allowed in guard tests if RecordTag is a literal atom and Size is a literal integer.

Returns true if Term is a reference, otherwise false.

Allowed in guard tests.

Returns true if Term is a tuple, otherwise false.

Allowed in guard tests.

Returns the length of List, for example:

> length([1,2,3,4,5,6,7,8,9]).
9

Allowed in guard tests.

Sets up and activates a link between the calling process and another process or a port identified by PidOrPort. We will from here on call the identified process or port linkee. If the linkee is a port, it must reside on the same node as the caller.

If one of the participants of a link terminates, it will send an exit signal to the other participant. The exit signal will contain the exit reason of the terminated participant. Other cases when exit signals are triggered due to a link are when no linkee exist (noproc exit reason) and when the connection between linked processes on different nodes is lost or cannot be established (noconnection exit reason).

An existing link can be removed by calling unlink/1. For more information on links and exit signals due to links, see the Processes chapter in the Erlang Reference Manual:

• Links
• Sending Exit Signals
• Receiving Exit Signals

For historical reasons, link/1 has a strange semi-synchronous behavior when it is "cheap" to check if the linkee exists or not, and the caller does not trap exits. If the above is true and the linkee does not exist, link/1 will raise a noproc error exception. The expected behavior would instead have been that link/1 returned true, and the caller later was sent an exit signal with noproc exit reason, but this is unfortunately not the case. The noproc exception is not to be confused with an exit signal with exit reason noproc. Currently it is "cheap" to check if the linkee exists when it is supposed to reside on the same node as the calling process.

The link setup and activation is performed asynchronously. If the link already exists, or if the caller attempts to create a link to itself, nothing is done. A detailed description of the link protocol can be found in the Distribution Protocol chapter of the ERTS User's Guide.

Failure:

• badarg if PidOrPort does not identify a process or a node local port.
• noproc linkee does not exist and it is "cheap" to check if it exists as described above.

Returns the atom whose text representation is String.

As from Erlang/OTP 20, String may contain any Unicode character. Earlier versions allowed only ISO-latin-1 characters as the implementation did not allow Unicode characters above 255.

Example:

> list_to_atom("Erlang").
'Erlang'

Returns a binary that is made from the integers and binaries in IoList, for example:

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6>>.
<<6>>
> list_to_binary([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6>>

Returns a bitstring that is made from the integers and bitstrings in BitstringList. (The last tail in BitstringList is allowed to be a bitstring.) Example:

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6,7:4>>.
<<6,7:4>>
> list_to_bitstring([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6,7:4>>

Returns the atom whose text representation is String, but only if there already exists such atom. An atom exists if it has been created by the run-time system by either loading code or creating a term in which the atom is part.

Failure: badarg if there does not already exist an atom whose text representation is String.

Returns the float whose text representation is String, for example:

> list_to_float("2.2017764e+0").
2.2017764

The float string format is the same as the format for Erlang float literals except for that underscores are not permitted.

Failure: badarg if String contains a bad representation of a float.

Returns an integer whose text representation is String, for example:

> list_to_integer("123").
123

> list_to_integer("-123").
-123

> list_to_integer("+123234982304982309482093833234234").
123234982304982309482093833234234

String must contain at least one digit character and can have an optional prefix consisting of a single "+" or "-" character (that is, String must match the regular expression "^[+-]?[0-9]+$").

Failure: badarg if String contains a bad representation of an integer.

Returns an integer whose text representation in base Base is String, for example:

> list_to_integer("3FF", 16).
1023

> list_to_integer("+3FF", 16).
1023

> list_to_integer("3ff", 16).
1023

> list_to_integer("3fF", 16).
1023

> list_to_integer("-3FF", 16).
-1023

For example, when Base is 16, String must match the regular expression "^[+-]?([0-9]|[A-F]|[a-f])+$".

Failure: badarg if String contains a bad representation of an integer.

Returns a process identifier whose text representation is a String, for example:

> list_to_pid("<0.4.1>").
<0.4.1>

Failure: badarg if String contains a bad representation of a process identifier.

Returns a port identifier whose text representation is a String, for example:

> list_to_port("#Port<0.4>").
#Port<0.4>

Failure: badarg if String contains a bad representation of a port identifier.

Returns a reference whose text representation is a String, for example:

> list_to_ref("#Ref<0.4192537678.4073193475.71181>").
#Ref<0.4192537678.4073193475.71181>

Failure: badarg if String contains a bad representation of a reference.

Returns a tuple corresponding to List, for example

> list_to_tuple([share, ['Ericsson_B', 163]]).
{share, ['Ericsson_B', 163]}

List can contain any Erlang terms.

If Binary contains the object code for module Module, this BIF loads that object code. If the code for module Module already exists, all export references are replaced so they point to the newly loaded code. The previously loaded code is kept in the system as old code, as there can still be processes executing that code.

Returns either {module, Module}, or {error, Reason} if loading fails. Reason is one of the following:

badfile

The object code in Binary has an incorrect format or the object code contains code for another module than Module.

not_purged

Binary contains a module that cannot be loaded because old code for this module already exists.

on_load

The code in Binary contains an on_load declaration that must be executed before Binary can become the current code. Any previous current code for Module will remain until the on_load call has finished.

Loads and links a dynamic library containing native implemented functions (NIFs) for a module. Path is a file path to the shareable object/dynamic library file minus the OS-dependent file extension (.so for Unix and .dll for Windows). Notice that on most OSs the library has to have a different name on disc when an upgrade of the nif is done. If the name is the same, but the contents differ, the old library may be loaded instead. For information on how to implement a NIF library, see erl_nif(3).

LoadInfo can be any term. It is passed on to the library as part of the initialization. A good practice is to include a module version number to support future code upgrade scenarios.

The call to load_nif/2 must be made directly from the Erlang code of the module that the NIF library belongs to. It returns either ok, or {error,{Reason,Text}} if loading fails. Reason is one of the following atoms while Text is a human readable string that can give more information about the failure:

load_failed

The OS failed to load the NIF library.

bad_lib

The library did not fulfill the requirements as a NIF library of the calling module.

load | upgrade

The corresponding library callback was unsuccessful.

reload

A NIF library is already loaded for this module instance. The previously deprecated reload feature was removed in OTP 20.

old_code

The call to load_nif/2 was made from the old code of a module that has been upgraded; this is not allowed.

Returns a list of all loaded Erlang modules (current and old code), including preloaded modules.

See also code(3).

Returns the current local date and time, {{Year, Month, Day}, {Hour, Minute, Second}}, for example:

> erlang:localtime().
{{1996,11,6},{14,45,17}}

The time zone and Daylight Saving Time correction depend on the underlying OS. The return value is based on the OS System Time.

Converts local date and time to Universal Time Coordinated (UTC), if supported by the underlying OS. Otherwise no conversion is done and Localtime is returned. Example:

> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}).
{{1996,11,6},{13,45,17}}

Failure: badarg if Localtime denotes an invalid date and time.

Converts local date and time to Universal Time Coordinated (UTC) as erlang:localtime_to_universaltime/1, but the caller decides if Daylight Saving Time is active.

If IsDst == true, Localtime is during Daylight Saving Time, if IsDst == false it is not. If IsDst == undefined, the underlying OS can guess, which is the same as calling erlang:localtime_to_universaltime(Localtime).

Examples:

> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, true).
{{1996,11,6},{12,45,17}}
> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, false).
{{1996,11,6},{13,45,17}}
> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, undefined).
{{1996,11,6},{13,45,17}}

Failure: badarg if Localtime denotes an invalid date and time.

Returns a unique reference. The reference is unique among connected nodes.

Creates a new tuple of the specified Arity, where all elements are InitialValue, for example:

> erlang:make_tuple(4, []).
{[],[],[],[]}

Creates a tuple of size Arity, where each element has value DefaultValue, and then fills in values from InitList. Each list element in InitList must be a two-tuple, where the first element is a position in the newly created tuple and the second element is any term. If a position occurs more than once in the list, the term corresponding to the last occurrence is used. Example:

> erlang:make_tuple(5, [], [{2,ignored},{5,zz},{2,aa}]).
{[],aa,[],[],zz}

Returns value Value associated with Key if Map contains Key.

The call fails with a {badmap,Map} exception if Map is not a map, or with a {badkey,Key} exception if no value is associated with Key.

Example:

> Key = 1337,
  Map = #{42 => value_two,1337 => "value one","a" => 1},
  map_get(Key,Map).
"value one"

Allowed in guard tests.

Returns an integer, which is the number of key-value pairs in Map, for example:

> map_size(#{a=>1, b=>2, c=>3}).
3

Allowed in guard tests.

Tests a match specification used in calls to ets:select/2 and erlang:trace_pattern/3. The function tests both a match specification for "syntactic" correctness and runs the match specification against the object. If the match specification contains errors, the tuple {error, Errors} is returned, where Errors is a list of natural language descriptions of what was wrong with the match specification.

If Type is table, the object to match against is to be a tuple. The function then returns {ok,Result,[],Warnings}, where Result is what would have been the result in a real ets:select/2 call, or false if the match specification does not match the object tuple.

If Type is trace, the object to match against is to be a list. The function returns {ok, Result, Flags, Warnings}, where Result is one of the following:

• true if a trace message is to be emitted
• false if a trace message is not to be emitted
• The message term to be appended to the trace message

Flags is a list containing all the trace flags to be enabled, currently this is only return_trace.

This is a useful debugging and test tool, especially when writing complicated match specifications.

See also ets:test_ms/2.

Returns the largest of Term1 and Term2. If the terms compare equal with the == operator, Term1 is returned.

The Expressions section contains descriptions of the == operator and how terms are ordered.

Examples:

> max(1, 2).
2

> max(1.0, 1).
1.0

> max(1, 1.0).
1

> max("abc", "b").
"b"

Computes an MD5 message digest from Data, where the length of the digest is 128 bits (16 bytes). Data is a binary or a list of small integers and binaries.

For more information about MD5, see RFC 1321 - The MD5 Message-Digest Algorithm.

Finishes the update of an MD5 Context and returns the computed MD5 message digest.

Creates an MD5 context, to be used in the following calls to md5_update/2.

Update an MD5 Context with Data and returns a NewContext.

Returns a list with information about memory dynamically allocated by the Erlang emulator. Each list element is a tuple {Type, Size}. The first element Type is an atom describing memory type. The second element Size is the memory size in bytes.

Memory types:

total

The total amount of memory currently allocated. This is the same as the sum of the memory size for processes and system.

processes

The total amount of memory currently allocated for the Erlang processes.

processes_used

The total amount of memory currently used by the Erlang processes. This is part of the memory presented as processes memory.

system

The total amount of memory currently allocated for the emulator that is not directly related to any Erlang process. Memory presented as processes is not included in this memory. instrument(3) can be used to get a more detailed breakdown of what memory is part of this type.

atom

The total amount of memory currently allocated for atoms. This memory is part of the memory presented as system memory.

atom_used

The total amount of memory currently used for atoms. This memory is part of the memory presented as atom memory.

binary

The total amount of memory currently allocated for binaries. This memory is part of the memory presented as system memory.

code

The total amount of memory currently allocated for Erlang code. This memory is part of the memory presented as system memory.

ets

The total amount of memory currently allocated for ETS tables. This memory is part of the memory presented as system memory.

maximum

The maximum total amount of memory allocated since the emulator was started. This tuple is only present when the emulator is run with instrumentation.

For information on how to run the emulator with instrumentation, see instrument(3) and/or erl(1).

The different values have the following relation to each other. Values beginning with an uppercase letter is not part of the result.

total      = processes + system
processes  = processes_used + ProcessesNotUsed
system     = atom + binary + code + ets + OtherSystem
atom       = atom_used + AtomNotUsed
RealTotal  = processes + RealSystem
RealSystem = system + MissedSystem

More tuples in the returned list can be added in a future release.

Failure: notsup if an erts_alloc(3) allocator has been disabled.

Returns the memory size in bytes allocated for memory of type Type. The argument can also be specified as a list of memory_type() atoms, in which case a corresponding list of {memory_type(), Size :: integer >= 0} tuples is returned.

Failures:

badarg

If Type is not one of the memory types listed in the description of erlang:memory/0.

badarg

If maximum is passed as Type and the emulator is not run in instrumented mode.

notsup

If an erts_alloc(3) allocator has been disabled.

See also erlang:memory/0.

Returns the smallest of Term1 and Term2. If the terms compare equal with the == operator, Term1 is returned.

The Expressions section contains descriptions of the == operator and how terms are ordered.

Examples:

> min(1, 2).
1

> min(1.0, 1).
1.0

> min(1, 1.0).
1

> min("abc", "b").
"abc"

Returns true if the module Module is loaded, otherwise false. It does not attempt to load the module.

Sends a monitor request of type Type to the entity identified by Item. If the monitored entity does not exist or it changes monitored state, the caller of monitor/2 is notified by a message on the following format:

{Tag, MonitorRef, Type, Object, Info}

Type can be one of the following atoms: process, port or time_offset.

A process or port monitor is triggered only once, after that it is removed from both monitoring process and the monitored entity. Monitors are fired when the monitored process or port terminates, does not exist at the moment of creation, or if the connection to it is lost. If the connection to it is lost, we do not know if it still exists. The monitoring is also turned off when demonitor/1 is called.

A process or port monitor by name resolves the RegisteredName to pid() or port() only once at the moment of monitor instantiation, later changes to the name registration will not affect the existing monitor.

When a process or port monitor is triggered, a 'DOWN' message is sent that has the following pattern:

{'DOWN', MonitorRef, Type, Object, Info}

In the monitor message MonitorRef and Type are the same as described earlier, and:

Object

The monitored entity, which triggered the event. When monitoring a process or a local port, Object will be equal to the pid() or port() that was being monitored. When monitoring process or port by name, Object will have format {RegisteredName, Node} where RegisteredName is the name which has been used with monitor/2 call and Node is local or remote node name (for ports monitored by name, Node is always local node name).

Info

Either the exit reason of the process, noproc (process or port did not exist at the time of monitor creation), or noconnection (no connection to the node where the monitored process resides).

Monitoring a process

Creates monitor between the current process and another process identified by Item, which can be a pid() (local or remote), an atom RegisteredName or a tuple {RegisteredName, Node} for a registered process, located elsewhere.

Note

Before ERTS 10.0 (OTP 21.0), monitoring a process could fail with badarg if the monitored process resided on a primitive node (such as erl_interface or jinterface), where remote process monitoring is not implemented.

Now, such a call to monitor will instead succeed and a monitor is created. But the monitor will only supervise the connection. That is, a {'DOWN', _, process, _, noconnection} is the only message that may be received, as the primitive node have no way of reporting the status of the monitored process.

Monitoring a port

Creates monitor between the current process and a port identified by Item, which can be a port() (only local), an atom RegisteredName or a tuple {RegisteredName, Node} for a registered port, located on this node. Note, that attempt to monitor a remote port will result in badarg.

Monitoring a time_offset

Monitors changes in time offset between Erlang monotonic time and Erlang system time. One valid Item exists in combination with the time_offset Type, namely the atom clock_service. Notice that the atom clock_service is not the registered name of a process. In this case it serves as an identifier of the runtime system internal clock service at current runtime system instance.

The monitor is triggered when the time offset is changed. This either if the time offset value is changed, or if the offset is changed from preliminary to final during finalization of the time offset when the single time warp mode is used. When a change from preliminary to final time offset is made, the monitor is triggered once regardless of whether the time offset value was changed or not.

If the runtime system is in multi time warp mode, the time offset is changed when the runtime system detects that the OS system time has changed. The runtime system does, however, not detect this immediately when it occurs. A task checking the time offset is scheduled to execute at least once a minute, so under normal operation this is to be detected within a minute, but during heavy load it can take longer time.

The monitor is not automatically removed after it has been triggered. That is, repeated changes of the time offset trigger the monitor repeatedly.

When the monitor is triggered a 'CHANGE' message is sent to the monitoring process. A 'CHANGE' message has the following pattern:

{'CHANGE', MonitorRef, Type, Item, NewTimeOffset}

where MonitorRef, Type, and Item are the same as described above, and NewTimeOffset is the new time offset.

When the 'CHANGE' message has been received you are guaranteed not to retrieve the old time offset when calling erlang:time_offset(). Notice that you can observe the change of the time offset when calling erlang:time_offset() before you get the 'CHANGE' message.

Making several calls to monitor/2 for the same Item and/or Type is not an error; it results in as many independent monitoring instances.

The monitor functionality is expected to be extended. That is, other Types and Items are expected to be supported in a future release.

Provides an option list for modification of monitoring functionality provided by monitor/2. The Type and Item arguments have the same meaning as when passed to monitor/2. Currently available options:

{alias, UnaliasOpt}

The returned monitor reference will also become an alias for the calling process. That is, the returned reference can be used for sending messages to the calling process. See also alias/0. The UnaliasOpt determines how the alias should be deactivated.

explicit_unalias

Only an explicit call to unalias/1 will deactivate the alias.

demonitor

The alias will be automatically deactivated when the monitor is removed. This either via an explicit call to demonitor/1 or when it is automatically removed at the same time as a 'DOWN' message is delivered due to the monitor. The alias can also still be deactivated via a call to unalias/1.

reply_demonitor

The alias will be automatically deactivated when the monitor is removed (see demonitor option above) or a reply message sent via the alias is received. When a reply message is received via the alias the monitor will also be automatically removed. This is useful in client/server scenarios when a client monitors the server and will get the reply via the alias. Once the response is received both the alias and the monitor will be automatically removed regardless of whether the response is a reply or a 'DOWN' message. The alias can also still be deactivated via a call to unalias/1. Note that if the alias is removed using the unalias/1 BIF, the monitor will still be left active.

Example:

server() ->
    receive
        {request, AliasReqId, Request} ->
            Result = perform_request(Request),
            AliasReqId ! {reply, AliasReqId, Result}
    end,
    server().

client(ServerPid, Request) ->
    AliasMonReqId = monitor(process, ServerPid, [{alias, reply_demonitor}]),
    ServerPid ! {request, AliasMonReqId, Request},
    %% Alias as well as monitor will be automatically deactivated if we
    %% receive a reply or a 'DOWN' message since we used 'reply_demonitor'
    %% as unalias option...
    receive
        {reply, AliasMonReqId, Result} ->
            Result;
        {'DOWN', AliasMonReqId, process, ServerPid, ExitReason} ->
            error(ExitReason)
    end.

Note that both the server and the client in this example must be executing on at least OTP 24 systems in order for this to work.

For more information on process aliases see the Process Aliases section of the Erlang Reference Manual.

{tag, UserDefinedTag}

Replace the default Tag with UserDefinedTag in the monitor message delivered when the monitor is triggered. For example, when monitoring a process, the 'DOWN' tag in the down message will be replaced by UserDefinedTag.

An example of how the {tag, UserDefinedTag} option can be used in order to enable the new selective receive optimization, introduced in OTP 24, when making multiple requests to different servers:

server() ->
    receive
        {request, From, ReqId, Request} ->
            Result = perform_request(Request),
            From ! {reply, self(), ReqId, Result}
    end,
    server().

client(ServerPids, Request) when is_list(ServerPids) ->
    ReqId = make_ref(),
    lists:foreach(fun (ServerPid) ->
                          _ = monitor(process, ServerPid,
                                      [{tag, {'DOWN', ReqId}}]),
                          ServerPid ! {request, self(), ReqId, Request}
                  end,
                  ServerPids),
    receive_replies(ReqId, length(ServerPids), []).

receive_replies(_ReqId, 0, Acc) ->
    Acc;
receive_replies(ReqId, N, Acc) ->
    %% The compiler will detect that we match on the 'ReqId'
    %% reference in all clauses, and will enable the selective
    %% receive optimization which makes the receive able to
    %% skip past all messages present in the message queue at
    %% the time when the 'ReqId' reference was created...
    Res = receive
              {reply, ServerPid, ReqId, Result} ->
                  %% Here we typically would have deactivated the
                  %% monitor by a call to demonitor(Mon, [flush]) but
                  %% we ignore this in this example for simplicity...
                  {ok, ServerPid, Result};
              {{'DOWN', ReqId}, _Mon, process, ServerPid, ExitReason} ->
                  {error, ServerPid, ExitReason}
          end,
    receive_replies(ReqId, N-1, [Res | Acc]).

In order for this example to work as intended, the client must be executing on at least an OTP 24 system, but the servers may execute on older systems.

Monitor the status of the node Node. If Flag is true, monitoring is turned on. If Flag is false, monitoring is turned off.

Making several calls to monitor_node(Node, true) for the same Node is not an error; it results in as many independent monitoring instances.

If Node fails or does not exist, the message {nodedown, Node} is delivered to the process. If a process has made two calls to monitor_node(Node, true) and Node terminates, two nodedown messages are delivered to the process. If there is no connection to Node, an attempt is made to create one. If this fails, a nodedown message is delivered.

The delivery of the nodedown signal is not ordered with respect to other link or monitor signals from the node that goes down. If you need a guarantee that all signals from the remote node has been delivered before the nodedown signal is sent, you should use net_kernel:monitor_nodes/1.

Nodes connected through hidden connections can be monitored as any other nodes.

Failure: notalive if the local node is not alive.

Behaves as monitor_node/2 except that it allows an extra option to be specified, namely allow_passive_connect. This option allows the BIF to wait the normal network connection time-out for the monitored node to connect itself, even if it cannot be actively connected from this node (that is, it is blocked). The state where this can be useful can only be achieved by using the Kernel option dist_auto_connect once. If that option is not used, option allow_passive_connect has no effect.