### Install git-lfs

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Installs git-lfs using Homebrew. This must be done before cloning the repository due to large file dependencies.

```bash
brew install git-lfs
git lfs install
```

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

### Install Maven

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Installs the Maven build tool using Homebrew. Maven is required for generating the CLDR toolchain.

```bash
brew install maven
```

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

### Configure ex_cldr Backend with Providers

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Define a backend module for ex_cldr, specifying locales and enabling specific providers. If :providers is nil, all installed providers are enabled by default. Use an empty list to disable all providers.

```elixir
defmodule MyApp.Cldr do
  use Cldr,
    locales: ["en", "zh"],
    default_locale: "en",
    providers: [Cldr.Number, Cldr.List]
end
```

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

### Get Available Units with Cldr.Unit

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Retrieve a list of all available unit symbols supported by the Cldr.Unit module.

```elixir
iex> MyApp.Cldr.Unit.available_units
[:acre, :acre_foot, :ampere, :arc_minute, :arc_second, :astronomical_unit, :bit,
 :bushel, :byte, :calorie, :carat, :celsius, :centiliter, :centimeter, :century,
 :cubic_centimeter, :cubic_foot, :cubic_inch, :cubic_kilometer, :cubic_meter,
 :cubic_mile, :cubic_yard, :cup, :cup_metric, :day, :deciliter, :decimeter,
 :degree, :fahrenheit, :fathom, :fluid_ounce, :foodcalorie, :foot, :furlong,
 :g_force, :gallon, :gallon_imperial, :generic, :gigabit, :gigabyte, :gigahertz,
 :gigawatt, :gram, :hectare, :hectoliter, :hectopascal, :hertz, :horsepower,
 :hour, :inch, ...]
```

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

### Clone CLDR Repository

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Clones the official CLDR repository. Ensure git-lfs is installed first. The CLDR_REPO environment variable should be set to your preferred directory.

```bash
# Set to whatever directory is appropriate
export CLDR_REPO="$HOME/development/cldr_repo"
git clone https://github.com/unicode-org/cldr $CLDR_REPO
```

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

### Configure Maven GitHub Token

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Modifies or creates the $HOME/.m2/settings.xml file to include server credentials for accessing GitHub packages. Replace 'your github user id' and 'your access token' with your actual GitHub credentials.

```xml
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

 <servers>
  <server>
   <id>githubicu</id>
   <username>your github user id</username>
   <password>your access token</password>
  </server>

 </servers>
</settings>
```

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

### Download ISO Currency Database

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Use the mix cldr.download.iso_currency task to fetch the latest ISO currency data.

```bash
mix cldr.download.iso_currency
```

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

### Global Ex_cldr Configuration

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Define global configuration for Ex_cldr in your config.exs file. Valid keys include :json_library, :default_locale, :default_backend, :cacertfile, :data_dir, and :force_locale_download. Other keys may be used for migration but will print deprecation warnings.

```elixir
config :ex_cldr,
  default_locale: "en",
  default_backend: MyApp.Cldr,
  json_library: Jason,
  cacertfile: "path/to/cacertfile"
```

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

### Create Staging and Production Directories

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Ensure that the CLDR staging and production directories exist before running the data generation script. The script will exit if these directories are not found.

```bash
mkdir $CLDR_STAGING
mkdir $CLDR_PRODUCTION
```

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

### Configure Locales with Wildcards in Ex_cldr

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Configure specific locales and use wildcard matching for regional variants. Ensures only specified locales are available, raising an error for unknown ones.

```elixir
use Cldr,
  default_locale: "en",
  locales: ["en-*", "fr"]
```

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

### Format Lists with Cldr.List

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Use Cldr.List.to_string/2 for locale-aware list formatting. Specify the locale and optionally a format like :unit_narrow.

```elixir
iex> MyApp.Cldr.List.to_string(["a", "b", "c"], locale: "en")
"a, b, and c"
```

```elixir
iex> MyApp.Cldr.List.to_string(["a", "b", "c"], locale: "en", format: :unit_narrow)
"a b c"
```

```elixir
iex> MyApp.Cldr.List.to_string(["a", "b", "c"], locale: "fr")
"a, b et c"
```

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

### Update ex_cldr Repository

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Navigate to the ex_cldr directory and pull the latest changes from the repository.

```bash
cd $EX_CLDR
git pull
```

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

### Format Dates and Times with Cldr.DateTime

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Utilize Cldr.Date, Cldr.Time, and Cldr.DateTime modules for locale-aware date and time formatting. Cldr.DateTime.Relative provides relative date formatting.

