Erlang/OTP

https://www.erlang.org/doc/
Admin
Erlang/OTP is a complete development environment for concurrent programming, providing the Erlang...
Tokens:3,202,553
Snippets:42,376
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### demo/0

Source: https://www.erlang.org/doc/apps/wx/wx.md

Starts the Wx demo if the examples directory exists and is compiled.

```APIDOC
## demo()

### Description
Starts a Wx demo if examples directory exists and is compiled.

### Signature
-spec demo() -> ok | {error, atom()}
```

--------------------------------

### Start a slim release with excl_lib

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Example command to start a release when using the experimental excl_lib option, requiring specific SASL and boot configurations.

```text
erl -sasl releases_dir "mytarget/releases" -boot mytarget/releases/1.0/myrel\
 -boot_var RELTOOL_EXT_LIB mytarget/lib
```

--------------------------------

### Starting the Trace Example

Source: https://www.erlang.org/doc/apps/kernel/seq_trace.md

Function to initialize the processes and start the trace test.

```erlang
test() ->
    P = spawn(?MODULE, loop, [port]),
    register(call_server, spawn(?MODULE, loop, [])),
    start(),
    P ! {port,message}.
```

--------------------------------

### Start Wx demo

Source: https://www.erlang.org/doc/apps/wx/wx.md

Launches the Wx demo application if the examples directory is present and compiled.

```erlang
-spec demo() -> ok | {error, atom()}.
```

--------------------------------

### Example: Start Tracing with Wrap Logs

Source: https://www.erlang.org/doc/apps/observer/ttb_ug.md

Demonstrates how to start tracing on a node and configure it to write logs to a set of wrap files. This is typically the first step before formatting.

```erlang
(tiger@durin)1> ttb:tracer(node(),{file,{wrap,"trace"}}).
{ok,[tiger@durin]}
(tiger@durin)2> ttb:p(...)
...
```

--------------------------------

### Start a slave node with custom arguments

Source: https://www.erlang.org/doc/apps/stdlib/slave.md

Example of constructing arguments and starting a slave node with specific configuration.

```erlang
E = " -env DISPLAY " ++ net_adm:localhost() ++ ":0 ",
Arg = "-mnesia_dir " ++ M ++ " -pa " ++ Dir ++ E,
slave:start(H, Name, Arg).
```

--------------------------------

### start()

Source: https://www.erlang.org/doc/apps/eunit/eunit.md

Starts the EUnit server. This is typically handled automatically.

```APIDOC
## start()

### Description
Starts the EUnit server. Normally, you don't need to call this function; it is started automatically.

### Signature
-spec start() -> term()
```

--------------------------------

### Erlang Example Usage

Source: https://www.erlang.org/doc/system/c_portdriver.md

Steps to start Erlang, compile Erlang code, and interact with the loaded C driver.

```erlang
> erl
Erlang/OTP 26 [erts-14.2] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [jit:ns]

Eshell V14.2 (press Ctrl+G to abort, type help(). for help)
1> c(complex5).
{ok,complex5}
2> complex5:start("example_drv").
<0.34.0>
3> complex5:foo(3).
4
4> complex5:bar(5).
10
5> complex5:stop().
stop
```

--------------------------------

### Start Erlang/OTP with a Boot Script

Source: https://www.erlang.org/doc/system/release_structure.md

Demonstrates how to start an Erlang system using a generated boot script. All applications defined in the release are automatically loaded and started.

```bash
% erl -boot ch_rel-1
```

--------------------------------

### Start pseudo servers via RPC

Source: https://www.erlang.org/doc/apps/stdlib/slave.md

Example of starting a pseudo server named pxw_server on a slave node N.

```erlang
rpc:call(N, slave, pseudo, [node(), [pxw_server]]).
```

--------------------------------

### Starting Application and Getting Environment Variable

Source: https://www.erlang.org/doc/system/applications.md

Demonstrates starting an application and retrieving an environment variable using application:get_env/2.

```erlang
% erl
Erlang (BEAM) emulator version 5.2.3.6 [hipe] [threads:0]

Eshell V5.2.3.6  (abort with ^G)
1> application:start(ch_app).
ok
2> application:get_env(ch_app, file).
{ok,"/usr/local/log"}

```

--------------------------------

### Install using the Release Target

Source: https://www.erlang.org/doc/system/install.md

Creates a custom installation directory and manually runs the Install script.

```bash
$ ./configure
$ make
$ make RELEASE_ROOT=/home/me/OTP release
$ cd /home/me/OTP
$ ./Install -minimal /home/me/OTP
$ mkdir -p /home/me/bin
$ cd /home/me/bin
$ ln -s /home/me/OTP/bin/erl erl
$ ln -s /home/me/OTP/bin/erlc erlc
$ ln -s /home/me/OTP/bin/escript escript
...
```

```bash
$ ./Install [-cross] [-minimal|-sasl] <ERL_ROOT>
```

--------------------------------

### Get indentation guides status

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Returns the visibility status of indentation guides as a ?wxSTC_IV_* constant.

```erlang
-spec getIndentationGuides(This) -> integer() when This :: wxStyledTextCtrl().
```

--------------------------------

### Erlang Node Startup Example (kosken)

Source: https://www.erlang.org/doc/system/conc_prog.md

Example of starting an Erlang node named 'ping' on the 'kosken' machine. This demonstrates the command-line interface for initiating a distributed Erlang node.

```text
kosken$ erl -sname ping
Erlang/OTP 28 [erts-16.3] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit:ns]

Eshell V16.3 (press Ctrl+G to abort, type help(). for help)
(ping@kosken)1>
```

--------------------------------

### getTargetStart

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Get the position that starts the target.

```APIDOC
## getTargetStart(This)

### Description
Get the position that starts the target.

### Signature
-spec getTargetStart(This) -> integer() when This :: wxStyledTextCtrl().
```

--------------------------------

### Start Reltool Server and Get Configuration

