Gettext Sigils

https://hexdocs.pm/gettext_sigils/
Admin
Gettext Sigils is an Elixir library providing a ~t sigil for Gettext translations with automatic...
Tokens:9,027
Snippets:115
Trust Score:9
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install Gettext Sigils

Source: https://hexdocs.pm/gettext_sigils/readme.md

Installation commands for the library using igniter or manual dependency addition.

```bash
mix igniter.install gettext_sigils
```

```elixir
def deps do
  [
    {:gettext_sigils, "~> 0.5.0"}
  ]
end
```

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

### Example agent prompts

Source: https://hexdocs.pm/gettext_sigils/llm.md

Sample prompts for triggering localization-aware code generation.

```text
user: create a simple todo app
```

```text
user: translate the user list page
```

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

### Install Gettext Sigils via Igniter

Source: https://hexdocs.pm/gettext_sigils/index.html

Use the igniter task to automatically install and configure the library.

```elixir
mix igniter.install gettext_sigils
```

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

### Basic Modifier Examples

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Demonstrates single-letter modifiers for overriding Gettext domain, pluralization, and transforming output.

```elixir
~t"Not found"e               # override the Gettext domain
~t"#{count} error(s)"N       # pluralize
~t"hello"u                   # transform the result (e.g. upcase)
```

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

### Install Gettext Sigils

Source: https://hexdocs.pm/gettext_sigils/Mix.Tasks.GettextSigils.Install.md

Run this command in your project's root directory to replace `use Gettext` with `use GettextSigils` in modules that use a Gettext backend. It finds modules with `use Gettext, backend: MyApp.Gettext` and updates them.

```shell
mix gettext_sigils.install
```

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

### GettextSigils Translation Example

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.md

Demonstrates the usage of the ~t sigil for Gettext translations with automatic interpolation. This sigil simplifies the process of creating translatable strings that include dynamic values.

```Elixir
~t"Hello, #{user.name}!"
# => gettext("Hello, %{user_name}!", user_name: user.name)
```

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

### HTML-safe output modifier

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Example of wrapping strings in Phoenix.HTML.raw/1 for safe rendering.

```elixir
defmodule MyApp.RawModifier do
  use GettextSigils.Modifier

  @impl true
  def postprocess(string, _opts) do 
    {:ok, Phoenix.HTML.raw(string)}
  end
end
```

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    modifiers: [
      r: MyApp.RawModifier
    ]
  ]

~t"<em>important</em>"r
# => {:safe, "<em>important</em>"}
```

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

### Chained Modifier Examples

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Shows how multiple modifiers can be chained together, applying their effects from left to right.

```elixir
~t"Oops"em                   # override domain AND context
~t"#{count} error(s)"eN      # override domain AND pluralize
```

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

### Markdown postprocessing modifier

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Example of using MDEx to render translated strings as HTML.

```elixir
defmodule MyApp.MarkdownModifier do
  use GettextSigils.Modifier

  @impl true
  def postprocess(string, opts) do
    MDEx.to_html(string, opts)
  end
end
```

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    modifiers: [
      m: {MyApp.MarkdownModifier, extension: [strikethrough: true]}
    ]
  ]

~t"**bold** and ~~struck~~"m
# => {:ok, "<p><strong>bold</strong> and <del>struck</del></p>\n"}
```

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

### Runtime String Transformation

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Example of using a modifier 'u' to transform the final translated string at runtime, such as uppercasing it.

```elixir
# a modifier that uppercases the result
~t"hello"u
# => String.upcase(dpgettext("default", nil, "hello", []))
# => "HELLO"
```

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

### Translator-provided forms for custom modifier

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

Example of how singular and plural forms are presented in the .po file when using a custom pluralization modifier that splits the msgid.

```pot
msgid "One error"
msgid_plural "%{count} errors"
msgstr[0] "One error"
msgstr[1] "%{count} errors"
```

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

### Translator-provided plural forms in .po file

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

Example of how translators define singular and plural forms for a message in a .po file when using the 'N' modifier.

```pot
msgid "%{count} error(s)"
msgid_plural "%{count} error(s)"
msgstr[0] "One error"
msgstr[1] "%{count} errors"
```

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

