{"id":519,"date":"2011-04-13T08:49:55","date_gmt":"2011-04-13T07:49:55","guid":{"rendered":"http:\/\/trigonakis.com\/blog\/?p=519"},"modified":"2011-04-19T15:48:02","modified_gmt":"2011-04-19T14:48:02","slug":"introduction-to-erlang-bifs-predefined-modules","status":"publish","type":"post","link":"http:\/\/trigonakis.com\/blog\/2011\/04\/13\/introduction-to-erlang-bifs-predefined-modules\/","title":{"rendered":"Introduction to Erlang : BIFs & Predefined Modules"},"content":{"rendered":"
This entry is part 11 of 16 in the series Introduction to Erlang<\/a><\/div>

Built-in Functions (BIFs)<\/h3>\n

Erlang’s Built-in Functions<\/strong> (shorthand BIF<\/strong>s) are commonly used functions that are intergrated into the Erlang’s VM<\/acronym> for performance reasons. Most of them belong to the erlang<\/code> module, but there are some in other modules, such as lists<\/code>.<\/p>\n

The BIFs can be separated to standard<\/i> and non-standard<\/i>. The standard ones are auto-imported; they can be called without the use of the module name prefix (remember the effect of the -import(...)<\/code> directive). On the other hand, the non-standard ones have to be called following the normal module:function(...)<\/code> convension. In the erlang<\/code> module’s man pages (here<\/a>) the distinction between standard and non-standard is visible by the lack or existence of the erlang<\/code> (module’s name) prefix.<\/p>\n

elrang<\/h4>\n
abs\/1<\/h5>\n

Arithmetic absolut value of an integer or float.<\/p>\n

erlang:append_element\/2<\/h5>\n

Appends an element to a tuple.<\/p>\n

apply\/2|3<\/h5>\n

Calls the function passed as a parameter.<\/p>\n

atom_to_list\/1<\/h5>\n

Returns a string which corresponds to the text representation of Atom.
\n<\/p>\n

date\/0<\/h5>\n

Returns the date in the {Year, Month, Day}<\/code> format.<\/p>\n

element\/2<\/h5>\n

Called as element(N, Tuple)<\/code>. Returns the N<\/code>th of the Tuple<\/code>.<\/p>\n

error\/1|2<\/h5>\n

Stops the execution with an error Reason.<\/p>\n

exit\/1|2<\/h5>\n

Stops the execution with an exit Reason.<\/p>\n

float\/1<\/h5>\n

Converts the number to float.<\/p>\n

float_to_list\/1<\/h5>\n

Returns a string which corresponds to the text representation of Float.<\/p>\n

hd\/1<\/h5>\n

Returns the head of a list (the first element).<\/p>\n

integer_to_list\/1|2<\/h5>\n

Returns a string which corresponds to the text representation of Integer.<\/p>\n

is_atom\/1<\/h5>\n

Returns true if Term is an atom; otherwise returns false.<\/p>\n

is_boolean\/1<\/h5>\n

Returns true if Term is either the atom true or the atom false (i.e. a boolean); otherwise returns false.<\/p>\n

is_float\/1<\/h5>\n

Returns true if Term is a floating point number; otherwise returns false.<\/p>\n

is_integer\/1<\/h5>\n

Returns true if Term is an integer; otherwise returns false.<\/p>\n

is_list\/1<\/h5>\n

Returns true if Term is a list with zero or more elements; otherwise returns false.<\/p>\n

is_number\/1<\/h5>\n

Returns true if Term is either an integer or a floating point number; otherwise returns false.<\/p>\n

is_tuple\/1<\/h5>\n

Returns true if Term is a tuple; otherwise returns false.<\/p>\n

length\/1<\/h5>\n

Returns the length of a list.<\/p>\n

list_to_atom\/1<\/h5>\n

Returns the atom whose text representation is String.<\/p>\n

list_to_existing_atom\/1<\/h5>\n

Returns the atom whose text representation is String, but only if there already exists such atom.<\/p>\n

Failure: badarg if there does not already exist an atom whose text representation is String.<\/p>\n

\r\n2> erlang:loaded().\r\n[otp_internal,lib,shell_default,erl_internal,edlin_expand,\r\n sets,ordsets,erl_lint,unicode,io,erl_scan,erl_parse,epp,\r\n filelib,ram_file,beam_lib,file_io_server,orddict,erl_eval,\r\n file,c,error_logger_tty_h,kernel_config,shell,io_lib_format,\r\n proplists,io_lib,edlin,group|...]\r\n3> list_to_existing_atom(\"lib\").\r\nlib\r\n4> list_to_existing_atom(\"lib11\").\r\n** exception error: bad argument\r\n     in function  list_to_existing_atom\/1\r\n        called as list_to_existing_atom(\"lib11\")\r\n<\/pre>\n
list_to_float\/1<\/h5>\n
Returns the float whose text representation is String.<\/p>\n
list_to_integer\/1|2<\/h5>\n
Returns an integer whose text representation is String.<\/p>\n
list_to_tuple\/1<\/h5>\n
Returns a tuple which corresponds to List. List can contain any Erlang terms.<\/p>\n
erlang:loaded\/0<\/h5>\n
Returns a list of all loaded Erlang modules.<\/p>\n
erlang:localtime\/0<\/h5>\n
Returns the current local time and date in the format {{Year, Month, Date}, {Hour, Minute, Second}}<\/code>.<\/p>\n
max\/2<\/h5>\n
Returns the maximum between two terms, or the first one if equal.<\/p>\n
min\/2<\/h5>\n
Returns the minimum between two terms, or the first one if equal.<\/p>\n
now\/0<\/h5>\n
Returns the tuple {MegaSecs, Secs, MicroSecs}<\/code> which is the elapsed time since 00:00 GMT, January 1, 1970 (zero hour).<\/p>\n
round\/1<\/h5>\n
Returns the integer resulting by rounding the input.<\/p>\n
self\/0<\/h5>\n
Return the process identifier (Pid) of the current process. This function will be used extensively in the next post and what is a Pid will be explained in more detail.<\/p>\n
erlang:send\/2<\/h5>\n
Called as erlang:send(Dest, Msg)<\/code>. Sends message Msg<\/code> to Dest<\/code>. This is equivalent with Dest ! Msg<\/code>. We will see the details of message passing in an upcoming post.<\/p>\n
setelement\/3<\/h5>\n
Returns a new tuple where the value of the specified element is set to the one provided.<\/p>\n
size\/1<\/h5>\n
Returns the size of the provided tuple or binary.<\/p>\n
spawn\/1|2|3|4<\/h5>\n
Creates a new process and returns its Pid. It is one of the most important and used functions in Erlang. There will be a dedicated post about processes.<\/p>\n
throw\/1<\/h5>\n
A non-local return from a function. If evaluated within a catch, catch will return the value Any (called as throw(Any)<\/code>).<\/p>\n
\r\n7> throw(my_exception).\r\n** exception throw: my_exception\r\n8> catch throw(my_exception).\r\nmy_exception\r\n<\/pre>\n
time\/0<\/h5>\n
Returns the local time in {Hours, Minutes, Seconds}<\/code> format.<\/p>\n
tl\/1\/<\/h5>\n
Returns the tail of a list (the list without its head element).<\/p>\n
trunc\/1<\/h5>\n
Returns an integer by truncating the provided number.<\/p>\n
tuple_size\/1<\/h5>\n
Returns the size of the provided tuple.<\/p>\n
tuple_to_list\/1<\/h5>\n
Returns a list which corresponds to Tuple. Tuple may contain any Erlang terms.<\/p>\n
Preexisting Modules<\/h3>\n
Erlang comes with tons of predefined general purpose or specialized modules. In the majority of the cases, if Erlang provides a function with the functionality you need, you would prefer to use it instead of reimplementing it for three main reasons: (1) why reinventing the wheel, (2) performance, (3) difficult to program.<\/p>\n
I will present some of the modules that I consider the most important\/useful. A full list of the existing Erlang’s (Erlang\/OTP to be precise) modules can be found here<\/a>.<\/p>\n
debugger<\/h4>\n
This is the module used to start the Erlang debugger for debugging and testing Erlang programs. Details here<\/a>. There will be a post about debugging in the future, so do not worry for now.<\/p>\n
start\/0|1|2<\/h5>\n
Starts the debugger.<\/p>\n
file<\/h4>\n
Functions used to read and manipulate files. Details here<\/a>.<\/p>\n
open\/2<\/h5>\n
Opens a file.<\/p>\n
close\/1<\/h5>\n
Closes an opened file.<\/p>\n
read\/2, read_file\/1, read_line\/1, pread\/2|3<\/h5>\n
Reading from a file.<\/p>\n
write\/2, write_file\/2|3, pwrite\/2|3<\/h5>\n
Writing to a file.<\/p>\n
position\/2<\/h5>\n
Moves the current pointer in a file.<\/p>\n
rename\/2<\/h5>\n
Renames a file.<\/p>\n
copy\/2|3<\/h5>\n
Copies the contents of a file to another.<\/p>\n
list_dir\/1, make_dir\/1, delete_dir\/1<\/h5>\n
List, create, and delete directories.<\/p>\n
io<\/h4>\n
Functions related to input\/output. Details here<\/a>.<\/p>\n
format\/1|2|3<\/h5>\n
Write formatted output to the standard output. (similar to printf<\/code> in C)<\/p>\n
\r\n11> io:format(\"Hello World~n\").        \r\nHello World\r\nok\r\n<\/pre>\n
read\/1|2, read_line\/1|2, get_chars\/2|3<\/h5>\n
Reads a term, a line, or a number of chars from the standard input.<\/p>\n
lists<\/h4>\n
Functions related to lists. Details here<\/a>. The next post will be focusing on lists and the lists<\/code> module, so I do not present them here.<\/p>\n
math<\/h4>\n
Mathematical functions (sin\/1, cos\/1, tan\/1, exp\/1, log\/1, pow\/2, sqrt\/1<\/code>, etc). Details here<\/a>.<\/p>\n
pman<\/h4>\n
A graphical process manager tool used to inspect the Erlang processes executing either locally or on remote nodes. It is also possible to trace events in the individual processes. Details here<\/a>. We will use this module in the post about debugging.<\/p>\n
start\/0|1<\/h5>\n
Starts the process manager.<\/p>\n
proc\/1|3<\/h5>\n
Starts a process manager for a specific process.<\/p>\n
string<\/h4>\n
Functions related to strings. Details here<\/a>.<\/p>\n
len\/1<\/h5>\n
Returns the number of characters of a string.<\/p>\n
equal\/2<\/h5>\n
Test two strings for equality.<\/p>\n
concat\/2<\/h5>\n
Concatenates two strings and returns the results.<\/p>\n
str\/2, rstr\/2<\/h5>\n
Returns the position where the first\/last occurrence of a substring begins in a string. 0 is returned if substring does not exist in the string.<\/p>\n
substr\/2|3<\/h5>\n
Returns the substring of a string.<\/p>\n
to_lower\/1, to_upper\/1<\/h5>\n
Case convertion.<\/p>\n
timer<\/h4>\n
This module provides useful functions related to time. Details here<\/a>.<\/p>\n
apply_after\/4<\/h5>\n
Apply a function after a given time.<\/p>\n
send_after\/2|3<\/h5>\n
Send a message to a process after a given time.<\/p>\n
tc\/2|3<\/h5>\n
Returns {Time, Value}<\/code>, where Time<\/code> is the microseconds that the execution took and Value<\/code> is the result of the applied function.<\/p>\n
\r\n14> timer:tc(erlang, length, [[1, 2, 3, 4, 5, 6, 7]]).\r\n{6,7} %r esult 7 in 6 microseconds\r\n<\/pre>\n
now_diff\/2<\/h5>\n
Returns the difference between two different “now values” (got by calling now()<\/code>) in microseconds.<\/p>\n
\r\n15> Now_old = now().\r\n{1302,680891,260499}\r\n16> Now_new = now().\r\n{1302,680895,780496}\r\n17> timer:now_diff(Now_new, Now_old).\r\n4519997\r\n<\/pre>\n
Next<\/h3>\n
The next post will be dedicated to lists and the lists module<\/strong>. <\/p>\n","protected":false},"excerpt":{"rendered":"
This entry is part 11 of 16 in the series Introduction to Erlang<\/a><\/div>
Built-in Functions (BIFs) Erlang’s Built-in Functions (shorthand BIFs) are commonly used functions that are intergrated into the Erlang’s VM for performance reasons. Most of them belong to the erlang module, but there are some in other modules, such as lists. The BIFs can be separated to standard and non-standard. The standard ones are auto-imported; they […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false}}},"categories":[40,51,28],"tags":[26,55,42],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p1ouW6-8n","_links":{"self":[{"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/posts\/519"}],"collection":[{"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/comments?post=519"}],"version-history":[{"count":17,"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/posts\/519\/revisions"}],"predecessor-version":[{"id":549,"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/posts\/519\/revisions\/549"}],"wp:attachment":[{"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/media?parent=519"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/categories?post=519"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/trigonakis.com\/blog\/wp-json\/wp\/v2\/tags?post=519"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}