```elixir
iex> MyApp.Cldr.Date.to_string Date.utc_today()
{:ok, "Aug 18, 2017"}
```

```elixir
iex> MyApp.Cldr.Time.to_string Time.utc_now
{:ok, "11:38:55 AM"}
```

```elixir
iex> MyApp.Cldr.DateTime.to_string DateTime.utc_now
{:ok, "Aug 18, 2017, 11:39:08 AM"}
```

```elixir
iex> MyApp.Cldr.DateTime.Relative.to_string 1, unit: :day, format: :narrow
{:ok, "tomorrow"}
```

```elixir
iex> MyApp.Cldr.DateTime.Relative.to_string(1, unit: :day, locale: "fr")
"demain"
```

```elixir
iex> MyApp.Cldr.DateTime.Relative.to_string(1, unit: :day, format: :narrow)
"tomorrow"
```

```elixir
iex> MyApp.Cldr.DateTime.Relative.to_string(1234, unit: :year)
"in 1,234 years"
```

```elixir
iex> MyApp.Cldr.DateTime.Relative.to_string(1234, unit: :year, locale: "fr")
"dans 1 234 ans"
```

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

### Clone ex_cldr Repository

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Clones the ex_cldr repository. The EX_CLDR environment variable should be set to your preferred directory.

```bash
export EX_CLDR="$HOME/Development/ex_cldr"
git clone https://github.com/elixir-cldr/cldr $EX_CLDR
```

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

### Language Tag Handling

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Explains the conventions and standards used for language tags within ex_cldr.

```APIDOC
## Language Tag Standards

### Description
`ex_cldr` uses language strings conforming to the [IETF standard](https://en.wikipedia.org/wiki/IETF_language_tag) as defined in [RFC5646](https://tools.ietf.org/html/rfc5646). It also supports the `u` extension ([RFC6067](https://tools.ietf.org/html/rfc6067)) and the `t` extension ([RFC6497](https://tools.ietf.org/html/rfc6497)), aligning with W3C standards.

### Differences from ISO 15897
The IETF standard differs from the [ISO/IEC 15897](http://www.open-std.org/jtc1/sc22/wg20/docs/n610.pdf) standard primarily in the use of separators: IETF/W3C use '-' while ISO 15897 uses '_'.

### Conventions
Locale strings are case-insensitive, but common conventions include:
- Language codes: lower-cased
- Territory codes: upper-cased
- Script names: capital-cased
- Other subtags: lower-cased
```

```APIDOC
## `Cldr.LanguageTag.Sigil`

### Description
Provides a sigil (`~l`) for simplifying the creation of `t:Cldr.LanguageTag` structs.

### Usage
```elixir
import Cldr.LanguageTag.Sigil

# Example usage (assuming the sigil is imported)
# ~l"en-US"
```

### Availability
Available since `ex_cldr` version 2.23.0.
```

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

### Configure Cldr Backend Module

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Configure the Cldr backend module with default locale, supported locales, fallback locales, gettext integration, data directory, OTP app, precompiled number formats and transliterations, providers, documentation generation, and locale download behavior.

```elixir
defmodule MyApp.Cldr do
  use Cldr,
    default_locale: "en",
    locales: ["fr", "en", "bs", "si", "ak", "th"],
    add_fallback_locales: false,
    gettext: MyApp.Gettext,
    data_dir: "./priv/cldr",
    otp_app: :my_app,
    precompile_number_formats: ["¤¤#,##0.##"],
    precompile_transliterations: [{:latn, :arab}, {:thai, :latn}],
    providers: [Cldr.Number],
    generate_docs: true,
    force_locale_download: false
end
```

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

### Configure Cldr Locales for Production

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Configure the Cldr backend module with multiple locales and precompiled transliterations for production environments, which may take longer to compile.

```elixir
config :my_app, MyApp.Cldr,
  locales: ["fr", "en", "bs", "si", "ak", "th"],
  precompile_transliterations: [{:latn, :arab}, {:thai, :latn}]
```

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

### Configure Cldr Backend Module with OTP App

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Configure the Cldr backend module specifying the OTP app, default locale, gettext integration, JSON library, data directory, precompiled number formats, and providers.

```elixir
defmodule MyApp.Cldr do
  use Cldr,
    otp_app: :my_app,
    default_locale: "en",
    gettext: MyApp.Gettext,
    json_library: Jason,
    data_dir: "./priv/cldr",
    precompile_number_formats: ["¤¤#,##0.##"],
    providers: [Cldr.Number]
end
```

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

