yamerl

https://github.com/yakaz/yamerl
Admin
yamerl is a pure Erlang application that parses YAML 1.1, YAML 1.2, and JSON documents with no...
Tokens:6,955
Snippets:52
Trust Score:6
License:BSD-2-Clause
Update:6 months ago
Show doc for...
Tokens:
Raw
### Start the Yamerl Application

Source: https://context7.com/yakaz/yamerl/llms.txt

Before using yamerl, the OTP application must be started to initialize its processes.

```erlang
%% Start the yamerl application
application:start(yamerl).
```

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

### Start yamerl Application

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Before using yamerl, ensure the application is started using the application:start/1 function.

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

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

### Parse YAML in Elixir

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Examples of calling the Myapp module to parse YAML in simple and detailed modes.

```elixir
Myapp.simple("system.yaml")
```

```elixir
# List of documents.
[
     # List of mappings.
     [
      # Mapping with two entries.
      [
       {'os', 'FreeBSD'},
       {'version', '9.0-RELEASE-p3'}
      ]
     ]
]
```

```elixir
Myapp.detailed("system.yaml")
```

```elixir
# List of documents.
[
     # Document with a list as its root node.
     yamerl_doc:
     {:yamerl_seq, :yamerl_node_seq, 'tag:yaml.org,2002:seq', [line: 2, column: 1],
      [
       # Mapping #1.
       {:yamerl_map, :yamerl_node_map, 'tag:yaml.org,2002:map', [line: 2, column: 3],
        [
         # Mapping entry #1.
         {
          {:yamerl_str, :yamerl_node_str, 'tag:yaml.org,2002:str', [line: 2, column: 3], 'os'},
          {:yamerl_str, :yamerl_node_str, 'tag:yaml.org,2002:str', [line: 2, column: 7], 'FreeBSD'}
         },
         # Mapping entry #2.
         {
          {:yamerl_str, :yamerl_node_str, 'tag:yaml.org,2002:str', [line: 3, column: 3], 'version'},
          {:yamerl_str, :yamerl_node_str, 'tag:yaml.org,2002:str', [line: 3, column: 12], '9.0-RELEASE-p3'}
         }
        ]
       }
      ],
      1
     }
]
```

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

### Parse YAML in Erlang

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Demonstrates simple and detailed YAML parsing using yamerl_constr in Erlang.

```erlang
yamerl_constr:file("system.yaml").
```

```erlang
% List of documents.
[
     % List of mappings.
     [
      % Mapping with two entries.
      [
       {"os", "FreeBSD"},
       {"version","9.0-RELEASE-p3"}
      ]
     ]
]
```

```erlang
yamerl_constr:file("system.yaml", [{detailed_constr, true}]).
```

```erlang
% List of documents.
[
     % Document with a list as its root node.
     {yamerl_doc,
      {yamerl_seq, yamerl_node_seq, "tag:yaml.org,2002:seq", [{line, 2}, {column, 1}], [
       % Mapping #1.
       {yamerl_map, yamerl_node_map, "tag:yaml.org,2002:map", [{line, 2}, {column, 3}], [
        {
         % Mapping entry #1.
         {yamerl_str, yamerl_node_str, "tag:yaml.org,2002:str", [{line, 2}, {column, 3}], "os"},
         {yamerl_str, yamerl_node_str, "tag:yaml.org,2002:str", [{line, 2}, {column, 7}], "FreeBSD"}
        }, {
         % Mapping entry #2.
         {yamerl_str, yamerl_node_str, "tag:yaml.org,2002:str", [{line, 3}, {column, 3}], "version"},
         {yamerl_str, yamerl_node_str, "tag:yaml.org,2002:str", [{line, 3}, {column, 12}], "9.0-RELEASE-p3"}
        }
       ]}
      ],
      1}
     ]
]
```

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

### Integrate yamerl in Elixir

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Steps to add yamerl as a dependency in mix.exs and implement parsing logic.