Source: https://www.erlang.org/doc/apps/reltool/reltool_examples.md

Demonstrates starting a Reltool server, retrieving its process ID, and inspecting its configuration. This is useful for programmatic control of Reltool.

```erlang
Erlang/OTP 20 [erts-9.0] [source-c13b302] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10]
[hipe] [kernel-poll:false]
Eshell V9.0  (abort with ^G)
1>
1> {ok, Win} = reltool:start([]).
{ok,<0.36.01>}
2> {ok, Server} = reltool:get_server(Win).
{ok,<0.37.01>}
3> reltool:get_config(Server).
{ok,{sys,[]}}
4>
4> {ok, Server2} = reltool:start_server([]).
{ok,<0.6535.01>}
5> reltool:get_config(Server2).
{ok,{sys,[]}}
6> reltool:stop(Server2).
ok
```

--------------------------------

### getHighlightGuide

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Get the highlighted indentation guide column.

```APIDOC
## getHighlightGuide(This)

### Description
Get the highlighted indentation guide column.

### Signature
-spec getHighlightGuide(This) -> integer() when This :: wxStyledTextCtrl().
```

--------------------------------

### Setup Input Controller

Source: https://www.erlang.org/doc/apps/erts/assets/gen_tcp_dist.erl

Links the supervisor and waits for the distribution handle to start the input loop.

```erlang
dist_cntrlr_input_setup(DHandle, Socket, Sup) ->
    link(Sup),
    %% Ensure we don't try to put data before we are registered
    %% as input handler...
    receive
        DHandle ->
            dist_cntrlr_input_loop(DHandle, Socket, 0)
    end.
```

--------------------------------

### Install Documentation

Source: https://www.erlang.org/doc/system/install.md

Commands to install documentation based on the chosen installation method.

```bash
$ make install-docs
```

```bash
$ make release_docs RELEASE_ROOT=<release dir>
```

--------------------------------

### Add Module, Update Supervisor, and Start Child

Source: https://www.erlang.org/doc/system/appup_cookbook.md

Comprehensive example for upgrading, including adding a new module, updating the supervisor, and starting the new child process. Downgrade instructions are also shown.

```erlang
"2",
[{"1",
   [{add_module, m1},
    {update, ch_sup, supervisor},
    {apply, {supervisor, restart_child, [ch_sup, m1]}}
   ]}],
[{"1",
   [{apply, {supervisor, terminate_child, [ch_sup, m1]}},
    {apply, {supervisor, delete_child, [ch_sup, m1]}},
    {update, ch_sup, supervisor},
    {delete_module, m1}
   ]}]
.

```

--------------------------------

### Running the Erlang Example

Source: https://www.erlang.org/doc/system/erl_interface.md

These Erlang commands show how to start the C program as a port, call functions within it (foo, bar), and then stop the port. The output demonstrates successful execution and return values.

```erlang
2> complex2:start("./extprg").
<0.34.0>
3> complex2:foo(3).
4
4> complex2:bar(5).
10
5> complex2:bar(352).
704
6> complex2:stop().
stop
```

--------------------------------

### Erlang Node Startup Example (gollum)

Source: https://www.erlang.org/doc/system/conc_prog.md

Example of starting an Erlang node named 'pong' on the 'gollum' machine. This shows the command-line interface for another node in the distributed system.

```text
gollum$ erl -sname pong
Erlang/OTP 28 [erts-16.3] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit:ns]

Eshell V16.3 (press Ctrl+G to abort, type help(). for help)
(pong@gollum)1>
```

--------------------------------

### Start HTTP server via application configuration

Source: https://www.erlang.org/doc/apps/inets/http_server.md

Example configuration to be placed in an Erlang node application configuration file to initialize HTTP servers at startup.

```erlang
[{inets, [{services, [{httpd, [{proplist_file,
           "/var/tmp/server_root/conf/8888_props.conf"}]},
          {httpd, [{proplist_file,
           "/var/tmp/server_root/conf/8080_props.conf"}]}]}]}].
```

--------------------------------

### Emacs Setup for Erlang Mode

Source: https://www.erlang.org/doc/apps/tools/erlang_mode_chapter.md

Example configuration for the .emacs file to set up Erlang mode on UNIX systems. Ensure OTP is installed in the specified directory.

```text
(setq load-path (cons  "/usr/local/otp/lib/tools-<ToolsVer>/emacs"
load-path))
(setq erlang-root-dir "/usr/local/otp")
(setq exec-path (cons "/usr/local/otp/bin" exec-path))
(require 'erlang-start)
```

--------------------------------

### Get start colour

Source: https://www.erlang.org/doc/apps/wx/wxGraphicsGradientStops.md

Retrieves the start colour of the gradient.

```erlang
-spec getStartColour(This) -> wx:wx_colour4() when This :: wxGraphicsGradientStops().
```

--------------------------------

### Starting a Distributed Application

Source: https://www.erlang.org/doc/system/distributed_applications.md

Call `application:start(Application)` on all involved nodes to start a distributed application. The example shows starting 'myapp' on 'cp1'.

```erlang
application:start(myapp).
```

--------------------------------

### Starting an Erlang System for Illustration

Source: https://www.erlang.org/doc/system/release_handling.md

Illustrates how to start an Erlang system using 'erl' with a specified boot script and configuration file. This is for demonstration purposes before actual embedded system startup.

```bash
% cd $ROOT
% bin/erl -boot $ROOT/releases/A/start -config $ROOT/releases/A/sys
...
```

--------------------------------

### Start Debug Emulator from Installation

Source: https://www.erlang.org/doc/system/debugging.md

Use this command to start the debug emulator if it's part of your Erlang/OTP installation. The `-emu_type debug` option enables enhanced debugging features.

```bash
> erl -emu_type debug
Erlang/OTP 25 [erts-13.0.2] ... [type-assertions] [debug-compiled] [lock-checking]

Eshell V13.0.2  (abort with ^G)
1>
```

--------------------------------

### start/2