### Configuring custom pluralization modifiers

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

Example of wiring up a custom pluralization modifier ('n' and 'p') in GettextSigils, including default and custom separator options.

```elixir
defmodule MyApp.Frontend do
  use GettextSigils,
    backend: MyApp.Gettext,
    sigils: [
      modifiers: [
        n: MyApp.SplitPluralModifier,
        p: {MyApp.SplitPluralModifier, separator: " :: "}
      ]
    ]

  def error_count(count), do: ~t"One error|#{count} errors"n
  def user_count(count), do: ~t"One user :: #{count} users"p
end
```

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

### Configure GettextSigils skills in mix.exs

Source: https://hexdocs.pm/gettext_sigils/llm.md

Include the package_skills configuration to allow agents to discover and utilize GettextSigils localization skills.

```elixir
defp usage_rules do
  [
    file: "AGENTS.md",
    usage_rules: [
      :gettext_sigils
    ],
    skills: [
      package_skills: [:gettext_sigils]
    ]
  ]
end
```

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

### Basic Sigil Usage

Source: https://hexdocs.pm/gettext_sigils/index.html

Demonstrates using the ~t sigil as a direct replacement for the gettext macro.

```elixir
~t"Hello, World!"
# same as
gettext("Hello, World!")
```

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

### Configure Module Usage

Source: https://hexdocs.pm/gettext_sigils/index.html

Replace the standard Gettext usage with GettextSigils in your modules.

```elixir
# replace this
use Gettext, backend: MyApp.Gettext

# with this
use GettextSigils, backend: MyApp.Gettext
```

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

### Configure GettextSigils with Options

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Options.md

Use this snippet to configure GettextSigils with a backend, default domain, context, and custom modifiers for the ~t sigil. Modifiers can be static keyword lists or module tuples.

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    domain: "default",
    context: "dashboard",
    modifiers: [
      e: [domain: "errors"],
      a: [context: "admin"]
    ]
  ]
```

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

### Set Default Domain and Context

Source: https://hexdocs.pm/gettext_sigils/index.html

Configure default domain and context settings for all sigils within a module.

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    domain: "frontend",
    context: "dashboard"
  ]

~t"Welcome"   # => dpgettext(MyApp.Gettext, "frontend", "dashboard", "Welcome")
```

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

### Compare Gettext and Gettext Sigils

Source: https://hexdocs.pm/gettext_sigils/index.html

Shows the syntax difference between standard Gettext macros and the ~t sigil.

```elixir
# before
gettext("Hello, %{name}", name: user.name)

# after
~t"Hello, #{user.name}"
```

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

### Add Dependency Manually

Source: https://hexdocs.pm/gettext_sigils/index.html

Add the package to your mix.exs file.

```elixir
def deps do
  [
    {:gettext_sigils, "~> 0.5.0"}
  ]
end
```

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

### Configure GettextSigils in modules

Source: https://hexdocs.pm/gettext_sigils/readme.md

Replace standard Gettext usage with GettextSigils to enable the ~t sigil.

```elixir
# replace this
use Gettext, backend: MyApp.Gettext

# with this
use GettextSigils, backend: MyApp.Gettext
```

```elixir
~t"Hello, World!"
# same as
gettext("Hello, World!")
```

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

### Configure GettextSigils in mix.exs

Source: https://hexdocs.pm/gettext_sigils/llm.md

Add the gettext_sigils rule to your usage_rules configuration to enable agent awareness of the ~t sigil.

```elixir
defp usage_rules do
  [
    file: "AGENTS.md",
    usage_rules: [
      :gettext_sigils
    ]
  ]
end
```

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

### Using GettextSigils in a Module

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.md

Shows how to integrate GettextSigils into an Elixir module by replacing the standard `use Gettext` with `use GettextSigils`. This enables the custom sigils and allows for configuration of the backend and sigil options.

```Elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    # ...
  ]
```

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

### Defining Custom Keyword-List Modifiers

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Shows how to define custom modifiers using keyword lists for domain and context overrides within a module.