```elixir
# mix.exs, created with `mix new myapp` and updated to have `yamerl` as
# a dependency.
defmodule Myapp.Mixfile do
  use Mix.Project

  def project do
    [app: :myapp,
     version: "0.1.0",
     elixir: "~> 1.3",
     build_embedded: Mix.env == :prod,
     start_permanent: Mix.env == :prod,
     deps: deps()]
  end

  # Configuration for the OTP application
  #
  # Type "mix help compile.app" for more information
  def application do
    [applications: [:logger]]
  end

  # Dependencies can be Hex packages:
  #
  #   {:mydep, "~> 0.3.0"}
  #
  # Or git/path repositories:
  #
  #   {:mydep, git: "https://github.com/elixir-lang/myapp.git", tag: "0.1.0"}
  #
  # Type "mix help deps" for more examples and options
  defp deps do
    [
      {:yamerl, "~> 0.4.0"}
    ]
  end
end
```

```elixir
# lib/myapp.ex
defmodule Myapp do
  def simple(filename) do
    # The yamerl application must be started before any use of it.
    Application.start(:yamerl)

    :yamerl_constr.file(filename)
  end

  def detailed(filename) do
    # The yamerl application must be started before any use of it.
    Application.start(:yamerl)

    :yamerl_constr.file(filename, [:detailed_constr])
  end
end
```

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

### Schema and Node Configuration

Source: https://context7.com/yakaz/yamerl/llms.txt

Functions to configure parsing schemas and register custom node modules for extended data types.

```APIDOC
## yamerl_constr:string/2

### Description
Parses a YAML string using specific schema rules or custom node modules.

### Parameters
- **YAMLString** (string) - Required - The YAML content to parse.
- **Options** (list) - Required - Includes {schema, Type} (failsafe, json, core, yaml11) or {node_mods, [Modules]} for custom types like atoms or timestamps.

### Response
- **Result** (list) - Parsed data based on the selected schema and registered modules.
```

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

### Parse YAML File with Options using yamerl:decode_file/2

Source: https://context7.com/yakaz/yamerl/llms.txt

Parse YAML files with additional configuration options, such as detailed construction or specific schema selection, using yamerl:decode_file/2.

```erlang
%% Parse file with detailed construction
yamerl:decode_file("applications.yaml", [{detailed_constr, true}]).

%% Parse file with specific schema
yamerl:decode_file("config.yaml", [{schema, json}]).
```

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

### Parse String with Options using yamerl_constr:string/2

Source: https://context7.com/yakaz/yamerl/llms.txt

Control parsing with yamerl_constr:string/2 using options like detailed_constr, ignore_unrecognized_tags, and keep_duplicate_keys. Detailed mode returns records with metadata.

```erlang
%% Simple mode (default) - returns basic Erlang types
yamerl_constr:string("Hello!", [{detailed_constr, false}]).
%% Returns: ["Hello!"]

%% Detailed mode - returns records with metadata
yamerl_constr:string("Hello!", [{detailed_constr, true}]).
%% Returns:
%% [{yamerl_doc,
%%    {yamerl_str, yamerl_node_str, "tag:yaml.org,2002:str",
%%      [{line, 1}, {column, 1}],
%%      "Hello!"}}]

%% Ignore unrecognized tags instead of throwing errors
yamerl_constr:string("!custom_tag value", [{ignore_unrecognized_tags, true}]).
%% Returns: ["value"]

%% Keep duplicate keys in mappings (requires detailed_constr or proplists)
yamerl_constr:string("key: 1\nkey: 2", [{keep_duplicate_keys, true}]).
%% Returns: [[{"key", 1}, {"key", 2}]]
```

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

### Parse YAML String with Options using yamerl:decode/2

Source: https://context7.com/yakaz/yamerl/llms.txt

Configure parsing behavior using options with yamerl:decode/2. Options include detailed construction mode and schema selection (e.g., yaml11, core).

```erlang
%% Parse with detailed construction mode
yamerl:decode("Hello!", [{detailed_constr, true}]).
%% Returns:
%% [{yamerl_doc,
%%    {yamerl_str, yamerl_node_str, "tag:yaml.org,2002:str",
%%      [{line, 1}, {column, 1}],
%%      "Hello!"}}]

%% Parse using YAML 1.1 schema
yamerl:decode("yes", [{schema, yaml11}]).
%% Returns: [true]  (YAML 1.1 recognizes "yes" as boolean)

%% Parse using core schema
yamerl:decode("yes", [{schema, core}]).
%% Returns: ["yes"]  (Core schema treats "yes" as string)
```

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

### Parse YAML Files with yamerl_constr

Source: https://context7.com/yakaz/yamerl/llms.txt

