YAML

https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/
Admin
YAML is a human-friendly, cross-language data serialization language designed for configuration...
Tokens:37,774
Snippets:412
Trust Score:7.4
Update:10 months ago
Show doc for...
Tokens:
Raw
### YAML: Example Document Prefix

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating a document prefix in YAML. It includes comment lines before the actual document content ('Document').

```yaml
⇔# Comment
# lines
Document
```

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

### Directives Document Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates directives documents in YAML, showing examples with YAML version directives and content, including empty documents.

```yaml
%YAML 1.2
---
- |-
  %!PS-Adobe-2.0
...
%YAML1.2
---
# Empty
...
```

```yaml
%YAML 1.2
---
!!str "%!PS-Adobe-2.0\n"
...
%YAML 1.2
---
!!null ""
```

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

### YAML Document Markers Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the usage of YAML document markers. Includes the YAML version, document start marker (---), content, and document end marker (...).

```yaml
%YAML 1.2
---
Document
...
# Suffix
```

```yaml
%YAML 1.2
---
!!str "Document"
```

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

### YAML Single Pair Flow Mapping Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows an example of a single key-value pair used within a flow sequence, demonstrating the compact notation.

```yaml
[
foo: bar
]
```

```yaml
%YAML 1.2
---
!!seq [
  !!map { ? !!str "foo" : !!str "bar" }
]
```

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

### Bare Document Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates examples of bare YAML documents. Shows content that might be misinterpreted without proper document markers, and how to correctly represent such content.

```yaml
Bare
document
...
# No document
...
|
%!PS-Adobe-2.0 # Not the first line
```

```yaml
%YAML 1.2
---
!!str "Bare document"
%YAML 1.2
---
!!str "%!PS-Adobe-2.0\n"
```

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

### Explicit Document Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of explicit YAML documents. Shows documents starting with '---' followed by content or an empty document indicated by '...'.

```yaml
---
{ matches
% : 20 }
...
---
# Empty
...
```

```yaml
%YAML 1.2
---
!!map {
  !!str "matches %": !!int "20"
}
...
%YAML 1.2
---
!!null ""
```

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

### YAML Block Sequence Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating a simple block sequence in YAML, showing nested elements and key-value pairs within the sequence.

```yaml
block sequence:
  - one↓
  - two : three↓
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "block sequence"
  : !!seq [
    !!str "one",
    !!map {
      ? !!str "two"
      : !!str "three"
    },
  ],
}
```

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

### YAML Node Properties Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the application of node properties, specifically tags ('!!str') and anchors ('&a1', '&a2'). The first example shows a compact representation with properties before content. The second example uses a more verbose map structure with anchors and tags for keys and values.

```yaml
!!str &a1 "foo":
  !!str bar
&a2 baz : *a1
```

```yaml
%YAML 1.2
---
!!map {
  ? &B1 !!str "foo"
  : !!str "bar",
  ? !!str "baz"
  : *B1,
}
```

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

### YAML Generic Sequence Examples (`!!seq`)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the block and flow styles for YAML sequences using the `!!seq` tag. Sequences represent collections indexed by sequential integers starting from zero.

```yaml
Block style: !!seq
- Clark Evans
- Ingy döt Net
- Oren Ben-Kiki

Flow style: !!seq [ Clark Evans, Ingy döt Net, Oren Ben-Kiki ]
```

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

### YAML Stream Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides an example of a YAML stream containing multiple documents. Demonstrates the separation between documents using markers like '---' and '...'.

```yaml
Document
---
# Empty
...
%YAML 1.2
---
matches %: 20
```

```yaml
%YAML 1.2
---
!!str "Document"
...
%YAML 1.2
---
!!null ""
...
%YAML 1.2
---
!!map {
  !!str "matches %": !!int "20"
}
```

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

### YAML 1.2 Example: YAML Directive

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of the %YAML directive. The first example shows a %YAML 1.3 directive, indicating a higher version that should be parsed with a warning. The second example shows a valid %YAML 1.2 directive.

```yaml
%YAML 1.3 # Attempt parsing
           # with a warning
---
```

```yaml
%YAML 1.2
--- !!str "foo"
```

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

### YAML: Example Block Collection Nodes

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating nested block sequences and mappings in YAML. It shows a 'sequence' with a nested sequence and a 'mapping' with a key-value pair.

```yaml
sequence: !!seq
- entry
- !!seq
 - nested
mapping: !!map
 foo: bar
```

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