Source: https://www.erlang.org/doc/apps/kernel/erl_boot_server.md

Starts the boot server with a list of allowed slaves and configuration options.

```APIDOC
## start(Slaves, Options)

### Description
Starts the boot server. `Slaves` is a list of IP addresses for hosts allowed to use this server. `Options` is a map with configuration options like `listen_port`.

### Parameters
- **Slaves** ([Host]) - Required - List of allowed hosts.
- **Options** (map) - Optional - Configuration map, e.g., #{listen_port => inet:port_number()}.

### Returns
- **{ok, Pid}** - Success
- **{error, Reason}** - Failure
```

--------------------------------

### Example: Patching mnesia and ssl

Source: https://www.erlang.org/doc/system/otp-patch-apply.md

This example shows how to patch 'mnesia' and 'ssl' applications from a source directory into an OTP installation. Ensure the source and installation directories are correctly specified.

```bash
otp_patch_apply -s /home/me/git/otp -i /opt/erlang/my_otp \
  mnesia ssl
```

--------------------------------

### Erlang .erlang Startup File Example

Source: https://www.erlang.org/doc/apps/erts/erl_cmd.md

This snippet shows a typical .erlang file configuration for setting up search paths and printing messages during startup.

```erlang
io:format("executing user profile in $HOME/.erlang\n",[]).
code:add_path("/home/calvin/test/ebin").
code:add_path("/home/hobbes/bigappl-1.2/ebin").
io:format(".erlang rc finished\n",[]).
```

--------------------------------

### substr usage example

Source: https://www.erlang.org/doc/apps/stdlib/string.md

Example of extracting a substring using a start position and length.

```erlang
1> substr("Hello World", 4, 5).
"lo Wo"
```

--------------------------------

### Start a main window process with options

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Initializes a main window process with custom configuration options.

```erlang
-spec start(options()) -> {ok, window_pid()} | {error, reason()}.
```

--------------------------------

### Erlang Echo Server Setup

Source: https://www.erlang.org/doc/apps/kernel/socket_usage.md

Sets up an echo server by opening, binding, and listening on a socket. It returns the port and address used, and starts an acceptor process.

```erlang
server() ->
    %% Make system choose port (and address)
    server(0).

%% This function return the port and address that it actually uses,
%% in case server/0 or server/1 (with a port number) was used to start it.

server(#{family := Family, addr := Addr, port := _} = SockAddr) ->
    {ok, Sock} = socket:open(Family, stream, tcp),
    ok         = socket:bind(Sock, SockAddr),
    ok         = socket:listen(Sock),
    {ok, #{port := Port}} = socket:sockname(Sock),
    Acceptor = start_acceptor(Sock),
    {ok, {Port, Addr, Acceptor}};

server(Port) when is_integer(Port) ->
    Family   = inet, % Default
    Addr     = get_local_addr(Family), % Pick an address
    SockAddr = #{family => Family,
		 addr   => Addr,
		 port   => Port},
    server(SockAddr).

server(Port, Addr)
  when is_integer(Port) andalso (Port >= 0) andalso
       is_tuple(Addr) ->
    Family   = which_family(Addr),
    SockAddr = #{family => Family,
		 addr   => Addr,
		 port   => Port},
    server(SockAddr).
```

--------------------------------

### Get selection start position

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Returns the character position at the start of the current selection.

```erlang
-spec getSelectionStart(This) -> integer() when This :: wxStyledTextCtrl().
```

--------------------------------

### Get view start position

Source: https://www.erlang.org/doc/apps/wx/wxScrolledWindow.md

Returns the current view start coordinates for the scrolled window.

```erlang
-spec getViewStart(This) -> {X :: integer(), Y :: integer()} when This :: wxScrolledWindow().
```

--------------------------------

### ensure_all_started/3

Source: https://www.erlang.org/doc/apps/kernel/application.md

Starts the specified applications and their dependencies with a configurable startup mode.

```APIDOC
## ensure_all_started(Applications, Type, Mode)

### Description
Starts the specified applications and their dependencies. The Mode argument controls if the applications should be started in serial mode or concurrent mode.

### Signature
ensure_all_started(Applications, Type, Mode) -> {ok, Started} | {error, AppReason}

### Parameters
- **Applications** (atom() | [atom()]) - Required - The application or list of applications to start.
- **Type** (restart_type()) - Required - The restart type for the applications.
- **Mode** (serial | concurrent) - Required - The mode of startup. Defaults to serial if not provided.
```

--------------------------------

### start/0

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Starts a main window process with default options.

```APIDOC
## start()

### Description
Starts a main window process with default options.

### Signature
`start() -> {ok, window_pid()} | {error, reason()}`
```

--------------------------------

### Traverse a tree starting from a key

Source: https://www.erlang.org/doc/apps/stdlib/gb_trees.md

Example usage of creating iterators starting from a specific key in both directions.

```erlang
1> Tree = gb_trees:from_list([{a,1},{b,2},{c,3},{d,4}]).
2> Iter0 = gb_trees:iterator_from(aa, Tree, ordered).
3> {b,2,Iter1} = gb_trees:next(Iter0).
4> RevIter0 = gb_trees:iterator_from(c, Tree, reversed).
5> {c,3,RevIter1} = gb_trees:next(RevIter0).
6> {b,2,RevIter2} = gb_trees:next(RevIter1).
```

--------------------------------

### Example Erlang Application Callback Module

Source: https://www.erlang.org/doc/system/applications.md

An example of an application callback module named `ch_app` that implements the `application` behaviour. It starts the `ch_sup` supervision tree upon application start and performs no specific cleanup on stop.

```erlang
-module(ch_app).
-behaviour(application).

-export([start/2, stop/1]).

start(_Type, _Args) ->
    ch_sup:start_link().

stop(_State) ->
    ok.
```

--------------------------------

### start/2

Source: https://www.erlang.org/doc/apps/tools/xref.md

Creates an Xref server with a specified name and configuration options.