### Define a Cldr Backend Module

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Define a backend module to host ex_cldr configuration and public API functions. This allows for multiple configurations and prevents interference between different ex_cldr implementations.

```elixir
defmodule MyApp.Cldr do
  @moduledoc """
  Define a backend module that will host our
  Cldr configuration and public API.

  Most function calls in Cldr will be calls
  to functions on this module.
  """
  use Cldr,
    locales: ["en", "fr", "zh", "th"],
    default_locale: "en"

end
```

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

### Configure Ex_cldr with Gettext Integration

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Integrate ex_cldr with a Gettext module for locale management. Handles transliteration between Gettext's POSIX locale format and ex_cldr's Unicode format.

```elixir
use Cldr,
  default_locale: "en",
  gettext: MyApp.Gettext,
  locales: ["en-*", "fr"]
```

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

### Consolidate ex_cldr Locale Data

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

After updating the repository, run the mix cldr.consolidate task to format the locales for ex_cldr.

```bash
mix cldr.consolidate
```

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

### Date and Time Localization

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

The `Cldr.DateTime` and `Cldr.DateTime.Relative` modules provide APIs for localizing dates and times.

```APIDOC
## `Cldr.Date.to_string/1`

### Description
Formats a `Date` struct into a locale-specific string.

### Method
`to_string(date)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **date** (Date) - Required - The `Date` struct to format.

### Request Example
```elixir
Mysystem.Cldr.Date.to_string(Date.utc_today())
```

### Response
#### Success Response (tuple)
- `{:ok, formatted_string}` or `{:error, reason}`.

#### Response Example
```elixir
{:ok, "Aug 18, 2017"}
```
```

```APIDOC
## `Cldr.Time.to_string/1`

### Description
Formats a `Time` struct into a locale-specific string.

### Method
`to_string(time)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **time** (Time) - Required - The `Time` struct to format.

### Request Example
```elixir
Mysystem.Cldr.Time.to_string(Time.utc_now())
```

### Response
#### Success Response (tuple)
- `{:ok, formatted_string}` or `{:error, reason}`.

#### Response Example
```elixir
{:ok, "11:38:55 AM"}
```
```

```APIDOC
## `Cldr.DateTime.to_string/1`

### Description
Formats a `DateTime` struct into a locale-specific string.

### Method
`to_string(datetime)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **datetime** (DateTime) - Required - The `DateTime` struct to format.

### Request Example
```elixir
Mysystem.Cldr.DateTime.to_string(DateTime.utc_now())
```

### Response
#### Success Response (tuple)
- `{:ok, formatted_string}` or `{:error, reason}`.

#### Response Example
```elixir
{:ok, "Aug 18, 2017, 11:39:08 AM"}
```
```

```APIDOC
## `Cldr.DateTime.Relative.to_string/2`

### Description
Formats a relative date or time difference into a human-readable string.

### Method
`to_string(value, opts)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **value** (number) - Required - The numeric value representing the time difference.
- **unit** (atom) - Required - The unit of the time difference (e.g., `:day`, `:year`).
- **locale** (string) - Optional - The locale to use for formatting.
- **format** (atom) - Optional - The formatting style to use (e.g., `:narrow`).

### Request Example
```elixir
Mysystem.Cldr.DateTime.Relative.to_string(1, unit: :day, format: :narrow)
```

### Response
#### Success Response (string or tuple)
- The localized string representation of the relative time, or `{:ok, string}`.

#### Response Example
```elixir
"tomorrow"
```
```

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

### Validate Locale with Timezone and Currency Format Extension

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Validates a locale string 'en-AU-u-tz-ausyd-cf-account' using MyApp.Cldr.validate_locale, demonstrating timezone and currency format extensions.

```elixir
iex> MyApp.Cldr.validate_locale "en-AU-u-tz-ausyd-cf-account"
{:ok,
 %Cldr.LanguageTag{
   canonical_locale_name: "en-Latn-AU",
   cldr_locale_name: "en-AU",
   extensions: %{},
   gettext_locale_name: "en",
   language: "en",
   language_subtags: [],
   language_variants: nil,
   locale: %Cldr.LanguageTag.U{cf: :account, timezone: "Australia/Sydney"},
   private_use: [],
   rbnf_locale_name: "en",
   requested_locale_name: "en-AU",
   script: :Latn,
   territory: :AU,
   transform: %{}
 }}
```

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

### Add ex_cldr and JSON Library Dependency

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Add ex_cldr and a compatible JSON library (like jason) to your mix project's dependencies. If running on OTP 27+ or Elixir 1.18+, a JSON library is not required.