### YAML 1.2 Flow Sequence Entry Examples

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of different YAML 1.2 flow sequence entries, including various scalar types, nested structures, and key-value pairs.

```yaml
- [ one, two, ]
- [three ,four]

```

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

### YAML Flow Mapping Entry Examples

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of flow mapping entries, showcasing the use of explicit keys indicated by '?' and implicit keys.

```yaml
{
? explicit: entry,
implicit: entry,
?°°
}
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "explicit" : !!str "entry",
  ? !!str "implicit" : !!str "entry",
  ? !!null "" : !!null "",
}
```

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

### YAML Flow Mapping Examples

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the practical application of flow mappings with different entry styles and formatting.

```yaml
- { one : two , three: four , }
- {five: six,seven : eight}
```

```yaml
%YAML 1.2
---
!!seq [
  !!map {
    ? !!str "one"   : !!str "two",
    ? !!str "three" : !!str "four",
  },
  !!map {
    ? !!str "five"  : !!str "six",
    ? !!str "seven" : !!str "eight",
  },
]
```

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

### Plain Style Example (YAML)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of plain scalars in YAML 1.2, showcasing various valid string formats that do not require quotes. This demonstrates the readability and limitations of the plain style.

```yaml
# Outside flow collection:
- ::vector
- ": - ()"
- Up, up, and away!
- -123
- http://example.com/foo#bar

```

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

### YAML Directive Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example illustrating the use of the directive indicator '%'. It shows a YAML 1.2 version directive followed by document content.

```yaml
%YAML 1.2
---
text
```

```yaml
%YAML 1.2
---
!!str "text"
```

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

### YAML Verbatim Tag Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the use of verbatim tags. The first example shows '!<tag:yaml.org,2002:str>' and '!< !bar>' used with scalar values. The second example demonstrates their use within a YAML map structure.

```yaml
!<tag:yaml.org,2002:str> foo :
  !<!bar> baz
```

```yaml
%YAML 1.2
---
!!map {
  ? !<tag:yaml.org,2002:str> "foo"
  : !<!bar> "baz",
}
```

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

### YAML: Document Prefix Representation (YAML 1.2)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

The YAML 1.2 representation of the example document prefix. This shows how comments and the document content are structured, with the '---' indicating the start of a document.

```yaml
%YAML 1.2
---
!!str "Document"
```

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

### YAML Document Stream with End Marker Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows a YAML stream with '---' to start a document and '...' to explicitly signal the end of a document, often used in real-time data feeds.

```yaml
---
time: 20:03:20
player: Sammy Sosa
action: strike (miss)
...
---
time: 20:03:47
player: Sammy Sosa
action: grand slam
...
```

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

### YAML Multi-Line Comments Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows an example of multiple comment lines following a key-value pair. The subsequent lines are comments and are ignored in the parsed YAML.

```yaml
key:····# Comment↓
········# lines↓
  value↓
↓

```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "key"
  : !!str "value",
}

```

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

### YAML Tag Shorthand Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates tag shorthands. '%TAG !e! tag:example.com,2000:app/' defines a prefix for '!e!'. Examples include '!local' (assuming a default or prior definition), '!!str' (a standard shorthand), and '!e!tag%21' which uses URI encoding for '!'. The second example shows the expanded form.

```yaml
%TAG !e! tag:example.com,2000:app/
---
- !local foo
- !!str bar
- !e!tag%21 baz
```

```yaml
%YAML 1.2
---
!!seq [
  !<!local> "foo",
  !<tag:yaml.org,2002:str> "bar",
  !<tag:example.com,2000:app/tag!> "baz"
]
```

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

### Single-Quoted Implicit Keys Example (Verbose Representation)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides the verbose representation of the single-quoted implicit keys example, showing how these keys are structured in a more explicit YAML format. This is useful for understanding YAML's data serialization.

```yaml
%YAML 1.2
---
!!map {
  ? !!str "implicit block key"
  : !!seq [
    !!map {
      ? !!str "implicit flow key"
      : !!str "value",
    }
  ]
}

