Elixir

https://elixir.hexdocs.pm/1.20.1/
Admin
Elixir provides documentation for the Elixir programming language, detailing its core modules,...
Tokens:1,215,236
Snippets:9,181
Trust Score:9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Agent.start_link examples

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Examples showing successful start_link and a failed start with an exception.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
iex> Agent.get(pid, fn state -> state end)
42

iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise "oops" end)
iex> exception
%RuntimeError{message: "oops"}
```

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

### start example

Source: https://elixir.hexdocs.pm/1.20.1/Node.md

Example of calling Node.start/1 with the :name_domain and :hidden options. Returns {:ok, pid} on success.

```elixir
{:ok, pid} = Node.start(:example, name_domain: :shortnames, hidden: true)
```

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

### Agent.start example

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Example showing how to start an agent with an anonymous function and retrieve its state.

```elixir
iex> {:ok, pid} = Agent.start(fn -> 42 end)
iex> Agent.get(pid, fn state -> state end)
42
```

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

### Usage example of Foo.Bucket in IEx

Source: https://elixir.hexdocs.pm/1.20.1/process-anti-patterns.md

Demonstrates how to use the refactored Foo.Bucket module to start an agent, put values, and get values by key.

```elixir
# start an agent through `Foo.Bucket`
iex> {:ok, bucket} = Foo.Bucket.start_link(%{})
{:ok, #PID<0.114.0>}

# add shared values to the keys `milk` and `beer`
iex> Foo.Bucket.put(bucket, "milk", 3)
iex> Foo.Bucket.put(bucket, "beer", 7)

# access shared data of specific keys
iex> Foo.Bucket.get(bucket, "beer")
7
iex> Foo.Bucket.get(bucket, "milk")
3
```

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

### Start a task with Task.Supervisor.async/2 (scalability example)

Source: https://elixir.hexdocs.pm/1.20.1/Task.Supervisor.md

Shows how to start a task under a named Task.Supervisor using async/2, used in the scalability section as the alternative to partitioning.

```elixir
Task.Supervisor.async(MyApp.TaskSupervisor, fn -> :do_some_work end)
```

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

### Partitioned supervisor start_link example

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Starts a partitioned registry within a supervisor tree.

```elixir
Supervisor.start_link([
  {Registry, keys: :unique, name: MyApp.Registry, partitions: System.schedulers_online()}
], strategy: :one_for_one)
```

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

### Partitioned start_link example

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Starts a partitioned registry for intensive workloads, setting partitions to the number of schedulers.

```elixir
Registry.start_link(
  keys: :unique,
  name: MyApp.Registry,
  partitions: System.schedulers_online()
)
```

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

### Manual start_link example

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Starts the registry manually as a supervisor process.

```elixir
Registry.start_link(keys: :unique, name: MyApp.Registry)
```

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

### Starting a Task.Supervisor under a supervision tree

Source: https://elixir.hexdocs.pm/1.20.1/Task.Supervisor.md

Example showing how to start a Task.Supervisor under a supervision tree using the tuple format.

```elixir
{Task.Supervisor, name: MyApp.TaskSupervisor}
```

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

### Interacting with KV process

Source: https://elixir.hexdocs.pm/1.20.1/processes.md

Shows how to start the KV process and send :get and :put messages. The first example sends a :get for a missing key and flushes the inbox, returning nil.

```elixir
iex> {:ok, pid} = KV.start_link()
{:ok, #PID<0.62.0>}
iex> send(pid, {:get, :hello, self()})
{:get, :hello, #PID<0.41.0>}
iex> flush()
nil
:ok
```

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

### Register a GenServer via Registry using {:via, Registry, ...}

Source: https://elixir.hexdocs.pm/1.20.1/GenServer.md

Shows how to start a local Registry with unique keys, then start a GenServer registered through that registry using a via tuple. The example also demonstrates how to look up the process ID with GenServer.whereis/1, returning a PID.

```elixir
{:ok, _} = Registry.start_link(keys: :unique, name: :stacks)
name = {:via, Registry, {:stacks, "stack 1"}}
{:ok, _pid} = GenServer.start_link(Stack, "hello", name: name)
GenServer.whereis(name)
#=> #PID<0.150.0>
```

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

### Recommended supervised start with child specifications

Source: https://elixir.hexdocs.pm/1.20.1/supervisor-and-application.md

This example shows the recommended way to start a registry inside a supervision tree. It passes a child specification as a {module, options} tuple to Supervisor.start_link. This ensures the registry is supervised and restarted if it fails.

```elixir
  def start(_type, _args) do
    children = [
      {Registry, name: KV, keys: :unique}
    ]

    Supervisor.start_link(children, strategy: :one_for_one)
  end
```

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

### available_compiler_options example

Source: https://elixir.hexdocs.pm/1.20.1/Code.md

Example of calling Code.available_compiler_options/0, showing it returns a list starting with :docs and :debug_info.

```elixir
Code.available_compiler_options()
#=> [:docs, :debug_info, ...]
```

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

### Duplicate key-partitioned start_link example

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Starts a duplicate registry with key-based partitioning for many keys with few subscribers each.

```elixir
Registry.start_link(
  keys: {:duplicate, :key},
  name: MyApp.TopicRegistry,
  partitions: System.schedulers_online()
)
```

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

### Supervisor tree start_link example

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Starts the registry within a supervisor tree.

```elixir
Supervisor.start_link([
  {Registry, keys: :unique, name: MyApp.Registry}
], strategy: :one_for_one)
```

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

### Naive start of registry and supervisor (discouraged)

Source: https://elixir.hexdocs.pm/1.20.1/supervisor-and-application.md

This example shows a naive approach to starting a registry and a supervisor in the start/2 callback. It is discouraged because it starts processes outside a supervision tree, losing the benefits of supervision. The code calls Registry.start_link and Supervisor.start_link separately.

```elixir
  def start(_type, _args) do
    Registry.start_link(name: KV, keys: :unique)
    Supervisor.start_link([], strategy: :one_for_one)
  end
```

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

### Start a Task.Supervisor with a name (scalability example)

Source: https://elixir.hexdocs.pm/1.20.1/Task.Supervisor.md

Shows the child specification for starting a Task.Supervisor with a name, used in the scalability section as the alternative to partitioning.

```elixir
children = [
  {Task.Supervisor, name: MyApp.TaskSupervisor}
]
```

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

### Calling start_link/1 directly

Source: https://elixir.hexdocs.pm/1.20.1/Task.Supervisor.md

Example showing how to start a Task.Supervisor by calling start_link/1 directly. Recommended only for scripting and should be avoided in production code.

```elixir
Task.Supervisor.start_link(name: MyApp.TaskSupervisor)
```

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

### Agent.update/3 example

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Shows how to start an agent with state 42, update it to 43, and then retrieve the new state.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
iex> Agent.update(pid, fn state -> state + 1 end)
:ok
iex> Agent.get(pid, fn state -> state end)
43
```

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

### Agent.get_and_update/3 example

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Example of using Agent.get_and_update/3. Starts an agent with state 42, gets and updates the state to 43, then retrieves the new state.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)
42
iex> Agent.get(pid, fn state -> state end)
43
```

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

### Agent.cast/2 example with anonymous function

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Example of using Agent.cast/2 with an anonymous function. Starts an agent with state 42, casts a function that increments the state, and then gets the state to verify it is 43.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
iex> Agent.cast(pid, fn state -> state + 1 end)
:ok
iex> Agent.get(pid, fn state -> state end)
43
```

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

### Supervision tree for task supervisor and GenServer

Source: https://elixir.hexdocs.pm/1.20.1/Task.md

Supervision tree setup that starts the task supervisor and the GenServer example together.

```elixir
children = [
  {Task.Supervisor, name: MyApp.TaskSupervisor},
  {GenServerTaskExample, name: MyApp.GenServerTaskExample}
]

Supervisor.start_link(children, strategy: :one_for_one)
```

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

### Agent.cast/4 example with module and arguments

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Example of using Agent.cast/4 with a module, function, and arguments. Starts an agent with state 42, casts Kernel.+/2 with argument 12, and then gets the state to verify it is 54.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
iex> Agent.cast(pid, Kernel, :+, [12])
:ok
iex> Agent.get(pid, fn state -> state end)
54
```

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

### Define a supervised GenServer counter

Source: https://elixir.hexdocs.pm/1.20.1/Supervisor.md

Defines a GenServer-based counter process that is supervised in the examples. It starts with an integer argument, handles :get and {:bump, value} calls, and registers itself with the name Counter.

```elixir
defmodule Counter do
  use GenServer

  def start_link(arg) when is_integer(arg) do
    GenServer.start_link(__MODULE__, arg, name: __MODULE__)
  end

  ## Callbacks

  @impl true
  def init(counter) do
    {:ok, counter}
  end

  @impl true
  def handle_call(:get, _from, counter) do
    {:reply, counter, counter}
  end

  def handle_call({:bump, value}, _from, counter) do
    {:reply, counter, counter + value}
  end
end
```

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

### Enum.slice/3 examples

Source: https://elixir.hexdocs.pm/1.20.1/Enum.md

Interactive examples for Enum.slice/3. They show slicing with a positive start index, taking more elements than available, zero amount, negative start indices, and an out-of-bounds start index.

```elixir
iex> Enum.slice(1..100, 5, 10)
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
```

```elixir
# amount to take is greater than the number of elements
iex> Enum.slice(1..10, 5, 100)
[6, 7, 8, 9, 10]
```

```elixir
iex> Enum.slice(1..10, 5, 0)
[]
```

```elixir
# using a negative start index
iex> Enum.slice(1..10, -6, 3)
[5, 6, 7]
iex> Enum.slice(1..10, -11, 5)
[1, 2, 3, 4, 5]
```

```elixir
# out of bound start index
iex> Enum.slice(1..10, 10, 5)
[]
```

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

### mkdir! success example

Source: https://elixir.hexdocs.pm/1.20.1/File.md

Example of mkdir! successfully creating a directory.

```elixir
File.mkdir!("test/unit")
#=> :ok
```

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

### System.build_info/0 example

Source: https://elixir.hexdocs.pm/1.20.1/System.md

Example output of System.build_info/0 in an IEx session, showing the returned map with build, date, otp_release, revision, and version fields.

```elixir
iex> System.build_info()
%{
  build: "1.9.0-dev (772a00a0c) (compiled with Erlang/OTP 21)",
  date: "2018-12-24T01:09:21Z",
  otp_release: "21",
  revision: "772a00a0c",
  version: "1.9.0-dev"
}
```

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

### Naming a bucket with an atom in IEx

Source: https://elixir.hexdocs.pm/1.20.1/supervisor-and-application.md

Shows how to start a bucket with a name and then use that name to put and get values. The example uses an atom for the name, which the surrounding text warns against for user input because atoms are not garbage collected.

```elixir
iex> KV.Bucket.start_link(name: :shopping)
{:ok, #PID<0.43.0>}
iex> KV.Bucket.put(:shopping, "milk", 1)
:ok
iex> KV.Bucket.get(:shopping, "milk")
1
```

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

### MapSet.size/1 example

Source: https://elixir.hexdocs.pm/1.20.1/MapSet.md

Example of getting the number of elements in a MapSet.

```elixir
iex> MapSet.size(MapSet.new([1, 2, 3]))
3
```

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

### Enum.reduce/3 examples

Source: https://elixir.hexdocs.pm/1.20.1/Enum.md

Examples of Enum.reduce/3 with a list and a map, both starting with accumulator 0.

```elixir
iex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end)
6
```

```elixir
iex> Enum.reduce(%{a: 2, b: 3, c: 4}, 0, fn {_key, val}, acc -> acc + val end)
9
```

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

### Date.day_of_week/2 examples with Sunday start

Source: https://elixir.hexdocs.pm/1.20.1/Date.md

Examples showing day of week when starting_on is :sunday.

```elixir
# 2016-10-31 is a Monday but, as we start the week on Sunday, now it returns 2
iex> Date.day_of_week(~D[2016-10-31], :sunday)
2
iex> Date.day_of_week(~D[2016-11-01], :sunday)
3
iex> Date.day_of_week(~N[2016-11-01 01:23:45], :sunday)
3
iex> Date.day_of_week(~D[-0015-10-30], :sunday)
4
```

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

### Example config/runtime.exs for :my_app

Source: https://elixir.hexdocs.pm/1.20.1/Application.md

Sample configuration for an OTP application :my_app, defining two database repositories and a list of them. Used to illustrate how get_env/3 reads configuration from the application environment.

```elixir
config :my_app, Databases.RepoOne,
  # A database configuration
  ip: "localhost",
  port: 5433

config :my_app, Databases.RepoTwo,
  # Another database configuration (for the same OTP app)
  ip: "localhost",
  port: 20_717

config :my_app, my_app_databases: [Databases.RepoOne, Databases.RepoTwo]
```

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

### beginning_of_week examples

Source: https://elixir.hexdocs.pm/1.20.1/Date.md

Examples of Date.beginning_of_week/2 with default Monday start and custom starting_on values.

```elixir
iex> Date.beginning_of_week(~D[2020-07-11])
~D[2020-07-06]
iex> Date.beginning_of_week(~D[2020-07-06])
~D[2020-07-06]
iex> Date.beginning_of_week(~D[2020-07-11], :sunday)
~D[2020-07-05]
iex> Date.beginning_of_week(~D[2020-07-11], :saturday)
~D[2020-07-11]
iex> Date.beginning_of_week(~N[2020-07-11 01:23:45])
~D[2020-07-06]
```

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

### Process.demonitor/2 example

Source: https://elixir.hexdocs.pm/1.20.1/Process.md

Demonstrates how to create a process, monitor it, and then demonitor it. The demonitor call returns true.

```elixir
pid = spawn(fn -> 1 + 2 end)
ref = Process.monitor(pid)
Process.demonitor(ref)
#=> true
```

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

### Start an application with Application.ensure_all_started/1

Source: https://elixir.hexdocs.pm/1.20.1/Application.md

Manually starts an application and all of its dependencies. Returns {:ok, pid} or {:ok, pid, state} on success.

```elixir
{:ok, _} = Application.ensure_all_started(:some_app)
```

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

### bit_size/1 examples

Source: https://elixir.hexdocs.pm/1.20.1/Kernel.html

Examples of getting the bit size of bitstrings with different bit lengths.

```elixir
iex> bit_size(<<433::16, 3::3>>)
19

iex> bit_size(<<1, 2, 3>>)
24
```

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

### Starting a single bucket in start/2

Source: https://elixir.hexdocs.pm/1.20.1/dynamic-supervisor.md

Shows a naive approach to starting a single bucket in the application's start/2 callback. This works but only starts one bucket, which is insufficient for dynamic creation.

```elixir
children = [
  {Registry, name: KV, keys: :unique}
  {KV.Bucket, name: {:via, Registry, {KV, "shopping"}}}
]
```

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

### Stream.with_index/2 with offset example

Source: https://elixir.hexdocs.pm/1.20.1/Stream.md

Example of Stream.with_index/2 with an integer offset of 3, starting indices from that offset.

```elixir
iex> stream = Stream.with_index([1, 2, 3], 3)
iex> Enum.to_list(stream)
[{1, 3}, {2, 4}, {3, 5}]
```

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

### ensure_all_loaded/1 success example

Source: https://elixir.hexdocs.pm/1.20.1/Code.md

Example showing successful loading of existing modules, returning :ok.

```elixir
iex> Code.ensure_all_loaded([Atom, String])
:ok
```

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

### Access.all/0 examples with get_in, get_and_update_in, and pop_in

Source: https://elixir.hexdocs.pm/1.20.1/Access.md

Examples showing how to use Access.all() with Kernel.get_in/2, get_and_update_in/3, and pop_in/2 to access, update, and pop all elements in a list.

```elixir
iex> list = [%{name: "john"}, %{name: "mary"}]
iex> get_in(list, [Access.all(), :name])
["john", "mary"]
iex> get_and_update_in(list, [Access.all(), :name], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
iex> pop_in(list, [Access.all(), :name])
{["john", "mary"], [%{}, %{}]}
```

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

### Start duplicate registry Registry.DispatcherTest

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Starts a duplicate-key registry named Registry.DispatcherTest for the dispatcher example.

```elixir
{:ok, _} = Registry.start_link(keys: :duplicate, name: Registry.DispatcherTest)
```

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

### `start`

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Documentation for the `start/2` function in the Agent module.

```APIDOC
## `start`

### Description
Starts an agent process without links (outside of a supervision tree). See `start_link/2` for more information.

### Signature
```elixir
@spec start((-&gt; term()), GenServer.options()) :: on_start()
```

### Parameters
- **fun** ((-&gt; term())) - Required - The function that returns the initial agent state.
- **options** (GenServer.options()) - Required - Options for the agent.

### Return Value
- **on_start()** - The result of starting the agent.

### Examples
```elixir
iex> {:ok, pid} = Agent.start(fn -> 42 end)
iex> Agent.get(pid, fn state -> state end)
42
```
```

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

### Stream.unfold/2 infinite stream examples

Source: https://elixir.hexdocs.pm/1.20.1/Stream.md

Two examples of Stream.unfold/2 that generate infinite streams. The first increments by 1 starting at 0, and the second doubles starting at 1. Both use Enum.take/2 to limit the output to 10 elements.

```elixir
iex> Stream.unfold(0, fn
...>   n -> {n, n + 1}
...> end) |> Enum.take(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

```elixir
iex> Stream.unfold(1, fn
...>   n -> {n, n * 2}
...> end) |> Enum.take(10)
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
```

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

### Example of File.cd/1 with existing directory

Source: https://elixir.hexdocs.pm/1.20.1/File.md

Example showing File.cd/1 returning :ok when the directory exists.

```elixir
File.cd("bin")
#=> :ok

```

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

### binary_part/3 negative size example

Source: https://elixir.hexdocs.pm/1.20.1/index.html

Example of using a negative size with binary_part/3 to extract bytes before the start position.

```elixir
iex> binary_part("Hello", 5, -3)
"llo"
```

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

### Start release node with NODES, PORT, and RELEASE_NODE

Source: https://elixir.hexdocs.pm/1.20.1/releases.md

Starts the release with the given node list, port, and release node name. Adjust @computer-name to your actual computer name.

```console
$ NODES="foo@computer-name,bar@computer-name" PORT=4040 RELEASE_NODE="foo" bin/kv start_iex
```

```console
$ NODES="foo@computer-name,bar@computer-name" PORT=4041 RELEASE_NODE="bar" bin/kv start_iex
```

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

### Registry.meta/2 example

Source: https://elixir.hexdocs.pm/1.20.1/Registry.md

Example usage of Registry.meta/2. Starts a unique registry with metadata and reads both an existing and a missing key.

```elixir
iex> Registry.start_link(keys: :unique, name: Registry.MetaTest, meta: [custom_key: "custom_value"])
iex> Registry.meta(Registry.MetaTest, :custom_key)
{:ok, "custom_value"}
iex> Registry.meta(Registry.MetaTest, :unknown_key)
:error
```

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

### Enum.slice/2 out-of-bounds start example

Source: https://elixir.hexdocs.pm/1.20.1/Enum.md

Example of Enum.slice/2 returning an empty list when the first position is after the end of the enumerable.

```elixir
iex> Enum.slice([1, 2, 3, 4, 5], 6..10)
[]
```

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

### Process.spawn/2 examples with :monitor and :link options

Source: https://elixir.hexdocs.pm/1.20.1/Process.md

Shows two calls to Process.spawn/2 with different options. The first uses :monitor and returns a tuple with PID and reference; the second uses :link and returns just the PID.

```elixir
Process.spawn(fn -> 1 + 2 end, [:monitor])
#=> {#PID<0.93.0>, #Reference<0.18808174.1939079169.202418>}
Process.spawn(fn -> 1 + 2 end, [:link])
#=> #PID<0.95.0>
```

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

### start_child example

Source: https://elixir.hexdocs.pm/1.20.1/Task.Supervisor.md

Example of starting a task with Task.Supervisor.start_child/3, which runs a function in a task under the supervisor without linking to the caller.

```elixir
Task.Supervisor.start_child(MyTaskSupervisor, fn ->
  IO.puts("I am running in a task")
end)
```

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

### Date.day_of_week/2 examples with default Monday start

Source: https://elixir.hexdocs.pm/1.20.1/Date.md

Examples showing day of week with default Monday as first day.

```elixir
# 2016-10-31 is a Monday and by default Monday is the first day of the week
iex> Date.day_of_week(~D[2016-10-31])
1
iex> Date.day_of_week(~D[2016-11-01])
2
iex> Date.day_of_week(~N[2016-11-01 01:23:45])
2
iex> Date.day_of_week(~D[-0015-10-30])
3
```

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

### File.ln_s!/2 success example

Source: https://elixir.hexdocs.pm/1.20.1/File.md

Example of File.ln_s!/2 creating a symbolic link and returning :ok.

```elixir
File.ln_s!("hello.txt", "link_to_hello")
#=> :ok
```

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

### mkdir_p examples

Source: https://elixir.hexdocs.pm/1.20.1/File.md

Shows successful creation of a directory with missing parents and a failure due to insufficient permissions.

```elixir
File.mkdir_p("non/existing/parents")
#=> :ok

File.mkdir_p("/usr/sbin/temp")
#=> {:error, :eperm}
```

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

### File.cd!/1 examples

Source: https://elixir.hexdocs.pm/1.20.1/File.md

Examples for File.cd!/1: successful change to "bin" returns :ok; changing to a non-existing directory raises a File.Error exception.

```elixir
File.cd!("bin")
#=> :ok
```

```elixir
File.cd!("non_existing_dir")
** (File.Error) could not set current working directory to "non_existing_dir": no such file or directory
```

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

### iterate/2 example

Source: https://elixir.hexdocs.pm/1.20.1/Stream.md

Example showing iterate/2 doubling each value starting from 1, producing the first five powers of two.

```elixir
iex> Stream.iterate(1, &(&1 * 2)) |> Enum.take(5)
[1, 2, 4, 8, 16]
```

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

### Agent.get/3 example

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Example of using Agent.get/3 with an anonymous function. Starts an agent with state 42 and retrieves the state, returning 42.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
iex> Agent.get(pid, fn state -> state end)
42
```

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

### Start child on single DynamicSupervisor

Source: https://elixir.hexdocs.pm/1.20.1/PartitionSupervisor.md

Shows how to start a child on the single DynamicSupervisor directly.

```elixir
DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Agent, fn -> %{} end})
```

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

### Enum.slice/2 increasing range example

Source: https://elixir.hexdocs.pm/1.20.1/Enum.md

Example of Enum.slice/2 with an increasing range where start is greater than stop, requiring the explicit //1 step marker.

```elixir
iex> Enum.slice([1, 2, 3, 4, 5], 1..-2//1)
[2, 3, 4]
```

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

### Module-based supervisor init/1 example

Source: https://elixir.hexdocs.pm/1.20.1/Supervisor.md

Example of a module-based supervisor's init/1 callback using Supervisor.init/2 with a list of children and the :one_for_one strategy.

```elixir
def init(_init_arg) do
  children = [
    {Counter, 0}
  ]

  Supervisor.init(children, strategy: :one_for_one)
end
```

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

### binary_slice/3 examples with positive start and size

Source: https://elixir.hexdocs.pm/1.20.1/Kernel.html

Shows basic usage of binary_slice/3 with positive start and size values, returning the sliced binary.

```elixir
iex> binary_slice("elixir", 0, 6)
"elixir"
iex> binary_slice("elixir", 0, 5)
"elixi"
iex> binary_slice("elixir", 1, 4)
"lixi"
iex> binary_slice("elixir", 0, 10)
"elixir"
```

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

### Start child via PartitionSupervisor

Source: https://elixir.hexdocs.pm/1.20.1/PartitionSupervisor.md

Shows how to start a child on a DynamicSupervisor through the PartitionSupervisor using a via tuple with self() as the routing key.

```elixir
DynamicSupervisor.start_child(
  {:via, PartitionSupervisor, {MyApp.DynamicSupervisors, self()}},
  {Agent, fn -> %{} end}
)
```

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

### Stream.scan/3 example with explicit accumulator

Source: https://elixir.hexdocs.pm/1.20.1/Stream.md

Example of Stream.scan/3 using 0 as the starting accumulator. The function adds each element to the accumulator, producing a running sum.

```elixir
iex> stream = Stream.scan(1..5, 0, &(&1 + &2))
iex> Enum.to_list(stream)
[1, 3, 6, 10, 15]
```

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

### Agent example for state

Source: https://elixir.hexdocs.pm/1.20.1/processes.md

Shows how to use Agent.start_link/1, Agent.update/3, and Agent.get/2 to manage state. The example stores and retrieves a value in a map.

```elixir
iex> {:ok, pid} = Agent.start_link(fn -> %{} end)
{:ok, #PID<0.72.0>}
iex> Agent.update(pid, fn map -> Map.put(map, :hello, :world) end)
:ok
iex> Agent.get(pid, fn map -> Map.get(map, :hello) end)
:world
```

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

### Stream.map_every/3 example with nth = 2

Source: https://elixir.hexdocs.pm/1.20.1/Stream.md

Example usage of Stream.map_every/3 with nth = 2. It doubles every second element, starting with the first, and converts to a list.

```elixir
iex> stream = Stream.map_every(1..10, 2, fn x -> x * 2 end)
iex> Enum.to_list(stream)
[2, 2, 6, 4, 10, 6, 14, 8, 18, 10]
```

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

### `start`

Source: https://elixir.hexdocs.pm/1.20.1/Agent.md

Documentation for the `start/4` function in the Agent module.

```APIDOC
## `start`

### Description
Starts an agent without links with the given module, function, and arguments. See `start_link/4` for more information.

### Signature
```elixir
@spec start(module(), atom(), [term()], GenServer.options()) :: on_start()
```

### Parameters
- **module** (module()) - Required - The module containing the function to call.
- **function** (atom()) - Required - The function to call.
- **args** ([term()]) - Required - Additional arguments to pass to the function.
- **options** (GenServer.options()) - Required - Options for the agent.

### Return Value
- **on_start()** - The result of starting the agent.
```

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

### File.ls!/1 success example

Source: https://elixir.hexdocs.pm/1.20.1/File.md

Example of File.ls!/1 returning a list of files in a directory.

```elixir
File.ls!("bin")
#=> ["iex", "elixir"]
```

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

### Start supervised KV.Bucket and use it

Source: https://elixir.hexdocs.pm/1.20.1/dynamic-supervisor.md

Starts a supervisor with a single KV.Bucket child using the {module, options} format, then puts and gets a value from the named bucket.

```elixir
iex> children = [{KV.Bucket, name: :shopping}]
iex> Supervisor.start_link(children, strategy: :one_for_one)
iex> KV.Bucket.put(:shopping, "milk", 1)
:ok
iex> KV.Bucket.get(:shopping, "milk")
1
```
Tokens:
Raw