--- %YAML:1.0
test: Simple Sequence 
brief: | 
    You can specify a list in YAML by placing each 
    member of the list on a new line with an opening 
    dash. These lists are called sequences. 
yaml: | 
    - apple 
    - banana 
    - carrot 
perl: |
    ['apple', 'banana', 'carrot']  
python: |
    [  
        ['apple', 'banana', 'carrot']  
    ] 
ruby: |
    ['apple', 'banana', 'carrot']  
 
--- 
test: Nested Sequences 
brief: | 
    You can include a sequence within another 
    sequence by giving the sequence an empty 
    dash, followed by an indented list. 
yaml: | 
    - 
     - foo 
     - bar 
     - baz 
perl: | 
    [['foo', 'bar', 'baz']] 
python: | 
    [ 
        [['foo', 'bar', 'baz']] 
    ] 
ruby: | 
    [['foo', 'bar', 'baz']] 
 
--- 
test: Mixed Sequences 
brief: | 
    Sequences can contain any YAML data, 
    including strings and other sequences. 
yaml: | 
    - apple 
    - 
     - foo 
     - bar 
     - x123 
    - banana 
    - carrot 
perl: | 
    ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'] 
python: | 
    [ 
        ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'] 
    ] 
ruby: | 
    ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'] 
 
--- 
test: Deeply Nested Sequences 
brief: | 
    Sequences can be nested even deeper, with each 
    level of indentation representing a level of 
    depth. 
yaml: | 
    - 
     - 
      - uno 
      - dos 
perl: | 
    [[['uno', 'dos']]] 
python: | 
    [ 
        [[['uno', 'dos']]] 
    ] 
ruby: | 
    [[['uno', 'dos']]] 
 
--- 
test: Simple Mapping 
brief: | 
    You can add a keyed list (also known as a dictionary or 
    hash) to your document by placing each member of the 
    list on a new line, with a colon seperating the key 
    from its value.  In YAML, this type of list is called 
    a mapping. 
yaml: | 
    foo: whatever 
    bar: stuff 
perl: | 
    { foo => 'whatever', bar => 'stuff' } 
python: | 
    [ 
        {'foo': 'whatever', 'bar': 'stuff'} 
    ] 
ruby: | 
    { 'foo' => 'whatever', 'bar' => 'stuff' } 
 
--- 
test: Sequence in a Mapping 
brief: | 
    A value in a mapping can be a sequence. 
yaml: | 
    foo: whatever 
    bar: 
     - uno 
     - dos 
perl: | 
    { foo => 'whatever', bar => [ 'uno', 'dos' ] } 
python: | 
    [ 
        {'foo': 'whatever', 'bar': ['uno', 'dos']} 
    ] 
ruby: | 
    { 'foo' => 'whatever', 'bar' => [ 'uno', 'dos' ] } 
 
--- 
test: Nested Mappings 
brief: | 
    A value in a mapping can be another mapping. 
yaml: | 
    foo: whatever 
    bar: 
     fruit: apple 
     name: steve 
     sport: baseball 
perl: | 
    { foo => 'whatever',  
      bar => { 
         fruit => 'apple',  
         name => 'steve', 
         sport => 'baseball' 
       } 
    } 
python: | 
    [ 
        {'foo': 'whatever',  
         'bar': { 
            'fruit': 'apple',  
            'name': 'steve', 
            'sport': 'baseball' 
            } 
        } 
    ] 
ruby: | 
    { 'foo' => 'whatever',  
      'bar' => { 
         'fruit' => 'apple',  
         'name' => 'steve', 
         'sport' => 'baseball' 
       } 
    } 
 
--- 
test: Mixed Mapping 
brief: | 
    A mapping can contain any assortment 
    of mappings and sequences as values. 
yaml: | 
    foo: whatever 
    bar: 
     - 
       fruit: apple 
       name: steve 
       sport: baseball 
     - more 
     - 
       python: rocks 
       perl: papers 
       ruby: scissorses 
perl: | 
    { foo => 'whatever',  
      bar => [ 
        { 
            fruit => 'apple',  
            name => 'steve', 
            sport => 'baseball' 
        }, 
        'more', 
        { 
            python => 'rocks', 
            perl => 'papers', 
            ruby => 'scissorses' 
        } 
      ] 
    } 
python: | 
    [ 
        {'foo': 'whatever',  
         'bar': [ 
            { 
                'fruit': 'apple',  
                'name': 'steve', 
                'sport': 'baseball' 
            }, 
            'more', 
            { 
                'python': 'rocks', 
                'perl':  'papers', 
                'ruby': 'scissorses' 
            } 
         ] 
        } 
    ] 
ruby: | 
    { 'foo' => 'whatever',  
      'bar' => [ 
        { 
            'fruit' => 'apple',  
            'name' => 'steve', 
            'sport' => 'baseball' 
        }, 
        'more', 
        { 
            'python' => 'rocks', 
            'perl' => 'papers', 
            'ruby' => 'scissorses' 
        } 
      ] 
    } 
 
--- 
test: Mapping-in-Sequence Shortcut 
brief: | 
     If you are adding a mapping to a sequence, you 
     can place the mapping on the same line as the 
     dash as a shortcut. 
yaml: | 
     - work on YAML.py: 
        - work on Store 
perl: | 
    [ { 'work on YAML.py' => ['work on Store'] } ] 
python: | 
    [ 
        [ {'work on YAML.py': ['work on Store']} ] 
    ] 
ruby: | 
    [ { 'work on YAML.py' => ['work on Store'] } ] 

---
test: Sequence-in-Mapping Shortcut
brief: |
     The dash in a sequence counts as indentation, so
     you can add a sequence inside of a mapping without
     needing spaces as indentation.
yaml: |
     allow:
     - 'localhost'
     - '%.sourceforge.net'
     - '%.freepan.org'
perl: |
     { 'allow' => [ 'localhost', '%.sourceforge.net', '%.freepan.org' ] }
python: |
     [
         { 'allow': [ 'localhost', '%.sourceforge.net', '%.freepan.org' ] }
     ]
ruby: |
     { 'allow' => [ 'localhost', '%.sourceforge.net', '%.freepan.org' ] }

---
test: Merge key
brief: |
     A merge key ('<<') can be used in a mapping to insert other mappings.  If
     the value associated with the merge key is a mapping, each of its key/value
     pairs is inserted into the current mapping.
yaml: |
     mapping:
       name: Joe
       job: Accountant
       <<:
         age: 38
ruby: |
     { 'mapping' =>
       { 'name' => 'Joe',
         'job' => 'Accountant',
         'age' => 38
       }
     }