```

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

### YAML Block Structure Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating the use of block sequence and mapping indicators in YAML. It shows a sequence with two items and a mapping with two key-value pairs.

```yaml
sequence:
- one
- two
mapping:
  ? sky
  : blue
  sea : green
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "sequence"
  : !!seq [ !!str "one", !!str "two" ],
  ? !!str "mapping"
  : !!map {
    ? !!str "sky" : !!str "blue",
    ? !!str "sea" : !!str "green",
  },
}
```

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

### YAML Sequence of Mappings Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates a YAML sequence where each entry is a mapping (key-value pairs), suitable for representing a list of objects, such as player records.

```yaml
- 
  name: Mark McGwire
  hr:   65
  avg:  0.278
- 
  name: Sammy Sosa
  hr:   63
  avg:  0.288
```

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

### YAML Separation Spaces Example (Parsed)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Presents the parsed YAML 1.2 structure for the separation spaces example, demonstrating how the separated tokens are interpreted into a valid YAML document.

```yaml
%YAML 1.2
---
!!seq [
  !!map {
    ? !!str "foo" : !!str "bar",
  },
  !!seq [ !!str "baz", !!str "baz" ],
]
```

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

### YAML Comment Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Examples demonstrating the use of the comment indicator '#'. The first shows a line containing only a comment, and the second shows multiple lines of comments.

```yaml
# Comment only.
```

```yaml
# This stream contains no
# documents, only comments.
```

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

### YAML Empty Lines Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates empty lines in YAML, showing examples for folding and chomping block scalar styles. It highlights how empty lines are treated as line feeds or ignored based on the style.

```text
Folding:
  "Empty line
···→
  as a line feed"
Chomping: |
  Clipped empty lines
·

```

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

### YAML Flow Collection Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example illustrating the use of flow collection indicators. It shows a sequence and a mapping written inline using brackets, braces, and commas.

```yaml
sequence: [ one, two, ]
mapping: { sky: blue, sea: green }
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "sequence"
  : !!seq [ !!str "one", !!str "two" ],
  ? !!str "mapping"
  : !!map {
    ? !!str "sky" : !!str "blue",
    ? !!str "sea" : !!str "green",
  },
}
```

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

### YAML 1.2 Example: Separation Spaces

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the use of separation spaces in YAML, showing how key-value pairs and comments are formatted within a map structure. The example includes inline comments and multi-line values.

```yaml
{Â·first:Â·Sammy,Â·last:Â·SosaÂ·}:â21e
# Statistics:
Â standar Â standar hr:Â·# Home runs
Â standar Â standar Â standar 65
Â standar Â standar avg:Â·# Average
Â standar Â standar Â standar 0.278
```

```yaml
%YAML 1.2
---
!!map {
  ? !!map {
    ? !!str "first"
    : !!str "Sammy",
    ? !!str "last"
    : !!str "Sosa",
  }
  : !!map {
    ? !!str "hr"
    : !!int "65",
    ? !!str "avg"
    : !!float "0.278",
  },
}
```

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

### YAML Separated Comment Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows an example of a comment separated by whitespace from a key-value pair. The comment is ignored in the parsed YAML content.

```yaml
key:····# Comment↓
  value_eof_

```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "key"
  : !!str "value",
}

```

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

### YAML Line Prefixes Example (Parsed)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Presents the parsed YAML 1.2 structure for the line prefixes example, showing how the scalar content is represented, including newlines and preserved whitespace where applicable.

```yaml
%YAML 1.2
---
!!map {
  ? !!str "plain"
  : !!str "text lines",
  ? !!str "quoted"
  : !!str "text lines",
  ? !!str "block"
  : !!str "text\n·→lines\n",
}
```

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

### YAML Null Examples (`!!null`)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of representing null values in YAML using the `!!null` tag. Null represents the lack of a value and is distinct from an empty string.

```yaml
!!null null: value for null key
key with null value: !!null null
```

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

### YAML 1.2 Flow Sequence Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates a basic YAML 1.2 flow sequence containing various scalar types and a nested sequence.

```yaml
%YAML 1.2
---
!!seq [
  !!str "::vector",
  !!str ": - () ",
  !!str "Up, up and away!",
  !!int "-123",
  !!str "http://example.com/foo#bar",
  !!seq [
    !!str "::vector",
    !!str ": - () ",
    !!str "Up, up and away!",
    !!int "-123",
    !!str "http://example.com/foo#bar",
  ],
]

```

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

### YAML Node Property Indicators Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example showcasing the use of tag, anchor, and alias indicators in YAML. It defines a value with an anchor and then references it using an alias.

```yaml
anchored: !local &anchor value
alias: *anchor
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "anchored"
  : !local &A1 "value",
  ? !!str "alias"
  : *A1,
}
```

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