Use file/1 for basic parsing or file/2 with options like detailed_constr to include metadata.

```erlang
%% Simple file parsing
yamerl_constr:file("applications.yaml").
%% For file containing:
%% - application: kernel
%%   version: 2.15.3
%%   path: /usr/local/lib/erlang/lib/kernel-2.15.3
%% - application: stdlib
%%   version: 1.18.3
%%   path: /usr/local/lib/erlang/lib/stdlib-1.18.3
%%
%% Returns:
%% [[[{"application", "kernel"},
%%    {"version", "2.15.3"},
%%    {"path", "/usr/local/lib/erlang/lib/kernel-2.15.3"}],
%%   [{"application", "stdlib"},
%%    {"version", "1.18.3"},
%%    {"path", "/usr/local/lib/erlang/lib/stdlib-1.18.3"}]]]

%% Parse with detailed construction
yamerl_constr:file("system.yaml", [{detailed_constr, true}]).
%% Returns records with line/column information and YAML tags
```

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

### yamerl:decode/2

Source: https://context7.com/yakaz/yamerl/llms.txt

Parses a YAML string with specific configuration options.

```APIDOC
## yamerl:decode/2

### Description
Parses a YAML string with additional configuration options such as detailed construction mode or schema selection.

### Parameters
#### Request Body
- **yaml_string** (string) - Required - The YAML content to parse.
- **options** (list) - Required - Configuration options (e.g., [{detailed_constr, true}, {schema, yaml11}]).

### Response
#### Success Response (200)
- **result** (list/record) - Parsed content based on the provided options.
```

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

### Configure Map Output for YAML Mappings

Source: https://context7.com/yakaz/yamerl/llms.txt

Set the map_node_format option to map to return Erlang maps instead of the default proplists.

```erlang
%% Parse YAML mapping as Erlang map
yamerl_constr:file("config.yaml", [
    {detailed_constr, false},
    {map_node_format, map}
]).
%% For file containing:
%% first: {item: 1}
%% second: {item: 2}
%%
%% Returns:
%% [#{ 
%%     "first" => #{"item" => 1},
%%     "second" => #{"item" => 2}
%% }]

%% Maps with detailed construction
yamerl_constr:file("config.yaml", [
    {detailed_constr, true},
    {map_node_format, map}
]).
%% Returns yamerl_map records with map data instead of proplist
```

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

### Select YAML Schemas

Source: https://context7.com/yakaz/yamerl/llms.txt

Use the schema option to control type interpretation, such as strict JSON or legacy YAML 1.1 compatibility.

```erlang
%% Failsafe schema - only strings, sequences, and mappings
yamerl_constr:string("123", [{schema, failsafe}]).
%% Returns: ["123"]  (parsed as string)

%% JSON schema - strict JSON compatibility
yamerl_constr:string("true", [{schema, json}]).
%% Returns: [true]

%% Core schema (default) - YAML 1.2 core types
yamerl_constr:string("0x1A", [{schema, core}]).
%% Returns: [26]  (hexadecimal integer)

%% YAML 1.1 schema - extended boolean/null values
yamerl_constr:string("yes", [{schema, yaml11}]).
%% Returns: [true]  (YAML 1.1 treats "yes", "on" as true)

yamerl_constr:string("~", [{schema, yaml11}]).
%% Returns: [null]  (YAML 1.1 treats "~" as null)
```

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

### Parse YAML File

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Parse a YAML document from a file using yamerl_constr:file/1. The output is a list of documents, with each document represented as a proplist for mappings.

```erlang
yamerl_constr:file("applications.yaml").
```

```erlang
% List of documents; again, only one document here.
[
 % List of mappings.
 [
  % Mapping, represented as a proplist: each entry has the form {Key, Value}.
  [
   {"application", "kernel"},
   {"version", "2.15.3"},
   {"path", "/usr/local/lib/erlang/lib/kernel-2.15.3"}
  ], [
   {"application", "stdlib"},
   {"version", "1.18.3"},
   {"path", "/usr/local/lib/erlang/lib/stdlib-1.18.3"}
  ], [
   {"application", "sasl"},
   {"version", "2.2.1"},
   {"path", "/usr/local/lib/erlang/lib/sasl-2.2.1"}
  ]
 ]
]
```

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

### Parse YAML File with yamerl:decode_file/1