```elixir
defmodule MyApp.Frontend do
  use GettextSigils,
    backend: MyApp.Gettext,
    sigils: [
      domain: "frontend",
      modifiers: [
        e: [domain: "errors"],
        g: [domain: :default, context: nil],
        m: [context: inspect(__MODULE__)]
      ]
    ]

  def example do
    ~t"Welcome"           # domain: "frontend", context: nil
    ~t"Yes"g              # domain: :default,   context: nil
    ~t"Not found"e        # domain: "errors",   context: nil
    ~t"Hello"m            # domain: "frontend", context: "MyApp.Frontend"
    ~t"Oops"em            # domain: "errors",   context: "MyApp.Frontend"
  end
end
```

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

### Basic Interpolation with ~t Sigil

Source: https://hexdocs.pm/gettext_sigils/interpolation.md

Use the ~t sigil for string interpolation. It parses expressions into Gettext \"%%{key}\" placeholders and a keyword list of bindings at compile time.

```elixir
~t"The #{fruit.name} is #{color}"
# => gettext("The %{fruit_name} is %{color}", fruit_name: fruit.name, color: color)
```

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

### GettextSigils.Options

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Options.md

Validates `:sigils` options passed to `use GettextSigils`. All other options are passed through to `use Gettext`.

```APIDOC
## GettextSigils.Options

### Description
Validates `:sigils` options passed to `use GettextSigils`. All other options are passed through to `use Gettext`.

### Options

* `:domain` - Default Gettext domain within the module that is using `GettextSigils`. Use the `:default` atom to follow the backend's configured default domain, or a binary to override.

* `:context` - Default Gettext context within the module that is using `GettextSigils`. May be `nil` (the default) or a binary.

* `:modifiers` - A keyword list of options applied when using the `~t` sigil with modifiers.

  The key has to be an atom between `:a` and `:z`. Uppercase modifiers are used by the library (eg. `N` for pluralization).

  Each entry can be a static keyword list, a module atom, or a `{module, opts}` tuple.
  The keyword-list form is shorthand for the built-in `GettextSigils.Modifiers.KeywordModifier`, whose options are:

    * `:domain` - Gettext domain. Use the `:default` atom to select the backend's configured default domain, or a binary to override.

    * `:context` - Gettext context. Use `nil` to clear the context, or a binary to override.

  The default value is `[]`.

### Example

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    domain: "default",
    context: "dashboard",
    modifiers: [
      e: [domain: "errors"],
      a: [context: "admin"]
    ]
  ]
```
```

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

### Explicit Key Assignment with ~t Sigil

Source: https://hexdocs.pm/gettext_sigils/interpolation.md

Use the \"key = expr\" syntax to explicitly set the binding key. This is useful for disambiguation, when derived keys are not meaningful, or for translator-friendly names. The left-hand side must be a plain variable.

```elixir
~t"Order status: #{status = order_status(resp[field])}"
# => gettext("Order status: %{status}", status: order_status(resp[field]))
```

```elixir
~t"Valid: #{x = Foo.bar()} != #{y = foo.bar}"
# => gettext("Valid: %{x} != %{y}", x: Foo.bar(), y: foo.bar)
```

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

### Configure and use modifiers

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Register modifiers in the sigils configuration and apply them using sigil suffixes.

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    domain: "frontend",
    modifiers: [
      u: MyApp.UpcaseModifier,
      s: {MyApp.ShoutModifier, intensity: 3}
    ]
  ]

~t"hello"u    # => "HELLO"
~t"hello"s    # => "hello!!!"
~t"hello"us   # => "HELLO!!!"   (upcase runs first, then shout)
```

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

### Implement GettextSigils.Modifier

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Define custom transformation logic by implementing the postprocess/2 callback.

```elixir
defmodule MyApp.UpcaseModifier do
  use GettextSigils.Modifier

  @impl true
  def postprocess(string, _opts), do: {:ok, String.upcase(string)}
end

defmodule MyApp.ShoutModifier do
  use GettextSigils.Modifier

  @impl true
  def postprocess(string, opts) do
    marks = String.duplicate("!", Keyword.get(opts, :intensity, 1))
    {:ok, string <> marks}
  end
end
```

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

### parse!/1

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Interpolation.md