### YAML Flow Sequence Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates a YAML flow sequence, which uses square brackets and commas to define a list of scalar values, offering a more compact representation.

```yaml
- [name        , hr, avg  ]
- [Mark McGwire, 65, 0.278]
- [Sammy Sosa  , 63, 0.288]
```

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

### YAML Separation Spaces Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the use of separation spaces in YAML, showing how whitespace between tokens like keys, values, and collection entries is handled.

```text
-·foo:→·bar
- -·baz
  -→baz
```

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

### YAML Indentation Indicators Example (Parsed)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows the parsed YAML 1.2 structure corresponding to the indentation indicators example, illustrating how YAML interprets these characters and their associated indentation.

```yaml
%YAML 1.2
---
!!map {
  ? !!str "a"
  : !!seq [
    !!str "b",
    !!seq [ !!str "c", !!str "d" ]
  ],
}
```

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

### YAML Empty Lines Example (Parsed)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows the parsed YAML 1.2 structure for the empty lines example. It illustrates how empty lines are interpreted, particularly in the context of folding and chomping scalar styles.

```yaml
%YAML 1.2
---
!!map {
  ? !!str "Folding"
  : !!str "Empty line\nas a line feed",
  ? !!str "Chomping"
  : !!str "Clipped empty lines\n",
}
```

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

### YAML 1.2 Local Tag Prefix Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the use of local tag prefixes with the TAG directive. In both examples, '!m!' is mapped to the prefix '!my-', creating local tags '!<my-light>' which are resolved to different values ('fluorescent' and 'green') based on their context.

```yaml
%TAG !m! !my-
---
# Bulb here
!m!light fluorescent
...
%TAG !m! !my-
---
# Color here
!m!light green
```

```yaml
%YAML 1.2
---
!<!my-light> "fluorescent"
...
%YAML 1.2
---
!<!my-light> "green"
```

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

### YAML 1.2 TAG Directive Examples

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the usage of the TAG directive to define custom tag shorthands. The first example shows how to associate a handle '!yaml!' with the prefix 'tag:yaml.org,2002:', and the second demonstrates mapping '!!' to 'tag:yaml.org,2002:'.

```yaml
%TAG !yaml! tag:yaml.org,2002:
---
!yaml!str "foo"
```

```yaml
%YAML 1.2
---
!!str "foo"
```

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

### YAML Generic String Examples (`!!str`)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows examples of representing Unicode strings in YAML using both block and flow styles with the `!!str` tag. This type is typically bound to native string types.

```yaml
Block style: !!str |-
  String: just a theory.

Flow style: !!str "String: just a theory."
```

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

### YAML Indentation Example (Parsed Structure)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Represents the visual indentation example as parsed YAML 1.2, demonstrating how indentation is interpreted into nested maps and sequences. This highlights the structural outcome of indentation.

```yaml
%YAML 1.2
- - -
!!map {
  ? !!str "Not indented"
  : !!map {
      ? !!str "By one space"
      : !!str "By four\n  spaces\n",
      ? !!str "Flow style"
      : !!seq [
          !!str "By two",
          !!str "Also by two",
          !!str "Still by two",
        ]
    }
}
```

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

### YAML 1.2 Example: Reserved Directives

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the usage of reserved directives in YAML. The example shows a '%FOO' directive with parameters, which should be ignored by a compliant processor with a warning. It also shows a valid %YAML directive.

```yaml
%FOO  bar baz # Should be ignored
               # with a warning.
--- "foo"
```

```yaml
%YAML 1.2
--- !!str
"foo"
```

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

### Single-Quoted Implicit Keys Example (YAML)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the use of single-quoted scalars as keys in implicit mappings within YAML 1.2. This example highlights how single quotes are handled in key-value pairs.

```yaml
'implicit block key' : [
  'implicit flow key' : value,
 ]

```

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

### Single-Quoted Lines Example (YAML)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates line folding within single-quoted scalars in YAML 1.2. This example shows how multiple lines are treated as a single string, including the handling of empty lines and whitespace.

```yaml
'·1st non-empty↓
↓
·2nd non-empty·
→3rd non-empty·'

```

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

### YAML Anchor and Alias Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates YAML anchors ('&') to define a node and aliases ('*') to reference it, enabling data reuse and reducing redundancy within a document.

```yaml
---
hr:
  - Mark McGwire
  # Following node labeled SS
  - &SS Sammy Sosa
rbi:
  - *SS # Subsequent occurrence
  - Ken Griffey
```

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