```APIDOC
## start(Name, Options)

### Description
Creates an Xref server with a given name. The default mode is functions. Options that are not recognized by Xref are passed on to gen_server:start/4.

### Signature
-spec start(Name, Options) -> {ok, pid()} | {error, {already_started, pid()}}
```

--------------------------------

### start/4

Source: https://www.erlang.org/doc/apps/wx/wx_object.md

Starts a generic wx_object server.

```APIDOC
## start(Name, Mod, Args, Options)

### Description
Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

### Parameters
- **Name** ({local, atom()}) - Required
- **Mod** (atom()) - Required
- **Args** (term()) - Required
- **Options** ([{timeout, timeout()} | {debug, [Flag]}]) - Required
```

--------------------------------

### getViewStart/1

Source: https://www.erlang.org/doc/apps/wx/wxScrolledWindow.md

Gets the view start position.

```APIDOC
## getViewStart(This)

### Description
Returns the current view start position.

### Parameters
- **This** (wxScrolledWindow()) - Required - The scrolled window instance.

### Returns
- **{X, Y}** (integer(), integer()) - The current view start coordinates.
```

--------------------------------

### Configuration file example

Source: https://www.erlang.org/doc/apps/common_test/ct.md

Example of a configuration file structure.

```erlang
{unix,[{telnet,IpAddr},
       {user,[{username,Username},
              {password,Password}]}]}.
```

--------------------------------

### start_link/3

Source: https://www.erlang.org/doc/apps/wx/wx_object.md

Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

```APIDOC
## start_link(Mod, Args, Options)

### Description
Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

### Parameters
- **Mod** (atom) - Required - The module name.
- **Args** (term) - Required - Arguments passed to the init function.
- **Options** (list) - Required - A list of options including timeout and debug flags.
```

--------------------------------

### start/1

Source: https://www.erlang.org/doc/apps/tools/xref.md

Creates an Xref server with optional name or configuration options.

```APIDOC
## start(NameOrOptions)

### Description
Creates an Xref server. The process can optionally be given a name. The default mode is functions. Options that are not recognized by Xref are passed on to gen_server:start/4.

### Signature
-spec start(NameOrOptions) -> {ok, pid()} | {error, {already_started, pid()}}
```

--------------------------------

### Get start position of a word

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Calculates the starting position of a word based on the provided position and word character constraints.

```erlang
-spec wordStartPosition(This, Pos, OnlyWordCharacters) -> integer()
                           when
                               This :: wxStyledTextCtrl(),
                               Pos :: integer(),
                               OnlyWordCharacters :: boolean().
```

--------------------------------

### Install Configuration and Handlers

Source: https://www.erlang.org/doc/apps/common_test/ct.md

Installs configuration files and event handlers; should be executed once before the first test.

```erlang
-spec install(Opts) -> ok | {error, Reason}
                 when
                     Opts :: [Opt],
                     Opt :: {config, ConfigFiles} | {event_handler, Modules} | {decrypt, KeyOrFile},
                     ConfigFiles :: [ConfigFile],
                     ConfigFile :: string(),
                     Modules :: [atom()],
                     KeyOrFile :: {key, Key} | {file, KeyFile},
                     Key :: string(),
                     KeyFile :: string(),
                     Reason :: term().
```

```erlang
install([{config,["config_node.ctc","config_user.ctc"]}])
```

--------------------------------

### Pattern start sequence for BSR and newline conventions

Source: https://www.erlang.org/doc/apps/stdlib/re.md

Example of combining newline convention and BSR settings at the start of a pattern string.

```text
(*ANY)(*BSR_ANYCRLF)
```

--------------------------------

### start_link/2

Source: https://www.erlang.org/doc/apps/kernel/erl_boot_server.md

Starts the boot server and links to the caller.

```APIDOC
## start_link(Slaves, Options)

### Description
Starts the boot server and links to the caller. Same functionality as `start/2`.

### Parameters
- **Slaves** ([Host]) - Required - List of allowed hosts.
- **Options** (map) - Optional - Configuration map.

### Returns
- **{ok, Pid}** - Success
- **{error, Reason}** - Failure
```

--------------------------------

### start()

Source: https://www.erlang.org/doc/apps/diameter/diameter.md

Starts the diameter application.

```APIDOC
## start()

### Description
Start the diameter application. The diameter application must be started before starting a service.

### Signature
-spec start() -> ok | {error, Reason} when Reason :: term().
```

--------------------------------

### Execute start_trace example

Source: https://www.erlang.org/doc/apps/observer/ttb.md

Example usage of start_trace and its equivalent manual sequence.

```erlang
> ttb:start_trace([Node, OtherNode],
                  [{mod, foo, []}, {mod, bar, 2}],
                  {all, call},
                  [{file, File}, {handler,{fun myhandler/4, S}}]).
```

```erlang
> ttb:start_trace([Node, OtherNode],
                  [{file, File}, {handler,{fun myhandler/4, S}}]),
ttb:tpl(mod, foo, []),
ttb:tpl(mod, bar, 2, []),
ttb:p(all, call).
```

--------------------------------

### Implement add_handlers in application start

Source: https://www.erlang.org/doc/apps/kernel/logger.md

Example of calling logger:add_handlers/1 within an application's start function after the supervisor has initialized.

```erlang
-behaviour(application).
start(_, []) ->
    case supervisor:start_link({local, my_sup}, my_sup, []) of
        {ok, Pid} ->
            ok = logger:add_handlers(my_app),
            {ok, Pid, []};
        Error -> Error
     end.
```

--------------------------------

### Start IPv6 Distributed Erlang Node

Source: https://www.erlang.org/doc/apps/erts/erl_cmd.md

Example of starting an Erlang node configured for distributed communication over IPv6 using the inet6_tcp protocol.

```bash
% erl -name test@ipv6node.example.com -proto_dist inet6_tcp
```

--------------------------------

### new/0 and new/1

Source: https://www.erlang.org/doc/apps/wx/wx.md

Starts a wx server.

