**BIFs (Built-In Functions)** are functions implemented in C inside the BEAM, exposed in Erlang. Combined with the standard library modules (`lists`, `maps`, `string`, `io`, etc.), they cover most everyday tasks. ## Common BIFs (in erlang module, no module prefix needed) ```erlang length([1, 2, 3]) %% 3 hd([1, 2, 3]) %% 1 — head tl([1, 2, 3]) %% [2, 3] — tail element(2, {a, b, c}) %% b — 1-indexed! setelement(2, {a, b, c}, x) %% {a, x, c} tuple_size({a, b, c}) %% 3 is_atom(foo) %% true is_list([1, 2]) %% true is_integer(42) %% true self() %% your PID spawn(Fun) %% start a process ``` All callable without `erlang:` prefix because they're auto-imported. ## Conversion BIFs ```erlang integer_to_list(42) %% "42" list_to_integer("42") %% 42 atom_to_list(hello) %% "hello" list_to_atom("hello") %% hello (CAREFUL — atoms aren't GC'd) binary_to_list(<<"hello">>) %% "hello" list_to_binary("hello") %% <<"hello">> float_to_list(3.14) %% "3.14000000000000012434e+00" float_to_list(3.14, [{decimals, 2}]) %% "3.14" ``` Erlang's string handling has quirks — strings are lists of integers. Modern Erlang prefers binaries (`<<"...">>`) for text. ## The lists module — your daily companion ```erlang lists:append([[1,2], [3,4]]) %% [1,2,3,4] lists:concat(["a", "b", "c"]) %% "abc" lists:reverse([1,2,3]) %% [3,2,1] lists:sort([3,1,2]) %% [1,2,3] lists:sort(fun(A,B) -> A > B end, [1,2,3]) %% custom sort lists:member(2, [1,2,3]) %% true lists:nth(2, [a,b,c]) %% b — 1-indexed lists:zip([1,2,3], [a,b,c]) %% [{1,a},{2,b},{3,c}] lists:unzip([{1,a},{2,b}]) %% {[1,2],[a,b]} lists:flatten([[1],[2,[3]]]) %% [1,2,3] lists:max([3,1,2]) %% 3 lists:min([3,1,2]) %% 1 lists:sum([1,2,3]) %% 6 lists:any(fun(X) -> X > 2 end, [1,2,3]) %% true lists:all(fun(X) -> X > 0 end, [1,2,3]) %% true ``` Learn these — they replace 90% of hand-written list code. ## The string module ```erlang string:trim(" hello ") %% "hello" string:tokens("a,b,c", ",") %% ["a","b","c"] string:join(["a","b","c"], "-") %% "a-b-c" string:to_upper("hello") %% "HELLO" string:to_lower("HELLO") %% "hello" string:length("hello") %% 5 string:replace("hello world", " ", "_") %% ["hello_world"] ``` Note: Erlang strings are LISTS OF INTEGERS. For real text processing, prefer the `unicode` module or binary strings (`<<"...">>`). ## Common mistakes - **1-indexed access** — element/2, lists:nth/2 are 1-indexed (not 0-indexed). Common bug source. - **String confusion** — "hello" is `[104, 101, 108, 108, 111]` (a list of code points). Different from `<<"hello">>` (binary). Pick one and stick to it. - **list_to_atom on user input** — atoms aren't garbage-collected. Untrusted input can DoS the VM by exhausting the atom table. - **Forgetting BIFs vs library functions** — BIFs are auto-imported; library functions need module prefix. lists:sum is library; length is BIF. - **Mixing strings and binaries** — converts often confuse newcomers. Decide on representation early.

Erlang Intermediate

Curriculum