### YAML Global Tag Prefix Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates the use of a global tag prefix '%TAG !e! tag:example.com,2000:app/' to define a shorthand '!e!'. This shorthand is then used to tag a scalar value 'foo' as '!e!foo'. The second example shows the expanded form where the shorthand is replaced by its full URI.

```yaml
%TAG !e! tag:example.com,2000:app/
---
- !e!foo "bar"
```

```yaml
%YAML 1.2
---
!<tag:example.com,2000:app/foo> "bar"
```

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

### YAML Sequence of Scalars Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates a simple YAML sequence where each entry is a scalar value, commonly used for lists of items like names.

```yaml
- Mark McGwire
- Sammy Sosa
- Ken Griffey
```

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

### JSON Tag Resolution Example in YAML

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

This example demonstrates how YAML 1.2 interprets JSON-like structures and resolves tags based on content and explicit tags. It covers null, booleans, integers, and floats, showing how unresolvable types are marked.

```yaml
%YAML 1.2
---
!!map {
  !!str "A null" : !!null "null",
  !!str "Booleans: !!seq [
    !!bool "true", !!bool "false"
  ],
  !!str "Integers": !!seq [
    !!int "0", !!int "-0",
    !!int "3", !!int "-19"
  ],
  !!str "Floats": !!seq [
    !!float "0.", !!float "-0.0",
    !!float "12e03", !!float "-2E+05"
  ],
  !!str "Invalid": !!seq [
    # Rejected by the schema
    True, Null, 0o7, 0x3A, +12.3,
  ],
}
...
```

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

### YAML Literal Style Scalar Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Presents a basic example of the YAML literal style ('|') scalar, showing how newlines and indentation are preserved as content. The 'code' displays the YAML structure, and 'codeList' provides the corresponding JSON representation.

```yaml
|↓
·literal↓
·→text↓
↓
```

```json
%YAML 1.2
---
!!str "literal\n\ttext\n"
```

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

### YAML 1.2 Secondary Tag Handle Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows the secondary tag handle '!!' being used with a custom prefix defined by a TAG directive. The example maps '!!' to 'tag:example.com,2000:app/' and then uses '!!int' to refer to a specific tag within that namespace.

```yaml
%TAG !! tag:example.com,2000:app/
---
!!int 1 - 3 # Interval, not integer
```

```yaml
%YAML 1.2
---
!<tag:example.com,2000:app/int> "1 - 3"
```

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

### YAML Comment Lines Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates YAML comment lines, including a line with only whitespace. The output shows the resulting content, which is empty.

```yaml
··# Comment↓
···↓
↓

```

```text
# This stream contains no
# documents, only comments.

```

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

### YAML Invalid Verbatim Tags Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Provides examples of invalid verbatim tags. '!<>' is invalid because the '!' requires a subsequent character, and '!<$:?>' is invalid because it's neither a valid URI nor a local tag starting with '!'.

```yaml
- !<!> foo
- !<$:?> bar
```

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

### YAML 1.2 Core Tag Resolution Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the resolution of various data types in YAML 1.2 according to the core schema, including nulls, booleans, integers, floats, and strings. This example showcases how different representations are mapped to their corresponding YAML tags.

```yaml
A null: null
Also a null: # Empty
Not a null: ""
Booleans: [ true, True, false, FALSE ]
Integers: [ 0, 0o7, 0x3A, -19 ]
Floats: [ 0., -0.0, .5, +12e03, -2E+05 ]
Also floats: [ .inf, -.Inf, +.INF, .NAN ]
```

```yaml
%YAML 1.2
---
!!map {
  !!str "A null" : !!null "null",
  !!str "Also a null" : !!null "",
  !!str "Not a null" : !!str "",
  !!str "Booleans: !!seq [
    !!bool "true", !!bool "True",
    !!bool "false", !!bool "FALSE",
  ],
  !!str "Integers": !!seq [
    !!int "0", !!int "0o7",
    !!int "0x3A", !!int "-19",
  ],
  !!str "Floats": !!seq [
    !!float "0.", !!float "-0.0", !!float ".5",
    !!float "+12e03", !!float "-2E+05"
  ],
  !!str "Also floats": !!seq [
    !!float ".inf", !!float "-.Inf",
    !!float "+.INF", !!float ".NAN",
  ],
}
...
```

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