Source: https://context7.com/yakaz/yamerl/llms.txt

Read and parse YAML documents directly from a file on disk using yamerl:decode_file/1.

```erlang
%% Parse a YAML file
yamerl:decode_file("config.yaml").
%% For a file containing:
%% database:
%%   host: localhost
%%   port: 5432
%%   name: myapp
%%
%% Returns:
%% [[[{"database", [{"host", "localhost"},
%%                  {"port", 5432},
%%                  {"name", "myapp"}]}]]]
```

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

### Extend yamerl with Custom Node Modules

Source: https://context7.com/yakaz/yamerl/llms.txt

Register modules to handle custom tags or enable features like atom autodetection.

```erlang
%% Register the Erlang atom node module
yamerl_app:set_param(node_mods, [yamerl_node_erlang_atom]).

%% Parse with explicit atom tag
yamerl_constr:string("!<tag:yamerl,2012:atom> my_atom", [{detailed_constr, false}]).
%% Returns: [my_atom]

%% Enable atom autodetection for untagged strings
yamerl_constr:string("my_atom", [
    {detailed_constr, false},
    {erlang_atom_autodetection, true}
]).
%% Returns: [my_atom]  (if it matches atom pattern)

%% Per-call node module registration
yamerl_constr:string("!<tag:yamerl,2012:atom> hello", [
    {node_mods, [yamerl_node_erlang_atom]}
]).
%% Returns: [hello]
```

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

### yamerl_constr:string/2

Source: https://context7.com/yakaz/yamerl/llms.txt

Advanced parsing of strings with specific construction options.

```APIDOC
## yamerl_constr:string/2

### Description
Provides granular control over the parsing process, including handling duplicate keys, ignoring tags, or returning detailed metadata.

### Parameters
#### Request Body
- **yaml_string** (string) - Required - The YAML content to parse.
- **options** (list) - Required - Options like {detailed_constr, boolean}, {ignore_unrecognized_tags, boolean}, or {keep_duplicate_keys, boolean}.

### Response
#### Success Response (200)
- **result** (list/record) - Parsed data structure.
```

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

### Add yamerl Dependency in Rebar

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Integrate yamerl into your project by listing it as a package dependency in your rebar.config file.

```erlang
{deps, [yamerl]}.
```

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

### yamerl:decode_file/1

Source: https://context7.com/yakaz/yamerl/llms.txt

Parses YAML documents from a file.

```APIDOC
## yamerl:decode_file/1

### Description
Reads a file from disk and parses its contents as YAML.

### Parameters
#### Request Body
- **file_path** (string) - Required - Path to the YAML file.

### Response
#### Success Response (200)
- **result** (list) - Parsed YAML documents.
```

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

### File Parsing API

Source: https://context7.com/yakaz/yamerl/llms.txt

Functions for parsing YAML documents directly from files with support for detailed construction options.

```APIDOC
## yamerl_constr:file/1,2

### Description
Parses YAML documents from a file. Supports optional configuration for detailed construction (line/column info and tags).

### Method
Erlang Function Call

### Parameters
#### Path Parameters
- **Filename** (string) - Required - Path to the YAML file.

#### Options
- **detailed_constr** (boolean) - Optional - If true, returns records with line/column information and YAML tags.
- **map_node_format** (atom) - Optional - Set to 'map' to return Erlang maps instead of proplists.

### Response
- **Result** (list) - A list of parsed YAML documents.
```

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

### Add yamerl Dependency in Erlang.mk

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Include yamerl as a dependency in your Makefile when using Erlang.mk for project management.

```makefile
DEPS = yamerl
```

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

### Extract Node Location Information in Erlang

Source: https://context7.com/yakaz/yamerl/llms.txt

Use detailed construction mode to retrieve line and column metadata for YAML nodes.

```erlang
%% Parse with detailed mode to get position information
[{yamerl_doc, Root}] = yamerl_constr:string("key: value", [{detailed_constr, true}]).

%% Get line number of a node
Line = yamerl_constr:node_line(Root).
%% Returns: 1

%% Get column number of a node
Column = yamerl_constr:node_column(Root).
%% Returns: 1

%% Get full presentation details
Details = yamerl_constr:get_pres_details(Root).
%% Returns: [{line, 1}, {column, 1}]
```

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