```elixir
defp deps do
  [
    {:ex_cldr, "~> 2.37"},
    # Poison or any other compatible json library
    # that implements `encode!/1` and `decode!/1`
    # :jason is recommended
    {:jason, "~> 1.0"}
    # {:poison, "~> 2.1 or ~> 3.0"}
  ]
end
```

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

### Unit Localization

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

The `Cldr.Unit` module handles unit localization. The main public API is `Cldr.Unit.to_string/3`.

```APIDOC
## `Cldr.Unit.to_string/3`

### Description
Localizes a numeric value with a given unit according to locale-specific conventions.

### Method
`to_string(value, unit, opts)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **value** (number) - Required - The numeric value to format.
- **unit** (atom) - Required - The unit to associate with the value (e.g., `:gallon`, `:megahertz`).
- **format** (atom) - Optional - The formatting style to use (e.g., `:long`, `:short`).

### Request Example
```elixir
Mysystem.Cldr.Unit.to_string 123, :gallon
```

### Response
#### Success Response (string)
- The localized string representation of the unit and value.

#### Response Example
```elixir
"123 gallons"
```
```

```APIDOC
## `Cldr.Unit.available_units/0`

### Description
Returns a list of all available units that can be used for localization.

### Method
`available_units()`

### Parameters
None

### Request Example
```elixir
Mysystem.Cldr.Unit.available_units()
```

### Response
#### Success Response (list)
- A list of atoms representing available units.

#### Response Example
```elixir
[:acre, :acre_foot, :ampere, :arc_minute, :arc_second, :astronomical_unit, :bit, :bushel, :byte, :calorie, :carat, :celsius, :centiliter, :centimeter, :century, :cubic_centimeter, :cubic_foot, :cubic_inch, :cubic_kilometer, :cubic_meter, :cubic_mile, :cubic_yard, :cup, :cup_metric, :day, :deciliter, :decimeter, :degree, :fahrenheit, :fathom, :fluid_ounce, :foodcalorie, :foot, :furlong, :g_force, :gallon, :gallon_imperial, :generic, :gigabit, :gigabyte, :gigahertz, :gigawatt, :gram, :hectare, :hectoliter, :hectopascal, :hertz, :horsepower, :hour, :inch, ...]
```
```

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

### Configure Cldr Locales for Development/Testing

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Configure the Cldr backend module with a single locale for faster compilation in development and test environments.

```elixir
config :my_app, MyApp.Cldr,
  locales: ["en"]
```

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

### List Localization

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

The `Cldr.List` module provides functionality for localizing lists. The primary public API is `Cldr.List.to_string/2`.

```APIDOC
## `Cldr.List.to_string/2`

### Description
Formats a list of strings into a human-readable string according to locale-specific conventions.

### Method
`to_string(list, opts)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **locale** (string) - Required - The locale to use for formatting.
- **format** (atom) - Optional - The formatting style to use (e.g., `:unit_narrow`).

### Request Example
```elixir
Mysystem.Cldr.List.to_string(["a", "b", "c"], locale: "en")
```

### Response
#### Success Response (string)
- The formatted string.

#### Response Example
```elixir
"a, b, and c"
```
```

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

### Configure Cldr with Conditional Locale Download

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Conditionally forces locale data download during compilation based on the Mix environment. Useful for ensuring reproducible builds in production.

```elixir
defmodule MyApp.Cldr do
  use Cldr,
    locales: ["en", "fr"],
    default_locale: "en",
    force_locale_download: Mix.env() == :prod
end
```

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

### Export Environment Variables for CLDR Data Generation

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Set these environment variables to define the locations for ex_cldr, the Unicode CLDR repository, and staging/production data directories.

```bash
export EX_CLDR=directory_where_you_cloned_ex_cldr
export CLDR_REPO=directory_where_you_cloned_unicode_cldr
export CLDR_STAGING=directory_where_staging_data_will_be_saved
export CLDR_PRODUCTION=directory_where_production_data_will_be_saved
```

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

### Generate ex_cldr Language Tags

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Regenerate the language_tags.ebin file by setting the DEV shell variable to true, which disables locale stale tests.

```bash
DEV=true mix cldr.generate_language_tags
```

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

### Configure Gettext Pluralization with Cldr.Gettext.Plural

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Define a custom gettext plural forms module using Cldr.Gettext.Plural to leverage CLDR plural rules. This module is then configured in your gettext backend.

```elixir
defmodule MyApp.Gettext.Plural do
  use Cldr.Gettext.Plural, cldr_backend: MyApp.Cldr
end
```

```elixir
defmodule MyApp.Gettext do
  use Gettext, plural_forms: MyApp.Gettext.Plural
end
```

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