### YAML Flow Mapping Adjacent Value Examples

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the compact notation for JSON-like keys where the value is adjacent to the colon, improving JSON compatibility.

```yaml
{
"adjacent":value,
"readable":·value,
"empty":°
}
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "adjacent" : !!str "value",
  ? !!str "readable" : !!str "value",
  ? !!str "empty"    : !!null "",
}
```

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

### YAML Flow Mapping Separate Value Examples

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates scenarios where values are separated from keys by whitespace or are omitted, including URLs and empty values.

```yaml
{
unquoted·:·"separate",
http://foo.com,
omitted value:°,
°:·omitted key,
}
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "unquoted" : !!str "separate",
  ? !!str "http://foo.com" : !!null "",
  ? !!str "omitted value" : !!null "",
  ? !!null "" : !!str "omitted key",
}
```

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

### YAML Complex Mapping Key Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates using a question mark ('?') to indicate a complex key in a YAML mapping, such as a sequence as a key, which is then followed by its value.

```yaml
? - Detroit Tigers
  - Chicago cubs
:
  - 2001-07-23

? [ New York Yankees,
    Atlanta Braves ]
: [ 2001-07-02, 2001-08-12,
    2001-08-14 ]
```

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

### YAML Generic Mapping Examples (`!!map`)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the block and flow styles for representing generic mappings in YAML using the `!!map` tag. Mappings represent associative containers with unique keys.

```yaml
Block style: !!map
  Clark : Evans
  Ingy  : döt Net
  Oren  : Ben-Kiki

Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }
```

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

### YAML Line Prefixes Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates line prefixes in different YAML scalar styles (plain, quoted, block). It visually shows how indentation and whitespace contribute to the prefix, which is a presentation detail.

```text
plain: text
··lines
quoted: "text
··→lines"
block: |
··text
···→lines
```

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

### YAML Indentation Example (Visual Representation)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Illustrates YAML indentation rules with visual markers for spaces. It shows how leading spaces in comments and different indentation levels affect structure, differentiating content from presentation.

```text
··# Leading comment line spaces are
···# neither content nor indentation.
····
Not indented:
·By one space: |
····By four
······spaces
·Flow style: [    # Leading spaces
···By two,        # in flow style
··Also by two,    # are neither
··→Still by two   # content nor
····]             # indentation.
```

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

### YAML Flow Mapping Start Indicator ({)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

The left brace '{' character indicates the start of a flow mapping. It precedes the key-value pairs when a mapping is written inline.

```yaml
[#] c-mapping-start ::= "{"
```

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

### YAML Quoted Scalar Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example showing the usage of single and double-quoted scalars in YAML. It demonstrates how to enclose scalar values within single or double quotes.

```yaml
single: 'text'
double: "text"
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "single"
  : !!str "text",
  ? !!str "double"
  : !!str "text",
}
```

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

### YAML Block Scalar Indicators Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating the use of literal and folded block scalar indicators. It shows how '|' preserves newlines and '>' folds them into spaces.

```yaml
literal: |
  some
  text
folded: >
  some
  text
```

```yaml
%YAML 1.2
---
!!map {
  ? !!str "literal"
  : !!str "some\ntext\n",
  ? !!str "folded"
  : !!str "some text\n",
}
```

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

### YAML Flow Mapping Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows a YAML flow mapping using curly braces and commas to define key-value pairs, suitable for compact inline object representations.

```yaml
Mark McGwire: {hr: 65, avg: 0.278}
Sammy Sosa: {
    hr: 63,
    avg: 0.288
  }
```

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

### YAML Invalid Use of Reserved Indicators Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating the invalid use of reserved indicators '@' and '`' at the beginning of a plain scalar. This usage is disallowed and will result in a parsing error.

```yaml
commercial-at: @text
grave-accent: `text
```

```text
ERROR:
 Reserved indicators can't
 start a plain scalar.
```

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

### YAML Full Example - Log File

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

A complete YAML document representing a log file, demonstrating multiple documents separated by '---', timestamps, string values, and literal block scalars for code snippets.

```yaml
---\nTime: 2001-11-23 15:01:42 -5
User: ed
Warning:
  This is an error message
  for the log file
---\nTime: 2001-11-23 15:02:31 -5
User: ed
Warning:
  A slightly different error
  message.
---\nDate: 2001-11-23 15:03:17 -5
User: ed
Fatal:
  Unknown variable "bar"