### Parse YAML Stream Chunks

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Process a YAML stream by feeding it in chunks to the parser. Initialize with yamerl_constr:new/1, process with next_chunk/3, and finalize with last_chunk/3.

```erlang
% Initialize a new construction state. It takes a term describing the
% source; it may be any Erlang term.
Parser0 = yamerl_constr:new({file, "<stdin>"}),

% Read chunks and feed the parser. A new parser state is returned.
{continue, Parser1} = yamerl_constr:next_chunk(Parser0, Chunk1),
% ...
{continue, Parser2} = yamerl_constr:next_chunk(Parser1, Chunk2),

% When the stream ends, tell the parser it's the last chunk.
Documents = yamerl_constr:last_chunk(Parser2, Chunk3).
```

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

### Add yamerl Dependency in Mix

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Incorporate yamerl into your Elixir project by specifying it as a dependency in your mix.exs file.

```elixir
def project do
  [
    deps: [{:yamerl, "~> 0.8.0"}]
  ]
end
```

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

### Parse YAML String with yamerl:decode/1

Source: https://context7.com/yakaz/yamerl/llms.txt

Use the convenience wrapper yamerl:decode/1 for simple YAML string parsing. It handles sequences, mappings, and multiple documents within a single string.

```erlang
%% Parse a simple string
yamerl:decode("Hello World!").
%% Returns: ["Hello World!"]

%% Parse a YAML sequence
yamerl:decode("- item1\n- item2\n- item3").
%% Returns: [["item1", "item2", "item3"]]

%% Parse a YAML mapping
yamerl:decode("name: John\nage: 30").
%% Returns: [[{"name", "John"}, {"age", 30}]]

%% Parse multiple YAML documents in one string
yamerl:decode("---\nfirst\n---\nsecond").
%% Returns: ["first", "second"]
```

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

### Integrate yamerl in Elixir

Source: https://context7.com/yakaz/yamerl/llms.txt

Use Erlang interop syntax to parse YAML files or strings within an Elixir application.

```elixir
# Add to mix.exs dependencies
defp deps do
  [{:yamerl, "~> 0.10.0"}]
end

# Start application and parse YAML
defmodule MyApp.YamlParser do
  def parse_simple(filename) do
    Application.start(:yamerl)
    :yamerl_constr.file(filename)
  end

  def parse_detailed(filename) do
    Application.start(:yamerl)
    :yamerl_constr.file(filename, [:detailed_constr])
  end

  def parse_string(yaml_string) do
    Application.start(:yamerl)
    :yamerl_constr.string(yaml_string)
  end
end

# Usage
MyApp.YamlParser.parse_string("name: Alice\nrole: admin")
# Returns: [[{'name', 'Alice'}, {'role', 'admin'}]]

MyApp.YamlParser.parse_detailed("config.yaml")
# Returns detailed records with Elixir atom syntax for record names
```

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

### Handle Parsing Errors in Erlang

Source: https://context7.com/yakaz/yamerl/llms.txt

Catch yamerl_exception records to process parsing errors or invalid configuration options.

```erlang
%% Catch parsing errors
try
    yamerl_constr:string("'unterminated string")
catch
    throw:{yamerl_exception, Errors} ->
        %% Errors is a list of error records
        lists:foreach(fun(Error) ->
            case Error of
                {yamerl_parsing_error, Type, Text, Line, Column, Name, Token, Extra} ->
                    io:format("Error at line ~p, column ~p: ~s~n", [Line, Column, Text]);
                _ ->
                    io:format("Unknown error: ~p~n", [Error])
            end
        end, Errors)
end.

%% Example error output:
%% Error at line 1, column 22: Unexpected end-of-stream while parsing flow scalar

%% Invalid option handling
try
    yamerl_constr:string("test", [{invalid_option, value}])
catch
    throw:{yamerl_exception, [{yamerl_invalid_option, _, Text, Option}]} ->
        io:format("Invalid option ~p: ~s~n", [Option, Text])
end.
```

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

### yamerl:decode/1

Source: https://context7.com/yakaz/yamerl/llms.txt

Parses a YAML string into basic Erlang types.

```APIDOC
## yamerl:decode/1

### Description
Parses a YAML string and returns basic Erlang types (strings, integers, lists, proplists/maps).

### Parameters
#### Request Body
- **yaml_string** (string) - Required - The YAML content to parse.

### Request Example
"- item1\n- item2"

### Response
#### Success Response (200)
- **result** (list) - A list containing the parsed YAML documents.
```

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