```APIDOC
## new()

### Description
Starts a wx server.

### Signature
-spec new() -> wx_object()

## new(Options)

### Description
Starts a wx server with options.

### Signature
-spec new([Option]) -> wx_object() when Option :: {debug, list() | atom()} | {silent_start, boolean()}
```

--------------------------------

### Initialize Mnesia Schema and Start Node

Source: https://www.erlang.org/doc/apps/mnesia/mnesia_chap2.md

Initializes the Mnesia schema for a database and starts the Mnesia node. This is typically done during Mnesia setup.

```erlang
% erl -mnesia dir '"/ldisc/scratch/Mnesia.Company"'
Erlang/OTP 27 [erts-15.1.2]

Eshell V15.1.2 (press Ctrl+G to abort, type help(). for help)
1> mnesia:create_schema([node()]).
ok
2> mnesia:start().
ok
```

--------------------------------

### init:boot/1

Source: https://www.erlang.org/doc/apps/erts/init.md

Starts the Erlang runtime system.

```APIDOC
## init:boot(BootArgs)

### Description
Starts the Erlang runtime system. This function is called when the emulator is started and coordinates system startup.

### Parameters
- **BootArgs** ([binary()]) - Required - Command-line arguments excluding emulator flags.
```

--------------------------------

### Install MinGW-w64 and Make

Source: https://www.erlang.org/doc/system/install-win32.md

Install the MinGW-w64 cross-compiler toolchain and make utility using apt within the WSL environment.

```bash
sudo apt update && sudo apt install g++-mingw-w64 gcc-mingw-w64 make
```

--------------------------------

### Build Documentation

Source: https://www.erlang.org/doc/system/install.md

Commands to configure, set the path, and build documentation targets.

```bash
$ cd $ERL_TOP
```

```bash
$ ./configure [Configure Args]
```

```bash
$ export PATH=$ERL_TOP/bin:$PATH     # Assuming bash/sh
```

```bash
$ make docs
```

```bash
$ make docs DOC_TARGETS=chunks
```

--------------------------------

### start_link/4

Source: https://www.erlang.org/doc/apps/wx/wx_object.md

Starts a generic wx_object server with a registered name and invokes Mod:init(Args) in the new process.

```APIDOC
## start_link(Name, Mod, Args, Options)

### Description
Starts a generic wx_object server with a registered name and invokes Mod:init(Args) in the new process.

### Parameters
- **Name** ({local, atom}) - Required - The local name to register the process under.
- **Mod** (atom) - Required - The module name.
- **Args** (term) - Required - Arguments passed to the init function.
- **Options** (list) - Required - A list of options including timeout and debug flags.
```

--------------------------------

### Get From Page

Source: https://www.erlang.org/doc/apps/wx/wxPrintDialogData.md

Retrieves the starting page number entered by the user.

```erlang
-spec getFromPage(This) -> integer() when This :: wxPrintDialogData().
```

--------------------------------

### Erlang Ping-Pong Example Execution

Source: https://www.erlang.org/doc/system/conc_prog.md

Shows the output of the Erlang ping-pong example when started with a specific node configuration. All output is consolidated to the node where the command is initiated.

```erlang
(pong@gollum)1> tut18:start(ping@kosken).
<3934.39.0>
Pong received ping
Ping received pong
Pong received ping
Ping received pong
Pong received ping
Ping received pong
Pong finished
ping finished
```

--------------------------------

### start/1

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Starts a main window process with specified options.

```APIDOC
## start(options)

### Description
Starts a main window process with provided options.

### Signature
`start(options()) -> {ok, window_pid()} | {error, reason()}`
```

--------------------------------

### Starting Erlang Node with -sname

Source: https://www.erlang.org/doc/apps/erts/alt_dist.md

Starts an Erlang node with a short name, useful for distributed operations. This example shows the command-line arguments required for such a startup.

```text
$ erl -pa $ERL_TOP/lib/kernel/examples/uds_dist/ebin -proto_dist uds \
      -no_epmd -sname bong
Erlang (BEAM) emulator version 5.0

Eshell V5.0  (abort with ^G)
(bong@hador)1>
```

--------------------------------

### net_kernel:start(Name, Options)

Source: https://www.erlang.org/doc/apps/kernel/net_kernel.md

Initializes distribution for the current node. If Name is undefined, it requests a dynamic node name from the first node it connects to.

```APIDOC
## net_kernel:start(Name, Options)

### Description
Turns a non-distributed node into a distributed node by starting net_kernel and other necessary processes. If Name is set to undefined, the distribution will be started to request a dynamic node name from the first node it connects to.

### Signature
`net_kernel:start(Name, Options) -> {ok, pid()} | {error, Reason}`

### Parameters
- **Name** (atom | undefined) - Required - The name of the node to start.
- **Options** (map) - Required - Configuration map for the distribution.
    - **name_domain** (shortnames | longnames) - Optional - Determines the host name part of the node name.
    - **net_ticktime** (pos_integer) - Optional - Net tick time in seconds.
    - **net_tickintensity** (4..1000) - Optional - Net tick intensity value.
    - **dist_listen** (boolean) - Optional - Enable or disable listening for incoming connections.
    - **hidden** (boolean) - Optional - Enable or disable hidden node status.

### Return Values
- **{ok, pid()}** - Success, returns the process ID of the net_kernel.
- **{error, Reason}** - Failure, returns the error reason (e.g., {already_started, pid()}).
```

--------------------------------

### Get partial text extents

Source: https://www.erlang.org/doc/apps/wx/wxGraphicsContext.md

Calculates the widths from the start of the text to each character.

```erlang
-spec getPartialTextExtents(This, Text) -> [number()]
                               when This :: wxGraphicsContext(), Text :: unicode:chardata().
```

--------------------------------

### install/2

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Installs a created target system.

```APIDOC
## install(rel_name(), dir())

### Description
Install a created target system.

### Parameters
- **rel_name** (rel_name()) - Required - The name of the release.
- **dir** (dir()) - Required - The installation directory.
```