Parses the AST of a ~t sigil to produce a Gettext-compatible message ID and binding list.

```APIDOC
## parse!(ast)

### Description
Parses the AST of a `~t` sigil and produces a Gettext `msgid` string (with `%{key}` placeholders) and a keyword list of bindings.

### Parameters
#### Arguments
- **ast** (AST) - Required - The abstract syntax tree of the `~t` sigil to be parsed.

### Response
- **msgid** (String) - The resulting Gettext message ID with interpolated placeholders.
- **bindings** (Keyword List) - A list of key-value pairs representing the interpolated expressions.
```

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

### GettextSigils Schema

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifiers.KeywordModifier.md

Exposes the NimbleOptions schema for the modifier's options, allowing for integration into the top-level schema documentation.

```APIDOC
## schema

```elixir
@spec schema() :: NimbleOptions.t()
```

### Description
Returns the `NimbleOptions` schema for this modifier's opts. Exposed so that `GettextSigils.Options` can interpolate the rendered docs into its top-level schema docstring without duplicating the schema definition.
```

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

### Type definitions

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifier.md

Core type definitions used within the GettextSigils library.

```elixir
@type bindings() :: keyword()
```

```elixir
@type context() :: binary() | nil
```

```elixir
@type domain() :: binary() | :default | nil
```

```elixir
@type domain_context() :: {domain(), context()}
```

```elixir
@type input() :: {msgid(), bindings()}
```

```elixir
@type msgid() :: binary()
```

```elixir
@type opts() :: keyword()
```

```elixir
@type pluralized() :: input() | {msgid(), msgid(), Macro.t(), bindings()}
```

```elixir
@type reason() :: String.t() | Exception.t()
```

```elixir
@type result(value) :: {:ok, value} | {:error, reason()}
```

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

### Ambiguous Key Handling with ~t Sigil

Source: https://hexdocs.pm/gettext_sigils/interpolation.md

Duplicate keys referring to the same expression are allowed and appear only once in the emitted call. If the same key maps to different expressions, an ArgumentError is raised at compile time.

```elixir
~t"#{name} is #{name}"
# => gettext("%{name} is %{name}", name: name)
```

```elixir
~t"This is invalid: #{Foo.bar()} != #{foo.bar}"
# => ** (ArgumentError) ambiguous interpolation key "foo_bar" ...
```

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

### Modifier callbacks

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifier.md

Callback signatures for the GettextSigils.Modifier behaviour.

```elixir
@callback domain_context(input(), opts(), domain_context()) :: result(domain_context())
```

```elixir
@callback init(opts()) :: result(opts())
```

```elixir
@callback pluralize(input(), opts()) :: result(pluralized())
```

```elixir
@callback postprocess(String.t(), opts()) :: result(term())
```

```elixir
@callback preprocess(input(), opts()) :: result(input())
```

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

### validate!

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Options.md

Validates the given options or raises a `NimbleOptions.ValidationError` if invalid. After validation, the `:modifiers` keyword list is converted into a map keyed by the character code of each modifier letter.

```APIDOC
## validate!

### Description
Validates the given options or raises a `NimbleOptions.ValidationError` if invalid.

After validation, the `:modifiers` keyword list is converted into a map keyed by
the character code of each modifier letter (e.g. `?e` instead of `:e`) so that
modifier lookup can do a direct `Map.fetch/2` against the sigil charlist without
re-converting characters to atoms on every expansion.

### Type Specification

```elixir
@spec validate!(keyword()) :: keyword() | no_return()
```
```

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

### Retrieve NimbleOptions schema for KeywordModifier

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifiers.KeywordModifier.md

Returns the NimbleOptions schema definition used for validating modifier options.

```elixir
@spec schema() :: NimbleOptions.t()
```

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

### Validate GettextSigils Options

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Options.md

The validate! function checks the provided options for correctness and raises a NimbleOptions.ValidationError if any are invalid. It transforms the :modifiers keyword list into a map for efficient lookup.

```elixir
@spec validate!(keyword()) :: keyword() | no_return()
```

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

### Custom pluralization modifier implementation

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

A custom modifier module implementing the 'pluralize/2' callback to split msgids into singular and plural forms based on a separator.

