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:

assigns the same value to Y as this:

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:

assigns the same value to Z as this:

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 evaluates BIFs by using the module name erlang.

> 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 the reason undef is generated.

Returns a binary corresponding to the text representation of Atom. If Encoding is latin1, there is one byte for each character in the text representation. If Encoding is utf8 or unicode, the characters are encoded using UTF-8 (that is, characters from 16#80 through 0xFF are encoded in two bytes).

Example:

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

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

> atom_to_list('Erlang').
"Erlang"

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:

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

Start is zero-based, that is:

For details about the PosLen semantics, see the binary manual page in STDLIB.

Allowed in guard tests.

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

Allowed in guard tests.

Returns the atom whose text representation is Binary. If Encoding is latin1, no translation of bytes in the binary is done. If Encoding is utf8 or unicode, the binary must contain valid UTF-8 sequences. Only Unicode characters up to 0xFF are allowed.

Examples:

> binary_to_atom(<<"Erlang">>, latin1).
'Erlang'
> binary_to_atom(<<1024/utf8>>, utf8).
** exception error: bad argument
     in function  binary_to_atom/2
        called as binary_to_atom(<<208,128>>,utf8)

As binary_to_atom/2, but the atom must exist.

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

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

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

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

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

See also term_to_binary/1 and binary_to_term/2.

As binary_to_term/1, but takes options that affect decoding of the binary.

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.

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 (2000 reductions in OTP R12B).

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

Currently available Options:

More Options may be added in the future.

When the Result equals 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 has corresponded to a timer. If the timer has expired, the timeout message has been sent, but it does not tell you whether or not it has arrived at its destination yet. When the Result is an integer, it represents the time in milli-seconds left until the timer would have expired.

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

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

Returns true if Module has old code, otherwise false.

See also code(3).

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

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

The available Options are as follows:

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:

See also code(3).

Failures:

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:

assigns the same value to Y as this:

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:

assigns the same value to Z as this:

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

The time zone and Daylight Saving Time correction depend on the underlying OS.

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.

The following Types are valid:

The following options are available:

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. A {'DOWN', MonitorRef, _, _, _} message can have been placed in the caller message queue before the call, though. 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).

The available Options are as follows:

Failures:

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. On OSE, the term is printed to the ramlog.

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.

Example:

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

Stops the execution of the calling process with the reason Reason, where Reason is any term. The exit reason is {Reason, Where}, where Where is a list of the functions most recently called (the current function first). Since evaluating this function causes the process to terminate, it has no return value.

Example:

> catch error(foobar).
{'EXIT',{foobar,[{erl_eval,do_apply,5},
                 {erl_eval,expr,5},
                 {shell,exprs,6},
                 {shell,eval_exprs,6},
                 {shell,eval_loop,3}]}}

Stops the execution of the calling process with the reason Reason, where Reason is any term. The exit reason is {Reason, Where}, where Where is a list of the functions most recently called (the current function first). Args is expected to be the list of arguments for the current function; in Beam it is used to provide the arguments for the current function in the term Where. Since evaluating this function causes the process to terminate, it has no return value.

Stops the execution of the calling process with exit reason Reason, where Reason is any term. Since evaluating this function causes the process to terminate, it has no return value.

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:

If Reason is the atom normal, Pid does not exit. If it is trapping exits, the exit signal is transformed into a message {'EXIT', From, normal} and delivered to its message queue.

If Reason is the atom kill, that is, if exit(Pid, kill) is called, an untrappable exit signal is sent to Pid, which unconditionally exits with exit reason killed.

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:

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

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

Returns a string corresponding to the text representation of Float using fixed decimal point formatting. The options are as follows:

Examples:

> float_to_list(7.12, [{decimals, 4}]).
"7.1200"
> float_to_list(7.12, [{decimals, 4}, compact]).
"7.12"

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:

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

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

Returns a string corresponding to the text representation of Fun.

Returns true if the module Module is loaded and contains an exported function Function/Arity, or if there is a BIF (a built-in function implemented in C) with the given 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.

The available Options are as follows:

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:

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

Failures:

Returns the process dictionary as a list of {Key, Val} tuples, for 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.

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 a list of keys all keys present in the process dictionary.

> 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, for 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.

See also group_leader/0.

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:

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 a hash value for Term within the range 1..Range. The range is 1..2^27-1.

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

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, what erlang:hibernate/3 does is the following. It 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 reinserted 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 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 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 true if the local node is alive (that is, if the node can be part of a distributed system), otherwise false.

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

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.

Creates a link between the calling process and another process (or port) PidOrPort, if there is not such a link already. If a process attempts to create a link to itself, nothing is done. Returns true.

If PidOrPort does not exist, the behavior of the BIF depends on if the calling process is trapping exits or not (see process_flag/2):