--------------------------------

### Get Handler IDs

Source: https://www.erlang.org/doc/apps/kernel/logger.md

Retrieves the identities of all currently installed Logger handlers.

```erlang
-spec get_handler_ids() -> [HandlerId] when HandlerId :: logger_handler:id().
```

--------------------------------

### setHighlightGuide

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Sets the highlighted indentation guide column. A value of 0 disables the guide.

```APIDOC
## setHighlightGuide(This, Column)

### Description
Set the highlighted indentation guide column.

### Signature
-spec setHighlightGuide(This, Column) -> ok when This :: wxStyledTextCtrl(), Column :: integer().
```

--------------------------------

### startRecord

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Starts recording key presses and commands.

```APIDOC
## startRecord(This)

### Description
Start notifying the container of all key presses and commands.

### Parameters
- **This** (wxStyledTextCtrl) - Required
```

--------------------------------

### new/1,2

Source: https://www.erlang.org/doc/apps/wx/wxPageSetupDialog.md

Constructs a new wxPageSetupDialog object, optionally initializing it with existing page setup data.

```APIDOC
## new(Parent)
## new(Parent, [Option])

### Description
Constructor for the wxPageSetupDialog. Pass a parent window and optionally a block of page setup data to be copied to the dialog's internal data.

### Parameters
- **Parent** (wxWindow:wxWindow()) - Required - The parent window for the dialog.
- **Option** ({data, wxPageSetupDialogData:wxPageSetupDialogData()}) - Optional - Initial page setup data.
```

--------------------------------

### Erlang Common Test Suite Example

Source: https://www.erlang.org/doc/apps/common_test/example_chapter.md

This is a complete example of a Common Test suite for testing a database server. It includes suite initialization, test case setup and teardown, and example test cases for string and integer data types.

```erlang
-module(db_data_type_SUITE).

-include_lib("common_test/include/ct.hrl").

%% Test server callbacks
-export([suite/0, all/0, 
         init_per_suite/1, end_per_suite/1, 
         init_per_testcase/2, end_per_testcase/2]).

%% Test cases
-export([string/1, integer/1]).

-define(CONNECT_STR, "DSN=sqlserver;UID=alladin;PWD=sesame").

%%--------------------------------------------------------------------
%% COMMON TEST CALLBACK FUNCTIONS
%%--------------------------------------------------------------------

%%--------------------------------------------------------------------
%% Function: suite() -> Info
%%
%% Info = [tuple()]
%%   List of key/value pairs.
%%
%% Description: Returns list of tuples to set default properties
%%              for the suite.
%%--------------------------------------------------------------------
suite() ->
    [{timetrap,{minutes,1}}].

%%--------------------------------------------------------------------
%% Function: init_per_suite(Config0) -> Config1
%%
%% Config0 = Config1 = [tuple()]
%%   A list of key/value pairs, holding the test case configuration.
%%
%% Description: Initialization before the suite.
%%--------------------------------------------------------------------
init_per_suite(Config) ->
    {ok, Ref} = db:connect(?CONNECT_STR, []),
    TableName = db_lib:unique_table_name(),
    [{con_ref, Ref },{table_name, TableName}| Config].

%%--------------------------------------------------------------------
%% Function: end_per_suite(Config) -> term()
%%
%% Config = [tuple()]
%%   A list of key/value pairs, holding the test case configuration.
%%
%% Description: Cleanup after the suite.
%%--------------------------------------------------------------------
end_per_suite(Config) ->
    Ref = proplists:get_value(con_ref, Config),
    db:disconnect(Ref),
    ok.

%%--------------------------------------------------------------------
%% Function: init_per_testcase(TestCase, Config0) -> Config1
%%
%% TestCase = atom()
%%   Name of the test case that is about to run.
%% Config0 = Config1 = [tuple()]
%%   A list of key/value pairs, holding the test case configuration.
%%
%% Description: Initialization before each test case.
%%--------------------------------------------------------------------
init_per_testcase(Case, Config) ->
    Ref = proplists:get_value(con_ref, Config),
    TableName = proplists:get_value(table_name, Config),
    ok = db:create_table(Ref, TableName, table_type(Case)),
    Config.

%%--------------------------------------------------------------------
%% Function: end_per_testcase(TestCase, Config) -> term()
%%
%% TestCase = atom()
%%   Name of the test case that is finished.
%% Config = [tuple()]
%%   A list of key/value pairs, holding the test case configuration.
%%
%% Description: Cleanup after each test case.
%%--------------------------------------------------------------------
end_per_testcase(_Case, Config) ->
    Ref = proplists:get_value(con_ref, Config),
    TableName = proplists:get_value(table_name, Config),
    ok = db:delete_table(Ref, TableName),
    ok.

%%--------------------------------------------------------------------
%% Function: all() -> GroupsAndTestCases
%%
%% GroupsAndTestCases = [{group,GroupName} | TestCase]
%% GroupName = atom()
%%   Name of a test case group.
%% TestCase = atom()
%%   Name of a test case.
%%
%% Description: Returns the list of groups and test cases that
%%              are to be executed.
%%--------------------------------------------------------------------
all() ->
    [string, integer].


%%--------------------------------------------------------------------
%% TEST CASES
%%--------------------------------------------------------------------

string(Config) ->
    insert_and_lookup(dummy_key, "Dummy string", Config).

integer(Config) ->
    insert_and_lookup(dummy_key, 42, Config).


insert_and_lookup(Key, Value, Config) ->
    Ref = proplists:get_value(con_ref, Config),
    TableName = proplists:get_value(table_name, Config),
    ok = db:insert(Ref, TableName, Key, Value),
    [Value] = db:lookup(Ref, TableName, Key),
    ok = db:delete(Ref, TableName, Key),
    [] = db:lookup(Ref, TableName, Key),
    ok.

```

--------------------------------

### Start a main window process

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Initializes a main window process using default configuration options.