```elixir
defmodule MyApp.SplitPluralModifier do
  use GettextSigils.Modifier

  @schema NimbleOptions.new!(
    separator: [
      type: :string,
      default: "|",
      doc: "Separator between singular and plural forms in the msgid."
    ]
  )

  @impl true
  def init(opts), do: NimbleOptions.validate(opts, @schema)

  @impl true
  def pluralize({msgid, bindings}, opts) do
    case Keyword.pop(bindings, :count) do
      {nil, _} ->
        {:error, ~s|`n` modifier requires a "count" binding|}

      {count, remaining} ->
        separator = Keyword.fetch!(opts, :separator)

        case String.split(msgid, separator, parts: 2) do
          [singular, plural] ->
            {:ok, {singular, plural, count, remaining}}

          _ ->
            {:error, ~s|`n` modifier requires msgid in the form "singular#{separator}plural"|}
        end
    end
  end
end
```

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

### PluralModifier Logic

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifiers.PluralModifier.md

Details on how the PluralModifier processes bindings for pluralization.

```APIDOC
## PluralModifier Logic

### Description
Implements the N sigil modifier's pluralization logic. It checks for the presence of :count in the bindings to determine the appropriate translation function call.

### Behavior
- If :count is present: Returns {:ok, {msgid, msgid, count, remaining_bindings}} to trigger a dpngettext/6 call.
- If :count is absent: Returns an error resulting in a compile-time ArgumentError.
```

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

### GettextSigils.Sigil - sigil_t Macro

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Sigil.md

The `sigil_t` macro provides the `~t` sigil for interpolated translations. It translates the given string using the `Gettext` module. The module must `use GettextSigils` to import this sigil.

```APIDOC
## `sigil_t` Macro

### Description
Translates the given string using the `Gettext` module.

### Method
Macro

### Signature
```elixir
@spec sigil_t(
  Macro.t(),
  charlist()
) :: Macro.t()
```

### Usage
This macro is automatically imported into modules that use `GettextSigils`.

```elixir
# Example usage within a module that uses GettextSigils
# Assuming 'Gettext' is configured and imported

# In a module that uses GettextSigils:
# use GettextSigils

# Example translation:
# my_text = "Hello, %{name}!"
# translated_text = ~t(my_text, name: "World")
```

### Notes
- The module must `use GettextSigils` to import this sigil.
- Refer to `GettextSigils` for setup instructions.
```

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

### Implement a custom modifier

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifier.md

Define a module that uses GettextSigils.Modifier and overrides specific callbacks to transform translated strings.

```elixir
defmodule MyApp.UpcaseModifier do
  use GettextSigils.Modifier

  @impl true
  def postprocess(string, _opts), do: {:ok, String.upcase(string)}
end
```

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

### Configure modifiers in GettextSigils

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifier.md

Register custom modifiers in the GettextSigils configuration using the :modifiers option.

```elixir
use GettextSigils,
  backend: MyApp.Gettext,
  sigils: [
    modifiers: [
      u: MyApp.UpcaseModifier,
      # with opts:
      s: {MyApp.ShoutModifier, intensity: 3}
    ]
  ]
```

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

### Using the built-in 'N' pluralization modifier

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

Append 'N' to a '~t' sigil that has a 'count' binding. This reuses the msgid for both singular and plural forms, allowing translators to define distinct forms in the .po file.

```elixir
~t"#{count} error(s)"N
```

```elixir
~t"#{count} items"N
```

```elixir
~t"#{count = length(users)} user(s)"N
```

```elixir
~t"#{count} error(s)"eN
```

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

### Pluralization with Modifiers

Source: https://hexdocs.pm/gettext_sigils/index.html

Use the N modifier for pluralization and explicit binding keys for the count.

```elixir
~t"#{count} error(s)"N
```

```elixir
~t"#{count = length(errors)} error(s)"N
```

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

### GettextSigils.Sigil Macro Signature

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Sigil.md

Defines the type signature for the `sigil_t` macro, which translates a given string using the `Gettext` module. Ensure your module uses `GettextSigils` to import this functionality.