Stack:
  - file: TopClass.py
    line: 23
    code: |
      x = MoreObject("345\n")
  - file: MoreClass.py
    line: 58
    code: |-
      foo = bar

```

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

### YAML Flow Folding Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates line folding in YAML's flow style. Unlike block folding, all line breaks are folded into spaces, and leading/trailing spaces are discarded.

```yaml
"↓
··foo·↓
·↓
··→·bar↓
↓
··baz↓ "

```

```yaml
%YAML 1.2
---
!!str " foo\nbar\nbaz "

```

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

### YAML Document Separator Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the use of '---' to separate multiple YAML documents within a single stream, allowing for distinct data sets to be transmitted together.

```yaml
# Ranking of 1998 home runs
---
- Mark McGwire
- Sammy Sosa
- Ken Griffey

# Team ranking
---
- Chicago Cubs
- St Louis Cardinals
```

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

### YAML 1.2 Primary Tag Handle Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the use of the primary tag handle '!'. The first part shows a local tag '!foo'. The second part uses a TAG directive to associate '!' with 'tag:example.com,2000:app/' and then uses '!foo' to refer to a global tag.

```yaml
# Private
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"
```

```yaml
%YAML 1.2
---
!<!foo> "bar"
...
---
!<tag:example.com,2000:app/foo> "bar"
```

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

### YAML Node Anchor Example

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the usage of node anchors in YAML 1.2. It shows how to define an anchor '&anchor' for a value and then reference it using an alias '*anchor' in a subsequent part of the document.

```YAML
First occurrence: &anchor Value
Second occurrence: *anchor
```

```YAML
%YAML 1.2
---
!!map {
  ? !!str "First occurrence"
  : &A !!str "Value",
  ? !!str "Second occurrence"
  : *A,
}
```

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

### YAML: Example Block Scalar Nodes

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example illustrating literal and folded block scalar styles in YAML. The 'literal' style uses '|' to preserve newlines, while the 'folded' style uses '>' to fold newlines into spaces.

```yaml
literal: |2
··value
folded:↓
···!foo
··>1
·value
```

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

### Single-Quoted Lines Example (Verbose Representation)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Presents the verbose interpretation of the single-quoted lines example, showing how line breaks and whitespace are preserved or transformed in the parsed YAML. This is essential for data integrity when dealing with multi-line strings.

```yaml
%YAML 1.2
---
!!str " 1st non-empty\n\
      2nd non-empty \
      3rd non-empty "

```

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

### YAML Explicit Tags - String, Binary, and Local

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the use of explicit tags ('!!' and '!') to denote the type of a node. Includes examples for string, binary data, and application-specific local tags.

```yaml
---\nnot-date: !!str 2002-04-28

picture: !!binary |
 R0lGODlhDAAMAIQAAP//9/X
 17unp5WZmZgAAAOfn515eXv
 Pz7Y6OjuDg4J+fn5OTk6enp
 56enmleECcgggoBADs=

application specific tag: !something |
 The semantics of the tag
 above may be different for
 different documents.

```

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

### YAML: Example Block Node Structure

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

An example demonstrating different types of block nodes within a YAML document. It includes a flow node ('flow in block'), a block scalar ('Block scalar'), and a block collection ('foo : bar').

```yaml
-↓
··"flow in block"↓
-·>
 Block scalar↓
-·!!map # Block collection
  foo : bar↓
```

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

### YAML Global Tags - Shorthand Notation

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Shows how global tags can be defined using a %TAG directive and then referenced using shorthand handles (!). This example defines a '!shape' tag and uses it for 'circle', 'line', and 'label' nodes.

```yaml
%TAG ! tag:clarkevans.com,2002:
---\n!shape
  # Use the ! handle for presenting
  # tag:clarkevans.com,2002:circle
- !circle
  center: &ORIGIN {x: 73, y: 129}
  radius: 7
- !line
  start: *ORIGIN
  finish: { x: 89, y: 102 }
- !label
  start: *ORIGIN
  color: 0xFFEEBB
  text: Pretty vector drawing.

```

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

### Single-Quoted Style Example (YAML)

Source: https://raw.githubusercontent.com/yaml/yaml-spec/refs/heads/main/spec/1.2/markdown/spec

Demonstrates the representation of single-quoted strings in YAML 1.2, including how to escape single quotes within the string. This shows a practical application of the single-quoted style rules.

```yaml
'here''s to "quotes"'

```
Tokens:
Raw