```erlang
-spec start() -> {ok, window_pid()} | {error, reason()}.
```

--------------------------------

### Supervisor Callback Module Example

Source: https://www.erlang.org/doc/system/sup_princ.md

This is an example of a supervisor's callback module. It defines how to start and manage child processes. Ensure the 'ch3' module is available and correctly defined.

```erlang
-module(ch_sup).
-behaviour(supervisor).

-export([start_link/0]).
-export([init/1]).

start_link() ->
    supervisor:start_link(ch_sup, []).

init(_Args) ->
    SupFlags = #{strategy => one_for_one, intensity => 1, period => 5},
    ChildSpecs = [#{id => ch3,
                    start => {ch3, start_link, []},
                    restart => permanent,
                    shutdown => brutal_kill,
                    type => worker,
                    modules => [ch3]}],
    {ok, {SupFlags, ChildSpecs}}.
```

--------------------------------

### start/1

Source: https://www.erlang.org/doc/apps/observer/observer.md

Starts the Observer GUI and connects to a specific node.

```APIDOC
## start(Node)

### Description
Starts the Observer GUI and tries to connect it to the specified Node.

### Signature
`start(Node :: node() | [node()]) -> ok | {error, term()}`
```

--------------------------------

### spawn_monitor/3

Source: https://www.erlang.org/doc/man/erlang

Starts a new process and creates a monitor for it simultaneously.

```APIDOC
## spawn_monitor(Module, Function, Args)

### Description
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.
```

--------------------------------

### Start SNMP Manager and Interact with Agent

Source: https://www.erlang.org/doc/apps/snmp/snmp_impl_example_agent.md

Start a simple SNMP manager and link it to an agent. This example demonstrates performing GET-NEXT and SET requests using symbolic names.

```erlang
1> snmp_test_mgr:start_link([{agent,"dront.ericsson.se"},{community,"all-rights"},
 %% making it understand symbolic names: {mibs,["EX1-MIB","STANDARD-MIB"]}])).
{ok, <0.89.0>}
%% a get-next request with one OID.
2> snmp_test_mgr:gn([[1,3,6,1,3,7]]).
ok
* Got PDU:
[myName,0] = []
%% A set-request (now using symbolic names for convenience)
3> snmp_test_mgr:s([{[myName,0], "Martin"}]).
ok
* Got PDU:
[myName,0] = "Martin"
%% Try the same get-next request again
4> snmp_test_mgr:gn([[1,3,6,1,3,7]]).
ok
* Got PDU:
[myName,0] = "Martin"
%% ... and we got the new value.
%% you can event do row operations. How to add a row:
5> snmp_test_mgr:s([{[fName,0], "Martin"}, {[fAddress,0],"home"}, {[fStatus,0],4}]).
 %% createAndGo
ok
* Got PDU:
[fName,0] = "Martin"
[fAddress,0] = "home"
[fStatus,0] = 4
6> snmp_test_mgr:gn([[myName,0]]).
ok
* Got PDU:
[fName,0] = "Martin"
7> snmp_test_mgr:gn().
ok
* Got PDU:
[fAddress,0] = "home"
8> snmp_test_mgr:gn().
ok
* Got PDU:
[fStatus,0] = 1
9>
```

--------------------------------

### Example System Configuration File

Source: https://www.erlang.org/doc/system/applications.md

A sample system configuration file 'test.config' that overrides the 'file' environment variable for 'ch_app'.

```text
[{ch_app, [{file, "testlog"}]}].

```

--------------------------------

### start_server/1

Source: https://www.erlang.org/doc/apps/reltool/reltool.md

Starts a server process with specified options.

```APIDOC
## start_server(options)

### Description
Starts a server process with options. The returned server process identity can be used in other API functions.

### Signature
`start_server(options()) -> {ok, server_pid()} | {error, reason()}`
```

--------------------------------

### Get Origin-State-Id

Source: https://www.erlang.org/doc/apps/diameter/diameter.md

Returns a value for the Origin-State-Id attribute based on the application start time.

```erlang
-spec origin_state_id() -> 'Unsigned32'().
```

--------------------------------

### useProgram/1

Source: https://www.erlang.org/doc/apps/wx/gl.md

Installs a program object as part of the current rendering state.

```APIDOC
## useProgram(Program)

### Description
Installs the program object specified by `Program` as part of the current rendering state.

### Signature
`-spec useProgram(Program :: i()) -> ok.`

### Parameters
- **Program** (i) - The program object to install.
```

--------------------------------

### Setup Environment for Windows Build

Source: https://www.erlang.org/doc/system/install-win32.md

Sets up the necessary environment variables for building Erlang/OTP on Windows.

```shell
(cd $ERL_TOP && eval `./otp_build env_win32`)
```

--------------------------------

### Get Page Setup Data

Source: https://www.erlang.org/doc/apps/wx/wxHtmlEasyPrinting.md

Retrieves the wxPageSetupDialogData instance associated with the printing object.

```erlang
-spec getPageSetupData(This) -> wxPageSetupDialogData:wxPageSetupDialogData()
                          when This :: wxHtmlEasyPrinting().
```

--------------------------------

### Start Erlang as a Hidden Node

Source: https://www.erlang.org/doc/apps/erts/erl_cmd.md

Starts the Erlang runtime system as a hidden node in a distributed setup. Hidden nodes do not appear in the `nodes/0` list of other nodes and establish hidden connections.

```text
-hidden
```

--------------------------------

### Example sys.config and Included Files

Source: https://www.erlang.org/doc/apps/kernel/config.md

Illustrates how sys.config can include other configuration files and application-specific settings. The example shows nested includes and merging of application parameters.

```text
sys.config:

"/home/user/myconfig1"
{myapp,[{par1,val1},{par2,val2}]},
"/home/user/myconfig2".

myconfig1.config:

[{myapp,[{par0,val0},{par1,val0},{par2,val0}]}].

myconfig2.config:

[{myapp,[{par2,val3},{par3,val4}]}].

```