```elixir
@spec sigil_t(
  Macro.t(),
  charlist()
) :: Macro.t()
```

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

### GettextSigils.Modifier Callbacks

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifier.md

The following callbacks define the lifecycle and transformation hooks for the ~t sigil modifiers.

```APIDOC
## CALLBACK init/1

### Description
Validates options provided to the modifier.

### Parameters
- **opts** (keyword) - The options passed to the modifier.

### Response
- **result(opts)** - Returns {:ok, opts} or {:error, reason}.

## CALLBACK domain_context/3

### Description
Computes the Gettext domain and context for the translation call.

### Parameters
- **input** (input) - The message ID and bindings.
- **opts** (opts) - The modifier options.
- **domain_context** (domain_context) - The current domain and context.

### Response
- **result(domain_context)** - Returns {:ok, domain_context} or {:error, reason}.

## CALLBACK preprocess/2

### Description
Rewrites the message at compile time.

### Parameters
- **input** (input) - The message ID and bindings.
- **opts** (opts) - The modifier options.

### Response
- **result(input)** - Returns {:ok, input} or {:error, reason}.

## CALLBACK pluralize/2

### Description
Transforms the input into a plural form.

### Parameters
- **input** (input) - The message ID and bindings.
- **opts** (opts) - The modifier options.

### Response
- **result(pluralized)** - Returns {:ok, pluralized} or {:error, reason}.

## CALLBACK postprocess/2

### Description
Transforms the final translated string at runtime.

### Parameters
- **string** (String.t) - The translated string.
- **opts** (opts) - The modifier options.

### Response
- **result(term)** - Returns {:ok, term} or {:error, reason}.
```

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

### Pluralization with N Modifier

Source: https://hexdocs.pm/gettext_sigils/modifiers.md

Illustrates the use of the built-in 'N' modifier for pluralizing messages, utilizing the 'count' binding.

```elixir
~t"#{count} error(s)"N
```

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

### GettextSigils.Modifiers.KeywordModifier

Source: https://hexdocs.pm/gettext_sigils/GettextSigils.Modifiers.KeywordModifier.md

Provides details on the KeywordModifier, including its purpose, how it normalizes keyword lists, and its configuration options.

```APIDOC
## GettextSigils.Modifiers.KeywordModifier

### Description
Built-in modifier that implements the static keyword-list form of modifier configuration. When a user writes `modifiers: [e: [domain: "errors"]]`, the keyword list is normalized to `{KeywordModifier, [domain: "errors"]}` so all modifiers flow through the same resolution path.

### Options

#### :domain
- **Type**: Gettext domain
- **Description**: Use the `:default` atom to select the backend's configured default domain, or a binary to override.

#### :context
- **Type**: Gettext context
- **Description**: Use `nil` to clear the context, or a binary to override.
```

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

### Compile-time emission of custom pluralization modifier

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

Shows the Elixir code generated at compile time for a sigil using a custom pluralization modifier with a specific separator.

```elixir
dpngettext("default", nil, "One error", "%{count} errors", count, [])
```

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

### Define Sigil Modifiers

Source: https://hexdocs.pm/gettext_sigils/index.html

Use modifiers to override domain and context settings for specific translations.

```elixir
defmodule MyAppWeb.DashboardLive do
  use GettextSigils,
    backend: MyApp.Gettext,
    sigils: [
      domain: "frontend",
      context: inspect(__MODULE__),
      modifiers: [
        e: [domain: "errors"],
        g: [domain: :default, context: nil]
      ]
    ]

  ~t"Welcome"     # domain: "frontend", context: "MyAppWeb.DashboardLive"
  ~t"Not found"e  # domain: "errors",   context: "MyAppWeb.DashboardLive"
  ~t"Yes"g        # backend default domain, no context
  ~t"Not found"eg # backend default domain, no context (g runs after e)
end
```

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

### Compile-time emission of 'N' modifier

Source: https://hexdocs.pm/gettext_sigils/pluralization.md

Shows the approximate Elixir code generated at compile time when using the 'N' pluralization modifier.

```elixir
dpngettext("default", nil, "%{count} error(s)", "%{count} error(s)", count, [])
```
Tokens:
Raw