Returns the atom whose text representation is String.

String can only contain ISO-latin-1 characters (that is, numbers less than 256) as the implementation does not allow unicode characters equal to or above 256 in atoms. For more information on Unicode support in atoms, see note on UTF-8 encoded atoms in Section "External Term Format" in the User's Guide.

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 the atom whose text representation is String, but only if there already exists such atom.

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

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

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

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 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 any of the following:

Loads and links a dynamic library containing native implemented functions (NIFs) for a module. Path is a file path to the sharable object/dynamic library file minus the OS-dependent file extension (.so for Unix and .dll for Windows. For information on how to implement a NIF library, see erl_nif.

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:

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.

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.

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

Creates a new tuple of the given 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 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.

Returns the largest of Term1 and Term2. If the terms are equal, Term1 is returned.

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 subsequent calls to md5_update/2.

Updates an MD5 Context with Data and returns a NewContext.

Returns the smallest of Term1 and Term2. If the terms are equal, Term1 is returned.

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

Monitors 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 monitorings.

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.

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

Failure: badarg if the local node is not alive.

Behaves as monitor_node/2 except that it allows an extra option to be given, 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.

Failure: badarg if the local node is not alive or the option list is malformed.

Returns the current Erlang monotonic time in native time unit. This is a monotonically increasing time since some unspecified point in time.

Returns the current Erlang monotonic time converted into the Unit passed as argument.

Same as calling erlang:convert_time_unit(erlang:monotonic_time(), native, Unit) however optimized for commonly used Units.

Works exactly like erlang:error/1, but Dialyzer thinks that this BIF will return an arbitrary term. When used in a stub function for a NIF to generate an exception when the NIF library is not loaded, Dialyzer does not generate false warnings.

Works exactly like erlang:error/2, but Dialyzer thinks that this BIF will return an arbitrary term. When used in a stub function for a NIF to generate an exception when the NIF library is not loaded, Dialyzer does not generate false warnings.

Returns the name of the local node. If the node is not alive, nonode@nohost is returned instead.

Allowed in guard tests.

Returns the node where Arg is located. Arg can be a process identifier, a reference, or a port. If the local node is not alive, nonode@nohost is returned.

Allowed in guard tests.

Returns a list of all visible nodes in the system, except the local node. Same as nodes(visible).

Returns a list of nodes according to the argument given. The returned result when the argument is a list, is the list of nodes satisfying the disjunction(s) of the list elements.

NodeType can be any of the following:

Some equalities: [node()] = nodes(this), nodes(connected) = nodes([visible, hidden]), and nodes() = nodes(visible).

If the local node is not alive, nodes(this) == nodes(known) == [nonode@nohost]. For any other Arg the empty list [] is returned.

Returns a port identifier as the result of opening a new Erlang port. A port can be seen as an external Erlang process.

The name of the executable as well as the arguments given in cd, env, args, and arg0 are subject to Unicode filename translation if the system is running in Unicode filename mode. To avoid translation or force, that is, UTF-8, supply the executable and/or arguments as a binary in the correct encoding. For details, see the module file, the function file:native_name_encoding/0, and the STDLIB User's Guide.

PortName can be any of the following:

PortSettings is a list of settings for the port. The valid settings are as follows:

Default is stream for all port types and use_stdio for spawned ports.

Failure: If the port cannot be opened, the exit reason is badarg, system_limit, or the POSIX error code that most closely describes the error, or einval if no POSIX code is appropriate:

During use of a port opened using {spawn, Name}, {spawn_driver, Name}, or {spawn_executable, Name}, errors arising when sending messages to it are reported to the owning process using signals of the form {'EXIT', Port, PosixCode}. For the possible values of PosixCode, see the file(3) manual page in Kernel.

The maximum number of ports that can be open at the same time can be configured by passing command-line flag +Q to erl(1).

Portable hash function that gives the same hash for the same Erlang term regardless of machine architecture and ERTS version (the BIF was introduced in ERTS 4.9.1.1). Range is 1..2^32. The function returns a hash value for Term within the range 1..Range.

This BIF can be used instead of the old deprecated BIF erlang:hash/2, as it calculates better hashes for all data types, but consider using phash2/1,2 instead.

Returns a string corresponding to the text representation of Pid.

Closes an open port. Roughly the same as Port ! {self(), close} except for the error behavior (see the following), being synchronous, and that the port does not reply with {Port, closed}. Any process can close a port with port_close/1, not only the port owner (the connected process). If the calling process is linked to a port identified by Port, an exit signal is sent because that link will be received before the return from port_close/1

For comparison: Port ! {self(), close} fails with badarg if Port cannot be sent to (that is, Port refers not to a port and not to a process). If Port is a closed port, nothing happens. If Port is an open port and the calling process is the port owner, the port replies with {Port, closed} when all buffers have been flushed and the port really closes. If the calling process is not the port owner, the port owner fails with badsig.

Notice that any process can close a port using Port ! {PortOwner, close} as if it itself was the port owner, but the reply always goes to the port owner.

As from OTP R16, Port ! {PortOwner, close} is truly asynchronous. Notice that this operation has always been documented as an asynchronous operation, while the underlying implementation has been synchronous. port_close/1 is however still fully synchronous. This because of its error behavior.

Failure: badarg if Port is not an identifier of an open port, or the registered name of an open port. If the calling process was linked to the port, the exit identified by Port, the exit signal is sent because this link was delivered to the calling process before this exception occurs.

Sends data to a port. Same as Port ! {PortOwner, {command, Data}} except for the error behavior and being synchronous (see the following). Any process can send data to a port with port_command/2, not only the port owner (the connected process).

For comparison: Port ! {PortOwner, {command, Data}} fails with badarg if Port cannot be sent to (that is, Port refers not to a port and not to a process). If Port is a closed port, the data message disappears without a sound. If Port is open and the calling process is not the port owner, the port owner fails with badsig. The port owner fails with badsig also if Data is an invalid I/O list.

Notice that any process can send to a port using Port ! {PortOwner, {command, Data}} as if it itself was the port owner.

If the port is busy, the calling process is suspended until the port is not busy any more.

As from OTP-R16, Port ! {PortOwner, {command, Data}} is truly asynchronous. Notice that this operation has always been documented as an asynchronous operation, while the underlying implementation has been synchronous. port_command/2 is however still fully synchronous. This because of its error behavior.

Failures:

Sends data to a port. port_command(Port, Data, []) equals port_command(Port, Data).

If the port command is aborted, false is returned, otherwise true.

If the port is busy, the calling process is suspended until the port is not busy any more.

The following Options are valid:

Failures:

Sets the port owner (the connected port) to Pid. Roughly the same as Port ! {Owner, {connect, Pid}} except for the following:

The old port owner stays linked to the port and must call unlink(Port) if this is not desired. Any process can set the port owner to be any process with port_connect/2.

For comparison: Port ! {self(), {connect, Pid}} fails with badarg if Port cannot be sent to (that is, Port refers not to a port and not to a process). If Port is a closed port, nothing happens. If Port is an open port and the calling process is the port owner, the port replies with {Port, connected} to the old port owner. Notice that the old port owner is still linked to the port, while the new is not. If Port is an open port and the calling process is not the port owner, the port owner fails with badsig. The port owner fails with badsig also if Pid is not an existing local process identifier.

Notice that any process can set the port owner using Port ! {PortOwner, {connect, Pid}} as if it itself was the port owner, but the reply always goes to the port owner.

As from OTP-R16, Port ! {PortOwner, {connect, Pid}} is truly asynchronous. Notice that this operation has always been documented as an asynchronous operation, while the underlying implementation has been synchronous. port_connect/2 is however still fully synchronous. This because of its error behavior.

Failures:

Performs a synchronous control operation on a port. The meaning of Operation and Data depends on the port, that is, on the port driver. Not all port drivers support this control feature.

Returns a list of integers in the range 0..255, or a binary, depending on the port driver. The meaning of the returned data also depends on the port driver.

Failures:

Performs a synchronous call to a port. The meaning of Operation and Data depends on the port, that is, on the port driver. Not all port drivers support this feature.

Port is a port identifier, referring to a driver.

Operation is an integer, which is passed on to the driver.

Data is any Erlang term. This data is converted to binary term format and sent to the port.

Returns a term from the driver. The meaning of the returned data also depends on the port driver.

Failures:

Returns a list containing tuples with information about Port, or undefined if the port is not open. The order of the tuples is undefined, and all the tuples are not mandatory. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/1.

The result contains information about the following Items:

For more information about the different Items, see port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Pid is the process identifier of the process connected to the port.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Index is the internal index of the port. This index can be used to separate ports.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Bytes is the total number of bytes read from the port.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Pids is a list of the process identifiers of the processes that the port is linked to.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Locking is one of the following:

Notice that these results are highly implementation-specific and can change in a future release.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Bytes is the total number of bytes allocated for this port by the runtime system. The port itself can have allocated memory that is not included in Bytes.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Monitors represent processes that this port monitors.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Name is the command name set by open_port/2.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

OsPid is the process identifier (or equivalent) of an OS process created with open_port({spawn | spawn_executable, Command}, Options). If the port is not the result of spawning an OS process, the value is undefined.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Bytes is the total number of bytes written to the port from Erlang processes using port_command/2, port_command/3, or Port ! {Owner, {command, Data}.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent before this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Boolean corresponds to the port parallelism hint being used by this port. For more information, see option parallelism of open_port/2.

Bytes is the total number of bytes queued by the port using the ERTS driver queue implementation.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

RegisteredName is the registered name of the port. If the port has no registered name, [] is returned.

If the port identified by Port is not open, undefined is returned. If undefined is returned and the calling process was linked to a previously open port identified by Port, an exit signal is sent because this link was received by the process before the return from port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Returns a string corresponding to the text representation of the port identifier Port.

Returns a list of port identifiers corresponding to all the ports existing on the local node.

Notice that an exiting port exists, but is not open.

Returns a list of Erlang modules that are preloaded in the system. As all loading of code is done through the file system, the file system must have been loaded previously. Hence, at least the module init must be preloaded.

Writes information about the local process Pid on standard error. The only allowed value for the atom Type is backtrace, which shows the contents of the call stack, including information about the call chain, with the current function printed first. The format of the output is not further defined.

When trap_exit is set to true, exit signals arriving to a process are converted to {'EXIT', From, Reason} messages, which can be received as ordinary messages. If trap_exit is set to false, the process exits if it receives an exit signal other than normal and the exit signal is propagated to its linked processes. Application processes are normally not to trap exits.

Returns the old value of the flag.

See also exit/2.

Used by a process to redefine the error handler for undefined function calls and undefined registered processes. Inexperienced users are not to use this flag, as code auto-loading depends on the correct operation of the error handling module.

Returns the old value of the flag.

Changes the minimum heap size for the calling process.

Returns the old value of the flag.

Changes the minimum binary virtual heap size for the calling process.

Returns the old value of the flag.

N must be an integer in the interval 0..10000. If N is greater than 0, call saving is made active for the process. This means that information about the N most recent global function calls, BIF calls, sends, and receives made by the process are saved in a list, which can be retrieved with process_info(Pid, last_calls). A global function call is one in which the module of the function is explicitly mentioned. Only a fixed amount of information is saved, as follows:

If N = 0, call saving is disabled for the process, which is the default. Whenever the size of the call saving list is set, its contents are reset.

Returns the old value of the flag.

Sets or clears flag sensitive for the current process. When a process has been marked as sensitive by calling process_flag(sensitive, true), features in the runtime system that can be used for examining the data or inner working of the process are silently disabled.

Features that are disabled include (but are not limited to) the following:

process_info/1,2 cannot be used to read out the message queue or the process dictionary (both are returned as empty lists).

Stack back-traces cannot be displayed for the process.

In crash dumps, the stack, messages, and the process dictionary are omitted.

If {save_calls,N} has been set for the process, no function calls are saved to the call saving list. (The call saving list is not cleared. Furthermore, send, receive, and timeout events are still added to the list.)

Returns the old value of the flag.

Sets certain flags for the process Pid, in the same manner as process_flag/2. Returns the old value of the flag. The valid values for Flag are only a subset of those allowed in process_flag/2, namely save_calls.

Failure: badarg if Pid is not a local process.

Returns a list of process identifiers corresponding to all the processes currently existing on the local node.

Notice that an exiting process exists, but is not alive. That is, is_process_alive/1 returns false for an exiting process, but its process identifier is part of the result returned from processes/0.

Example:

> processes().
[<0.0.0>,<0.2.0>,<0.4.0>,<0.5.0>,<0.7.0>,<0.8.0>]

Removes old code for Module. Before this BIF is used, erlang:check_process_code/2 is to be called to check that no processes execute old code in the module.

Failure: badarg if there is no old code for Module.

Adds a new Key to the process dictionary, associated with the value Val, and returns undefined. If Key exists, the old value is deleted and replaced by Val, and the function returns the old value.

Example:

> X = put(name, walrus), Y = put(name, carpenter),
Z = get(name),
{X, Y, Z}.
{undefined,walrus,carpenter}

Read the state of a timer that has been created by either erlang:start_timer(), or erlang:send_after(). TimerRef identifies the timer, and was returned by the BIF that created the timer.

Currently available Options:

More Options may be added in the future.

When the Result equals false, a timer corresponding to TimerRef could not be found. This can be either because the timer had expired, had been canceled, or because TimerRef never has corresponded to a timer. If the timer has expired, the timeout message has been sent, but it does not tell you whether or not it has arrived at its destination yet. When the Result is an integer, it represents the time in milli-seconds left until the timer expires.

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

Read the state of a timer. The same as calling erlang:read_timer(TimerRef, []).

Returns a string corresponding to the text representation of Ref.

Associates the name RegName with a process identifier (pid) or a port identifier. RegName, which must be an atom, can be used instead of the pid or port identifier in send operator (RegName ! Message).

Example:

> register(db, Pid).
true

Failures:

Returns a list of names that have been registered using register/2, for example:

> registered().
[code_server, file_server, init, user, my_db]

Decreases the suspend count on the process identified by Suspendee. Suspendee is previously to have been suspended through erlang:suspend_process/2 or erlang:suspend_process/1 by the process calling erlang:resume_process(Suspendee). When the suspend count on Suspendee reaches zero, Suspendee is resumed, that is, its state is changed from suspended into the state it had before it was suspended.

Failures:

Returns an integer by rounding Number, for example:

round(5.5).
6

Allowed in guard tests.

Returns the process identifier of the calling process, for example:

> self().
<0.26.0>

Allowed in guard tests.

Starts a timer. When the timer expires, the message Msg will be sent to the process identified by Dest. Appart from the format of the message sent to Dest when the timer expires erlang:send_after/4 works exactly as erlang:start_timer/4.

Starts a timer. The same as calling erlang:send_after(Time, Dest, Msg, []).

Sets the magic cookie of Node to the atom Cookie. If Node is the local node, the function also sets the cookie of all other unknown nodes to Cookie (see Section Distributed Erlang in the Erlang Reference Manual in System Documentation).

Failure: function_clause if the local node is not alive.

Returns a tuple that is a copy of argument Tuple1 with the element given by integer argument Index (the first element is the element with index 1) replaced by argument Value, for example:

> setelement(2, {10, green, bottles}, red).
{10,red,bottles}

Returns an integer that is the size of argument Item, which must be a tuple or a binary, for example:

> size({morni, mulle, bwange}).
3

Allowed in guard tests.

Returns the process identifier of a new process started by the application of Fun to the empty list []. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Fun to the empty list [] on Node. If Node does not exist, a useless pid is returned. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Module:Function to Args. The new created process is placed in the system scheduler queue and will be run some time later.

error_handler:undefined_function(Module, Function, Args) is evaluated by the new process if Module:Function/Arity does not exist (where Arity is the length of Args). The error handler can be redefined (see process_flag/2). If error_handler is undefined, or the user has redefined the default error_handler, its replacement is undefined, and a failure with reason undef occurs.

Example:

> spawn(speed, regulator, [high_speed, thin_cut]).
<0.13.1>

Returns the process identifier (pid) of a new process started by the application of Module:Function to Args on Node. If Node does not exist, a useless pid is returned. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Fun to the empty list []. A link is created between the calling process and the new process, atomically. Otherwise works like spawn/3.

Returns the process identifier (pid) of a new process started by the application of Fun to the empty list [] on Node. A link is created between the calling process and the new process, atomically. If Node does not exist, a useless pid is returned (and, because of the link, an exit signal with exit reason noconnection is received). Otherwise works like spawn/3.

Returns the process identifier of a new process started by the applicatio of Module:Function to Args. A link is created between the calling process and the new process, atomically. Otherwise works like spawn/3.

Returns the process identifier (pid) of a new process started by the application of Module:Function to Args on Node. A link is created between the calling process and the new process, atomically. If Node does not exist, a useless pid is returned (and, because of the link, an exit signal with exit reason noconnection is received). Otherwise works like spawn/3.

Returns the process identifier of a new process, started by the application of Fun to the empty list [], and a reference for a monitor created to the new process. Otherwise works like spawn/3.

A new process is started by the application of Module:Function to Args. The process is monitored at the same time. Returns the process identifier and a reference for the monitor. Otherwise works like spawn/3.

Returns a tuple containing the binaries that are the result of splitting Bin into two parts at position Pos. This is not a destructive operation. After the operation, there are three binaries altogether.

Example:

> B = list_to_binary("0123456789").
<<"0123456789">>
> byte_size(B).
10
> {B1, B2} = split_binary(B,3).
{<<"012">>,<<"3456789">>}
> byte_size(B1).
3
> byte_size(B2).
7

Starts a timer. When the timer expires, the message {timeout, TimerRef, Msg} will be sent to the process identified by Dest.

Currently available Options:

More Options may be added in the future.

The absolute point in time that the timer is set to expire on has to be in the interval [erlang:system_info(start_time), erlang:system_info(end_time)]. Further, if a relative time is specified, the Time value is not allowed to be negative.

If Dest is a pid(), it must be a pid() of a process created on the current runtime system instance. This process may or may not have terminated. If Dest is an atom(), it will be interpreted as the name of a locally registered process. The process referred to by the name is looked up at the time of timer expiration. No error is given if the name does not refer to a process.

If Dest is a pid(), the timer is automatically canceled if the process referred to by the pid() is not alive, or when the process exits. This feature was introduced in ERTS version 5.4.11. Notice that timers are not automatically canceled when Dest is an atom().

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

Failure: badarg if the arguments do not satisfy the requirements specified here.

Starts a timer. The same as calling erlang:start_timer(Time, Dest, Msg, []).

Returns the total number of context switches since the system started.

Returns the number of exact reductions.

Returns information about garbage collection, for example:

> statistics(garbage_collection).
{85,23961,0}

This information can be invalid for some implementations.

Returns Input, which is the total number of bytes received through ports, and Output, which is the total number of bytes output to ports.

Returns information about reductions, for example:

> statistics(reductions).
{2046,11}

Returns the total length of run-queues, that is, the number of processes that are ready to run on all available run-queues.

Returns information about runtime, in milliseconds.

The runtime is the sum of the runtime for all threads in the Erlang runtime system and can therefore be greater than the wall clock time.

Example:

> statistics(runtime).
{1690,1620}

Returns a list of tuples with {SchedulerId, ActiveTime, TotalTime}, where SchedulerId is an integer ID of the scheduler, ActiveTime is the duration the scheduler has been busy, and TotalTime is the total time duration since scheduler_wall_time activation. The time unit is undefined and can be subject to change between releases, OSs, and system restarts. scheduler_wall_time is only to be used to calculate relative values for scheduler-use. ActiveTime can never exceed TotalTime.

The definition of a busy scheduler is when it is not idle and is not scheduling (selecting) a process or port, that is:

Notice that a scheduler can also be busy even if the OS has scheduled out the scheduler thread.

Returns undefined if system flag scheduler_wall_time is turned off.

The list of scheduler information is unsorted and can appear in different order between calls.

Using scheduler_wall_time to calculate scheduler-use:

> erlang:system_flag(scheduler_wall_time, true).
false
> Ts0 = lists:sort(erlang:statistics(scheduler_wall_time)), ok.
ok

Some time later the user takes another snapshot and calculates scheduler-use per scheduler, for example:

> Ts1 = lists:sort(erlang:statistics(scheduler_wall_time)), ok.
ok
> lists:map(fun({{I, A0, T0}, {I, A1, T1}}) ->
	{I, (A1 - A0)/(T1 - T0)} end, lists:zip(Ts0,Ts1)).
[{1,0.9743474730177548},
 {2,0.9744843782751444},
 {3,0.9995902361669045},
 {4,0.9738012596572161},
 {5,0.9717956667018103},
 {6,0.9739235846420741},
 {7,0.973237033077876},
 {8,0.9741297293248656}]

Using the same snapshots to calculate a total scheduler-use:

> {A, T} = lists:foldl(fun({{_, A0, T0}, {_, A1, T1}}, {Ai,Ti}) ->
	{Ai + (A1 - A0), Ti + (T1 - T0)} end, {0, 0}, lists:zip(Ts0,Ts1)), A/T.
0.9769136803764825

Returns information about wall clock. wall_clock can be used in the same manner as runtime, except that real time is measured as opposed to runtime or CPU time.

Increases the suspend count on the process identified by Suspendee and puts it in the suspended state if it is not already in that state. A suspended process will not be scheduled for execution until the process has been resumed.

A process can be suspended by multiple processes and can be suspended multiple times by a single process. A suspended process does not leave the suspended state until its suspend count reaches zero. The suspend count of Suspendee is decreased when erlang:resume_process(Suspendee) is called by the same process that called erlang:suspend_process(Suspendee). All increased suspend counts on other processes acquired by a process are automatically decreased when the process terminates.

The options (Opts) are as follows:

If the suspend count on the process identified by Suspendee is increased, true is returned, otherwise false.

Failures:

Suspends the process identified by Suspendee. The same as calling erlang:suspend_process(Suspendee, []). For more information, see erlang:suspend_process/2.

Sets the maximum depth of call stack back-traces in the exit reason element of 'EXIT' tuples.

Returns the old value of the flag.

Sets the number of dirty CPU schedulers online. Range is , where N is the smallest of the return values of erlang:system_info(dirty_cpu_schedulers) and erlang:system_info(schedulers_online).

Returns the old value of the flag.

The number of dirty CPU schedulers online can change if the number of schedulers online changes. For example, if 12 schedulers and 6 dirty CPU schedulers are online, and system_flag/2 is used to set the number of schedulers online to 6, then the number of dirty CPU schedulers online is automatically decreased by half as well, down to 3. Similarly, the number of dirty CPU schedulers online increases proportionally to increases in the number of schedulers online.

For more information, see erlang:system_info(dirty_cpu_schedulers) and erlang:system_info(dirty_cpu_schedulers_online).

Sets system flag fullsweep_after. Number is a non-negative integer indicating how many times generational garbage collections can be done without forcing a fullsweep collection. The value applies to new processes, while processes already running are not affected.

Returns the old value of the flag.

In low-memory systems (especially without virtual memory), setting the value to 0 can help to conserve memory.

This value can also be set through (OS) environment variable ERL_FULLSWEEP_AFTER.

Sets the default minimum heap size for processes. The size is given in words. The new min_heap_size effects only processes spawned after the change of min_heap_size has been made. min_heap_size can be set for individual processes by using spawn_opt/N or process_flag/2.

Returns the old value of the flag.

Sets the default minimum binary virtual heap size for processes. The size is given in words. The new min_bin_vhheap_size effects only processes spawned after the change of min_bin_vhheap_size has been made. min_bin_vheap_size can be set for individual processes by using spawn_opt/N or process_flag/2.

Returns the old value of the flag.

If multi-scheduling is enabled, more than one scheduler thread is used by the emulator. Multi-scheduling can be blocked. When multi-scheduling is blocked, only one scheduler thread schedules Erlang processes.

If BlockState =:= block, multi-scheduling is blocked. If BlockState =:= unblock and no one else blocks multi-scheduling, and this process has blocked only once, multi-scheduling is unblocked.

One process can block multi-scheduling multiple times. If a process has blocked multiple times, it must unblock exactly as many times as it has blocked before it has released its multi-scheduling block. If a process that has blocked multi-scheduling exits, it releases its blocking of multi-scheduling.

The return values are disabled, blocked, or enabled. The returned value describes the state just after the call to erlang:system_flag(multi_scheduling, BlockState) has been made. For information about the return values, see erlang:system_info(multi_scheduling).

See also erlang:system_info(multi_scheduling), erlang:system_info(multi_scheduling_blockers), and erlang:system_info(schedulers).

Turns on or off scheduler wall time measurements.

For more information, see erlang:statistics(scheduler_wall_time).

Sets the number of schedulers online. Range is .

Returns the old value of the flag.

The emulator was built with support for dirty schedulers. Changing the number of schedulers online can also change the number of dirty CPU schedulers online. For example, if 12 schedulers and 6 dirty CPU schedulers are online, and system_flag/2 is used to set the number of schedulers online to 6, then the number of dirty CPU schedulers online is automatically decreased by half as well, down to 3. Similarly, the number of dirty CPU schedulers online increases proportionally to increases in the number of schedulers online.

For more information, see erlang:system_info(schedulers) and erlang:system_info(schedulers_online).

Sets the value of the node trace control word to TCW, which is to be an unsigned integer. For more information, see the function set_tcw in Section "Match Specifications in Erlang" in the User's Guide.

Returns the old value of the flag.

Finalizes the time offset when the single time warp mode is being used. If another time warp mode than the "single time warp mode" is used, the time offset state will be left unchanged.

Returns the old state identifier. That is, if:

Returns current Erlang system time in native time unit.

Calling erlang:system_time() is equivalent to: erlang:monotonic_time() + erlang:time_offset().

Returns current Erlang system time converted into the Unit passed as argument.

Calling erlang:system_time(Unit) is equivalent to: erlang:convert_time_unit(erlang:system_time(), native, Unit).

Returns a binary data object that is the result of encoding Term according to the Erlang external term format.

This can be used for various purposes, for example, writing a term to a file in an efficient way, or sending an Erlang term to some type of communications channel not supported by distributed Erlang.

See also binary_to_term/1.

Returns a binary data object that is the result of encoding Term according to the Erlang external term format.

If option compressed is provided, the external term format is compressed. The compressed format is automatically recognized by binary_to_term/1 as from Erlang R7B.

A compression level can be specified by giving option {compressed, Level}. Level is an integer with range 0..9, where:

compressed and {compressed, 6} give the same result.

Option {minor_version, Version} can be used to control some encoding details. This option was introduced in OTP R11B-4. The valid values for Version are 0 and 1.

As from OTP 17.0, {minor_version, 1} is the default. It forces any floats in the term to be encoded in a more space-efficient and exact way (namely in the 64-bit IEEE format, rather than converted to a textual representation).

As from OTP R11B-4, binary_to_term/1 can decode this representation.

{minor_version, 0} means that floats are encoded using a textual representation. This option is useful to ensure that releases before OTP R11B-4 can decode resulting binary.

See also binary_to_term/1.

A non-local return from a function. If evaluated within a catch, catch returns value Any.

Example:

> catch throw({hello, there}).
{hello,there}

Failure: nocatch if not evaluated within a catch.

Returns the current time as {Hour, Minute, Second}.

The time zone and Daylight Saving Time correction depend on the underlying OS.

Example:

> time().
{9,42,44}

Returns the current time offset between Erlang monotonic time and Erlang system time in native time unit. Current time offset added to an Erlang monotonic time gives corresponding Erlang system time.

The time offset may or may not change during operation depending on the time warp mode used.

Returns the current time offset between Erlang monotonic time and Erlang system time converted into the Unit passed as argument.

Same as calling erlang:convert_time_unit(erlang:time_offset(), native, Unit) however optimized for commonly used Units.

Returns the tail of List, that is, the list minus the first element, for example:

> tl([geesties, guilies, beasties]).
[guilies, beasties]

Allowed in guard tests.

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

The delivery of trace messages is dislocated on the time-line compared to other events in the system. If you know that Tracee has passed some specific point in its execution, and you want to know when at least all trace messages corresponding to events up to this point have reached the tracer, use erlang:trace_delivered(Tracee). A {trace_delivered, Tracee, Ref} message is sent to the caller of erlang:trace_delivered(Tracee) when it is guaranteed that all trace messages are delivered to the tracer up to the point that Tracee reached at the time of the call to erlang:trace_delivered(Tracee).

Notice that message trace_delivered does not imply that trace messages have been delivered. Instead it implies that all trace messages that are to be delivered have been delivered. It is not an error if Tracee is not, and has not been traced by someone, but if this is the case, no trace messages have been delivered when the trace_delivered message arrives.

Notice that that Tracee must refer to a process currently, or previously existing on the same node as the caller of erlang:trace_delivered(Tracee) resides on. The special Tracee atom all denotes all processes that currently are traced in the node.

Example: Process A is Tracee, port B is tracer, and process C is the port owner of B. C wants to close B when A exits. C can ensure that the trace is not truncated by calling erlang:trace_delivered(A) when A exits and waits for message {trace_delivered, A, Ref} before closing B.

Failure: badarg if Tracee does not refer to a process (dead or alive) on the same node as the caller of erlang:trace_delivered(Tracee) resides on.

Returns an integer by truncating Number, for example:

> trunc(5.5).
5

Allowed in guard tests.

Returns an integer that is the number of elements in Tuple, for example:

> tuple_size({morni, mulle, bwange}).
3

Allowed in guard tests.

Returns a list corresponding to Tuple. Tuple can contain any Erlang terms.

Example:

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

Returns the current date and time according to Universal Time Coordinated (UTC) in the form {{Year, Month, Day}, {Hour, Minute, Second}} if supported by the underlying OS. Otherwise erlang:universaltime() is equivalent to erlang:localtime().

Example:

> erlang:universaltime().
{{1996,11,6},{14,18,43}}

Converts Universal Time Coordinated (UTC) date and time to local date and time in the form {{Year, Month, Day}, {Hour, Minute, Second}} if supported by the underlying OS. Otherwise no conversion is done, and Universaltime is returned.

Example:

> erlang:universaltime_to_localtime({{1996,11,6},{14,18,43}}).
{{1996,11,7},{15,18,43}}

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

Generates and returns an integer unique on current runtime system instance. The same as calling erlang:unique_integer([]).

Generates and returns an integer unique on current runtime system instance. The integer is unique in the sense that this BIF, using the same set of modifiers, will not return the same integer more than once on the current runtime system instance. Each integer value can of course be constructed by other means.

By default, i.e. when [] is passed as ModifierList, both negative and positive integers will be returned. This is order to be able to utilize the range of integers that do not need to be heap allocated as much as possible. By default the returned integers are also only guaranteed to be unique, i.e., any integer returned may be either smaller, or larger than previously returned integers.

Currently valid Modifiers:

All currently valid Modifiers can be combined. Repeated (valid) Modifiers in the ModifierList are ignored.

Failures:

Removes the link, if there is one, between the calling process and the process or port referred to by Id.

Returns true and does not fail, even if there is no link to Id, or if Id does not exist.

Once unlink(Id) has returned, it is guaranteed that the link between the caller and the entity referred to by Id has no effect on the caller in the future (unless the link is setup again). If the caller is trapping exits, an {'EXIT', Id, _} message is received, as the link can have been placed in the caller's message queue before the call.

Notice that the {'EXIT', Id, _} message can be the result of the link, but can also be the result of Id calling exit/2. Therefore, it can be appropriate to clean up the message queue when trapping exits after the call to unlink(Id), as follows:

Removes the registered name RegName associated with a process identifier or a port identifier, for example:

> unregister(db).
true

Users are advised not to unregister system processes.

Failure: badarg if RegName is not a registered name.

Returns the process identifier or port identifier with the registered name RegName. Returns undefined if the name is not registered.

Example:

> whereis(db).
<0.43.0>

Voluntarily lets other processes (if any) get a chance to execute. Using erlang:yield() is similar to receive after 1 -> ok end, except that yield() is faster.