Moar.Sugar (Moar v2.7.0)

View Source

Syntactic sugar functions.

These functions are intended to be used by importing the functions or the whole module:

import Moar.Sugar, only: [noreply: 1]

def handle_event("foo", _params, socket) do
  socket |> assign(foo: "bar") |> noreply()
end

Summary

Functions

Wraps a term in a :cont tuple. Useful in pipelines.

Unwraps a :cont tuple, raising if the term is not an :cont tuple.

Wraps a term in an :error tuple. Useful in pipelines.

Unwraps an :error tuple, raising if the term is not an :error tuple.

Wraps a term in a :halt tuple. Useful in pipelines.

Unwraps a :halt tuple, raising if the term is not an :halt tuple.

Wraps a term in a :noreply tuple. Useful in pipelines.

Unwraps a :noreply tuple, raising if the term is not an :noreply tuple.

Wraps a term in an :ok tuple. Useful in pipelines.

Unwraps an :ok tuple, raising if the term is not an :ok tuple.

Wraps two terms in a :reply tuple, reversing the terms. Useful in pipelines.

Accepts two arguments and returns the second.

Accepts an argument and passes it into the given function if the condition is truthy.

Functions

cont(term)

@spec cont(term()) :: {:cont, term()}

Wraps a term in a :cont tuple. Useful in pipelines.

iex> %{} |> Map.put(:count, "unknown") |> Moar.Sugar.cont()
{:cont, %{count: "unknown"}}

cont!(arg)

@spec cont!({:cont, term()}) :: term()

Unwraps a :cont tuple, raising if the term is not an :cont tuple.

iex> {:cont, 1} |> Moar.Sugar.cont!()
1

error(term)

@spec error(term()) :: {:error, term()}

Wraps a term in an :error tuple. Useful in pipelines.

iex> %{} |> Map.put(:count, "unknown") |> Moar.Sugar.error()
{:error, %{count: "unknown"}}

error!(arg)

@spec error!({:error, term()}) :: term()

Unwraps an :error tuple, raising if the term is not an :error tuple.

iex> {:error, 1} |> Moar.Sugar.error!()
1

halt(term)

@spec halt(term()) :: {:halt, term()}

Wraps a term in a :halt tuple. Useful in pipelines.

iex> %{} |> Map.put(:count, "unknown") |> Moar.Sugar.halt()
{:halt, %{count: "unknown"}}

halt!(arg)

@spec halt!({:halt, term()}) :: term()

Unwraps a :halt tuple, raising if the term is not an :halt tuple.

iex> {:halt, 1} |> Moar.Sugar.halt!()
1

noreply(term)

@spec noreply(term()) :: {:noreply, term()}

Wraps a term in a :noreply tuple. Useful in pipelines.

iex> %{} |> Map.put(:count, 0) |> Moar.Sugar.noreply()
{:noreply, %{count: 0}}

noreply!(arg)

@spec noreply!({:noreply, term()}) :: term()

Unwraps a :noreply tuple, raising if the term is not an :noreply tuple.

iex> {:noreply, 1} |> Moar.Sugar.noreply!()
1

ok(term)

@spec ok(term()) :: {:ok, term()}

Wraps a term in an :ok tuple. Useful in pipelines.

iex> %{} |> Map.put(:count, 10) |> Moar.Sugar.ok()
{:ok, %{count: 10}}

ok!(arg)

@spec ok!({:ok, term()}) :: term()

Unwraps an :ok tuple, raising if the term is not an :ok tuple.

iex> {:ok, 1} |> Moar.Sugar.ok!()
1

reply(term, message)

@spec reply(term(), term()) :: {:reply, term(), term()}

Wraps two terms in a :reply tuple, reversing the terms. Useful in pipelines.

iex> %{} |> Map.put(:count, 0) |> Moar.Sugar.reply(:ok)
{:reply, :ok, %{count: 0}}

returning(first, second)

@spec returning(any(), any()) :: any()

Accepts two arguments and returns the second.

Useful at the end of the pipeline when you want to return a different value than the last result of the pipeline, such as when the pipeline has side effects.

iex> %{} |> Map.put(:count, 20) |> Moar.Sugar.returning(:count_updated)
:count_updated

then_if(a, truthy, fun)

@spec then_if(term(), term(), (term() -> term())) :: term()

Accepts an argument and passes it into the given function if the condition is truthy.

iex> 1 |> Moar.Sugar.then_if(nil, &(&1 + 1))
1
iex> 1 |> Moar.Sugar.then_if(false, &(&1 + 1))
1

iex> 1 |> Moar.Sugar.then_if("exists", &(&1 + 1))
2