### Execute ldml2json Script

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Run the ldml2json script from the CLDR repository to process XML files into JSON format. This process can take a significant amount of time.

```bash
$CLDR_REPO/ldml2json
```

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

### Localize Units with Cldr.Unit

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Employ Cldr.Unit.to_string/3 for unit localization. The function takes a number, a unit symbol, and optional format options.

```elixir
iex> MyApp.Cldr.Unit.to_string 123, :gallon
"123 gallons"
```

```elixir
iex> MyApp.Cldr.Unit.to_string 1234, :gallon, format: :long
"1 thousand gallons"
```

```elixir
iex> MyApp.Cldr.Unit.to_string 1234, :gallon, format: :short
"1K gallons"
```

```elixir
iex> MyApp.Cldr.Unit.to_string 1234, :megahertz
"1,234 megahertz"
```

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

### Gettext Pluralization Integration

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

This section describes how to configure Gettext to use CLDR plural rules.

```APIDOC
## `use Cldr.Gettext.Plural`

### Description
Allows a module to define plural forms based on CLDR plural rules for use with the `gettext` library.

### Usage
```elixir
defmodule MyApp.Gettext.Plural do
  use Cldr.Gettext.Plural, cldr_backend: MyApp.Cldr
end
```

### Configuration
This module is then used in the `gettext` backend configuration:

```elixir
defmodule MyApp.Gettext do
  use Gettext, plural_forms: MyApp.Gettext.Plural
end
```

### Note
This module does not guarantee the same `plural index` as `Gettext`'s default engine, which may lead to compatibility issues if mixing plural engines.
```

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

### Create Language Tags with Sigil_l

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Use the Sigil_l to simplify the creation of Cldr.LanguageTag structs. This sigil is available from ex_cldr version 2.23.0.

```elixir
iex> import Cldr.LanguageTag.Sigil
Cldr.LanguageTag.Sigil

# Returns a locale that is valid and known to
```

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

### Format Numbers with ex_cldr

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Use Cldr.Number.to_string/2 to format numbers according to specified locales and formats. Supports various formats including currency, roman numerals, ordinals, and spellout.

```elixir
iex> MyApp.Cldr.Number.to_string 12345
"12,345"
```

```elixir
iex> MyApp.Cldr.Number.to_string 12345, locale: "fr"
"12 345"
```

```elixir
iex> MyApp.Cldr.Number.to_string 12345, locale: "fr", currency: "USD"
"12 345,00 $US"
```

```elixir
iex> MyApp.Cldr.Number.to_string 12345, format: "#E0"
"1.2345E4"
```

```elixir
iex(> MyApp.Cldr.Number.to_string 1234, format: :roman
"MCCXXXIV"
```

```elixir
iex> MyApp.Cldr.Number.to_string 1234, format: :ordinal
"1,234th"
```

```elixir
iex> MyApp.Cldr.Number.to_string 1234, format: :spellout
"one thousand two hundred thirty-four"
```

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

### Parse Complex Language Tag with Extensions

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Parses a complex language tag including various Unicode extensions for calendar, currency, script, and more.

```elixir
iex> ~l(en-u-ca-ethiopic-cu-aud-sd-gbsct-t-d0-lower-k0-extended-m0-ungegn-x-ux)
#Cldr.LanguageTag<en-t-d0-lower-k0-extended-m0-ungegn-u-ca-ethiopic-cu-aud-sd-gbsct-x-ux [validated]>
```

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

### Parse Language Tag with Specific Backend

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Parses a language tag (en-US) while specifying a custom backend module (MyApp.Cldr).

```elixir
iex> ~l(en-US|MyApp.Cldr)
#Cldr.LanguageTag<en-US [validated]>
```

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

### Parse Default Language Tag

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Uses the ~l sigil to parse a default language tag (en-US). The tag is validated and known.

```elixir
iex> ~l(en-US)
#Cldr.LanguageTag<en-US [validated]>
```

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

### Update CLDR Repository

Source: https://github.com/elixir-cldr/cldr/blob/main/DEVELOPMENT.md

Updates the local CLDR repository to the latest version by pulling changes from the remote repository. This command should be run from within the CLDR repository directory.

```bash
cd $CLDR_REPO
git pull
```

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

### Parse Language Tag with 'u' Flag

Source: https://github.com/elixir-cldr/cldr/blob/main/README.md

Parses a language tag (zh) with the 'u' flag, which validates the tag but may not recognize it as a configured locale.

```elixir
iex> ~l(zh)u
#Cldr.LanguageTag<zh [canonical]>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.