--------------------------------

### create/2,3

Source: https://www.erlang.org/doc/apps/wx/wxSashLayoutWindow.md

Initializes a sash layout window instance.

```APIDOC
## create(This, Parent)
## create(This, Parent, [Option])

### Description
Initializes a sash layout window, which can be a child of a frame, dialog or any other non-control window.

### Parameters
- **This** (wxSashLayoutWindow()) - Required - The window instance.
- **Parent** (wxWindow:wxWindow()) - Required - The parent window.
- **Option** (list) - Optional - Options include {id, integer()}, {pos, {X, Y}}, {size, {W, H}}, or {style, integer()}.
```

--------------------------------

### init/0

Source: https://www.erlang.org/doc/apps/snmp/snmp_framework_mib.md

Initializes the database objects at system start-up.

```APIDOC
## init()

### Description
Called from the supervisor at system start-up to create necessary objects in the database if they do not already exist. It does not destroy existing values.
```

--------------------------------

### Example of post_process_args usage

Source: https://www.erlang.org/doc/apps/stdlib/peer.md

Demonstrates how to modify arguments passed to the execution command before the peer starts.

```erlang
peer:start(#{ name => peer:random_name(),
  exec => {os:find_executable("bash"),["-c","erl"]},
  post_process_args =>
     fun(["-c"|Args]) -> ["-c", lists:flatten(lists:join($\s, Args))] end
  }).
```

--------------------------------

### getSelectionStart/1

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Retrieves the starting position of the current selection.

```APIDOC
## getSelectionStart(This)

### Description
Returns the position at the start of the selection.

### Signature
-spec getSelectionStart(This) -> integer() when This :: wxStyledTextCtrl().
```

--------------------------------

### Begin query

Source: https://www.erlang.org/doc/apps/wx/gl.md

Starts a query operation for a specific target and ID.

```erlang
-spec beginQuery(Target :: enum(), Id :: i()) -> ok.
```

--------------------------------

### start(Options)

Source: https://www.erlang.org/doc/apps/tftp/tftp.md

Starts a TFTP daemon process listening for UDP packets on a port.

```APIDOC
## start(Options)

### Description
Starts a daemon process listening for UDP packets on a port. When a request is received, it spawns a temporary server process to handle the file transfer.

### Signature
`start(Options) -> {ok, Pid} | {error, Reason}`

### Parameters
- **Options** (list) - Required - A list of connection options.

### Returns
- **{ok, Pid}** - Success, returns the process ID of the daemon.
- **{error, Reason}** - Failure, returns the error reason.
```

--------------------------------

### Start Simple MG Example

Source: https://www.erlang.org/doc/apps/megaco/megaco_examples.md

Starts a simple Media Gateway that connects to an MGC, sends a Service Change Request, and waits for a reply. Useful for visualizing MG interactions with the protocol stack.

```text
      cd megaco/examples/simple
      erl -pa ../../../megaco/ebin -s megaco_filter -s megaco
      megaco_simple_mg:start().
```

--------------------------------

### Starting Erlang with Custom inet Configuration

Source: https://www.erlang.org/doc/apps/erts/inet_cfg.md

Demonstrates how to start the Erlang shell with a specified `inetrc` configuration file. Ensure the path to the configuration file is correctly quoted.

```text
% erl -sname my_node -kernel inetrc '"./cfg_files/erl_inetrc"'
```

--------------------------------

### start/0

Source: https://www.erlang.org/doc/apps/tools/fprof.md

Starts the fprof server.

```APIDOC
## start()

### Description
Starts the fprof server. Note that this is usually called automatically by other functions.

### Signature
-spec start() -> {ok, Pid} | {error, {already_started, Pid}}
```

--------------------------------

### wordStartPosition

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Retrieves the starting position of a word.

```APIDOC
## wordStartPosition(This, Pos, OnlyWordCharacters)

### Description
Get position of start of word.

### Signature
-spec wordStartPosition(This, Pos, OnlyWordCharacters) -> integer() when This :: wxStyledTextCtrl(), Pos :: integer(), OnlyWordCharacters :: boolean().
```

--------------------------------

### gotoLine

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Set caret to start of a line and ensure it is visible.

```APIDOC
## gotoLine(This, Line)

### Description
Set caret to start of a line and ensure it is visible.

### Parameters
- **This** (wxStyledTextCtrl()) - Required - The control instance.
- **Line** (integer()) - Required - The line number to navigate to.
```

--------------------------------

### getIndentationGuides

Source: https://www.erlang.org/doc/apps/wx/wxStyledTextCtrl.md

Checks if the indentation guides are visible.

```APIDOC
## getIndentationGuides

### Description
Returns the visibility status of indentation guides as one of the ?wxSTC_IV_* constants.

### Signature
-spec getIndentationGuides(This) -> integer() when This :: wxStyledTextCtrl().
```

--------------------------------

### Start Simple MGC Example

Source: https://www.erlang.org/doc/apps/megaco/megaco_examples.md

Starts a simple Media Gateway Controller that listens on text and binary ports, handling Service Change Requests. Useful for visualizing MGC interactions with the protocol stack.

```text
      cd megaco/examples/simple
      erl -pa ../../../megaco/ebin -s megaco_filter -s megaco
      megaco_simple_mgc:start().
```

--------------------------------

### start()

Source: https://www.erlang.org/doc/apps/megaco/megaco_flex_scanner.md

Starts the flex scanner, locates the library, and loads the linked-in driver. The calling process must be permanent to prevent the driver from unloading.

```APIDOC
## start()

### Description
Starts the flex scanner. It locates the library and loads the linked-in driver. On multi-core systems with a reentrant scanner, multiple ports are created.

### Signature
`start() -> {ok, PortOrPorts} | {error, Reason}`

### Returns
- **{ok, PortOrPorts}** - Success, returns the scanner port or tuple of ports.
- **{error, Reason}** - Failure, returns the error reason.
```
Tokens:
Raw