### Parse YAML String

Source: https://github.com/yakaz/yamerl/blob/master/README.md

Parse a YAML document directly from a string using yamerl_constr:string/1. This function returns a list of documents, even if only one is present.

```erlang
yamerl_constr:string("Hello World!").
```

```erlang
% List of documents; here, only one document.
[
 % Document #1; contains a single scalar.
 "Hello World!"
]
```

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

### Stream Parsing API

Source: https://context7.com/yakaz/yamerl/llms.txt

Functions for parsing YAML from streaming data sources by feeding chunks incrementally.

```APIDOC
## yamerl_constr:new/2, next_chunk/2, last_chunk/2

### Description
Initializes a stream parser and processes YAML data in chunks, useful for large files or network streams.

### Method
Erlang Function Call

### Parameters
- **Source** (tuple) - Required - The data source, e.g., {file, "<stdin>"}.
- **Options** (list) - Optional - Configuration options like {detailed_constr, true}.

### Response
- **Result** (list) - Returns the parsed documents once the final chunk is processed.
```

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

### Parse YAML Streams with yamerl_constr

Source: https://context7.com/yakaz/yamerl/llms.txt

Incrementally feed chunks of data to the parser using next_chunk/2 and finalize with last_chunk/2.

```erlang
%% Initialize a new stream parser
Parser0 = yamerl_constr:new({file, "<stdin>"}),

%% Feed chunks to the parser
{continue, Parser1} = yamerl_constr:next_chunk(Parser0, <<"He">>),
{continue, Parser2} = yamerl_constr:next_chunk(Parser1, <<"ll">>),
{continue, Parser3} = yamerl_constr:next_chunk(Parser2, <<"o ">>),

%% Signal end of stream and get results
Documents = yamerl_constr:last_chunk(Parser3, <<"World!">>).
%% Returns: ["Hello World!"]

%% Stream parsing with detailed mode
Parser0 = yamerl_constr:new({file, "<stdin>"}, [{detailed_constr, true}]),
{continue, Parser1} = yamerl_constr:next_chunk(Parser0, <<"name: ">>),
Documents = yamerl_constr:last_chunk(Parser1, <<"Alice">>).
%% Returns detailed records with position information
```

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

### Parse Timestamps with yamerl_node_timestamp

Source: https://context7.com/yakaz/yamerl/llms.txt

Register the timestamp node module to convert YAML date strings into Erlang datetime tuples.

```erlang
%% Register timestamp node module
yamerl_app:set_param(node_mods, [yamerl_node_timestamp]).

%% Parse various timestamp formats
yamerl_constr:string("- 2011-05-26\n- 14:58:03\n- 2011-05-26 14:58:03", [
    {detailed_constr, false}
]).
%% Returns:
%% [[{{2011, 5, 26}, undefined},
%%   {undefined, {14, 58, 3}},
%%   {{2011, 5, 26}, {14, 58, 3}}]]

%% Detailed timestamp output
yamerl_constr:string("2011-05-26T14:58:03Z", [
    {detailed_constr, true},
    {node_mods, [yamerl_node_timestamp]}
]).
%% Returns timestamp record with year, month, day, hour, minute, second, timezone
```

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

### Parse String with yamerl_constr:string/1

Source: https://context7.com/yakaz/yamerl/llms.txt

Use yamerl_constr:string/1 for parsing in-memory YAML strings into basic Erlang types like scalars, lists, and proplists/maps. Supports nested structures.

```erlang
%% Parse a simple scalar
yamerl_constr:string("Hello!").
%% Returns: ["Hello!"]

%% Parse a sequence (list)
yamerl_constr:string("[1, 2, 3]").
%% Returns: [[1, 2, 3]]

%% Parse a mapping (proplist)
yamerl_constr:string("{key: value, count: 42}").
%% Returns: [[{"key", "value"}, {"count", 42}]]

%% Parse nested structures
yamerl_constr:string("users:\n  - name: Alice\n    role: admin\n  - name: Bob\n    role: user").
%% Returns:
%% [[ [{"users", [[{"name", "Alice"}, {"role", "admin"}],
%%               [{"name", "Bob"}, {"role", "user"}]}]]] 
```
Tokens:
Raw