1YAML::PP(3) User Contributed Perl Documentation YAML::PP(3)
2
6 YAML::PP - YAML 1.2 processor
7
9 WARNING: Most of the inner API is not stable yet.
10 Here are a few examples of the basic load and dump methods:
12 use YAML::PP;
14 my $ypp = YAML::PP->new;
15 my $yaml = <<'EOM';
17 --- # Document one is a mapping
18 name: Tina
19 age: 29
20 favourite language: Perl
21 --- # Document two is a sequence
23 - plain string
24 - 'in single quotes'
25 - "in double quotes we have escapes! like \t and \n"
26 - | # a literal block scalar
27 line1
28 line2
29 - > # a folded block scalar
30 this is all one
31 single line because the
32 linebreaks will be folded
33 EOM
34 my @documents = $ypp->load_string($yaml);
36 my @documents = $ypp->load_file($filename);
37 my $yaml = $ypp->dump_string($data1, $data2);
39 $ypp->dump_file($filename, $data1, $data2);
40 # The loader offers JSON::PP::Boolean, boolean.pm or
42 # perl 1/'' (currently default) for booleans
43 my $ypp = YAML::PP->new(boolean => 'JSON::PP');
44 my $ypp = YAML::PP->new(boolean => 'boolean');
45 my $ypp = YAML::PP->new(boolean => 'perl');
46 # Enable perl data types and objects
48 my $ypp = YAML::PP->new(schema => [qw/ + Perl /]);
49 my $yaml = $yp->dump_string($data_with_perl_objects);
50 # Legacy interface
52 use YAML::PP qw/ Load Dump LoadFile DumpFile /;
53 my @documents = Load($yaml);
54 my @documents = LoadFile($filename);
55 my @documents = LoadFile($filehandle);
56 my $yaml = = Dump(@documents);
57 DumpFile($filename, @documents);
58 DumpFile($filenhandle @documents);
59 Some utility scripts, mostly useful for debugging:
61 # Load YAML into a data structure and dump with Data::Dumper
63 yamlpp-load < file.yaml
64 # Load and Dump
66 yamlpp-load-dump < file.yaml
67 # Print the events from the parser in yaml-test-suite format
69 yamlpp-events < file.yaml
70 # Parse and emit events directly without loading
72 yamlpp-parse-emit < file.yaml
73 # Create ANSI colored YAML. Can also be useful for invalid YAML, showing
75 # you the exact location of the error
76 yamlpp-highlight < file.yaml
77
79 YAML::PP is a modular YAML processor.
80 It aims to support "YAML 1.2" and "YAML 1.1". See <https://yaml.org/>.
82 Some (rare) syntax elements are not yet supported and documented below.
83 YAML is a serialization language. The YAML input is called "YAML
85 Stream". A stream consists of one or more "Documents", separated by a
86 line with a document start marker "---". A document optionally ends
87 with the document end marker "...".
88 This allows one to process continuous streams additionally to a fixed
90 input file or string.
91 The YAML::PP frontend will currently load all documents, and return
93 only the first if called with scalar context.
94 The YAML backend is implemented in a modular way that allows one to add
96 custom handling of YAML tags, perl objects and data types. The inner
97 API is not yet stable. Suggestions welcome.
98 You can check out all current parse and load results from the yaml-
100 test-suite here:
101 <https://perlpunk.github.io/YAML-PP-p5/test-suite.html>
102
104 new
105 my $ypp = YAML::PP->new;
106 # load booleans via boolean.pm
107 my $ypp = YAML::PP->new( boolean => 'boolean' );
108 # load booleans via JSON::PP::true/false
109 my $ypp = YAML::PP->new( boolean => 'JSON::PP' );
110 # use YAML 1.2 Failsafe Schema
112 my $ypp = YAML::PP->new( schema => ['Failsafe'] );
113 # use YAML 1.2 JSON Schema
114 my $ypp = YAML::PP->new( schema => ['JSON'] );
115 # use YAML 1.2 Core Schema
116 my $ypp = YAML::PP->new( schema => ['Core'] );
117 # Die when detecting cyclic references
119 my $ypp = YAML::PP->new( cyclic_refs => 'fatal' );
120 my $ypp = YAML::PP->new(
122 boolean => 'JSON::PP',
123 schema => ['Core'],
124 cyclic_refs => 'fatal',
125 indent => 4,
126 header => 1,
127 footer => 1,
128 version_directive => 1,
129 );
130 Options:
132 boolean
134 Values: "perl" (currently default), "JSON::PP", "boolean"
135 This option is for loading and dumping.
137 Note that when dumping, only the chosen boolean style will be
139 recognized. So if you choose "JSON::PP", "boolean" objects will
140 not be recognized as booleans and will be dumped as ordinary
141 objects (if you enable the Perl schema).
142 schema
144 Default: "['Core']"
145 This option is for loading and dumping.
147 Array reference. Here you can define what schema to use. Supported
149 standard Schemas are: "Failsafe", "JSON", "Core", "YAML1_1".
150 To get an overview how the different Schemas behave, see
152 <https://perlpunk.github.io/YAML-PP-p5/schemas.html>
153 Additionally you can add further schemas, for example "Merge".
155 cyclic_refs
157 Default: 'allow' but will be switched to fatal in the future for
158 safety!
159 This option is for loading only.
161 Defines what to do when a cyclic reference is detected when
163 loading.
164 # fatal - die
166 # warn - Just warn about them and replace with undef
167 # ignore - replace with undef
168 # allow - Default
169 duplicate_keys
171 Default: 0
172 Since version 0.027
174 This option is for loading.
176 The YAML Spec says duplicate mapping keys should be forbidden.
178 When set to true, duplicate keys in mappings are allowed (and will
180 overwrite the previous key).
181 When set to false, duplicate keys will result in an error when
183 loading.
184 This is especially useful when you have a longer mapping and don't
186 see the duplicate key in your editor:
187 ---
189 a: 1
190 b: 2
191 # .............
192 a: 23 # error
193 indent
195 Default: 2
196 This option is for dumping.
198 Use that many spaces for indenting
200 width
202 Since version 0.025
203 Default: 80
205 This option is for dumping.
207 Maximum columns when dumping.
209 This is only respected when dumping flow collections right now.
211 in the future it will be used also for wrapping long strings.
213 header
215 Default: 1
216 This option is for dumping.
218 Print document header "---"
220 footer
222 Default: 0
223 This option is for dumping.
225 Print document footer "..."
227 yaml_version
229 Since version 0.020
230 This option is for loading and dumping.
232 Default: 1.2
234 Note that in this case, a directive "%YAML 1.1" will basically be
236 ignored and everything loaded with the "1.2 Core" Schema.
237 If you want to support both YAML 1.1 and 1.2, you have to specify
239 that, and the schema ("Core" or "YAML1_1") will be chosen
240 automatically.
241 my $yp = YAML::PP->new(
243 yaml_version => ['1.2', '1.1'],
244 );
245 This is the same as
247 my $yp = YAML::PP->new(
249 schema => ['+'],
250 yaml_version => ['1.2', '1.1'],
251 );
252 because the "+" stands for the default schema per version.
254 When loading, and there is no %YAML directive, 1.2 will be
256 considered as default, and the "Core" schema will be used.
257 If there is a "%YAML 1.1" directive, the "YAML1_1" schema will be
259 used.
260 Of course, you can also make 1.1 the default:
262 my $yp = YAML::PP->new(
264 yaml_version => ['1.1', '1.2'],
265 );
266 You can also specify 1.1 only:
268 my $yp = YAML::PP->new(
270 yaml_version => ['1.1'],
271 );
272 In this case also documents with "%YAML 1.2" will be loaded with
274 the "YAML1_1" schema.
275 version_directive
277 Since version 0.020
278 This option is for dumping.
280 Default: 0
282 Print Version Directive "%YAML 1.2" (or "%YAML 1.1") on top of each
284 YAML document. It will use the first version specified in the
285 "yaml_version" option.
286 preserve
288 Since version 0.021
289 Default: false
291 This option is for loading and dumping.
293 Preserving scalar styles is still experimental.
295 use YAML::PP::Common qw/ PRESERVE_ORDER PRESERVE_SCALAR_STYLE /;
297 # Preserve the order of hash keys
299 my $yp = YAML::PP->new( preserve => PRESERVE_ORDER );
300 # Preserve the quoting style of scalars
302 my $yp = YAML::PP->new( preserve => PRESERVE_SCALAR_STYLE );
303 # Preserve block/flow style (since 0.024)
305 my $yp = YAML::PP->new( preserve => PRESERVE_FLOW_STYLE );
306 # Preserve alias names (since 0.027)
308 my $yp = YAML::PP->new( preserve => PRESERVE_ALIAS );
309 # Combine, e.g. preserve order and scalar style
311 my $yp = YAML::PP->new( preserve => PRESERVE_ORDER | PRESERVE_SCALAR_STYLE );
312 Do NOT rely on the internal implementation of it.
314 If you load the following input:
316 ---
318 z: 1
319 a: 2
320 ---
321 - plain
322 - 'single'
323 - "double"
324 - |
325 literal
326 ---
327 block mapping: &alias
328 flow sequence: [a, b]
329 same mapping: *alias
330 flow mapping: {a: b}
331 with this code:
333 my $yp = YAML::PP->new(
335 preserve => PRESERVE_ORDER | PRESERVE_SCALAR_STYLE
336 | PRESERVE_FLOW_STYLE | PRESERVE_ALIAS
337 );
338 my ($hash, $styles, $flow) = $yp->load_file($file);
339 $yp->dump_file($hash, $styles, $flow);
340 Then dumping it will return the same output. Only folded block
342 scalars '>' cannot preserve the style yet.
343 Note that YAML allows repeated definition of anchors. They cannot
345 be preserved with YAML::PP right now. Example:
346 ---
348 - &seq [a]
349 - *seq
350 - &seq [b]
351 - *seq
352 Because the data could be shuffled before dumping again, the anchor
354 definition could be broken. In this case repeated anchor names will
355 be discarded when loading and dumped with numeric anchors like
356 usual.
357 Implementation:
359 When loading, hashes will be tied to an internal class
361 ("YAML::PP::Preserve::Hash") that keeps the key order.
362 Scalars will be returned as objects of an internal class
364 ("YAML::PP::Preserve::Scalar") with overloading. If you assign to
365 such a scalar, the object will be replaced by a simple scalar.
366 # assignment, style gets lost
368 $styles->[1] .= ' append';
369 You can also pass 1 as a value. In this case all preserving options
371 will be enabled, also if there are new options added in the future.
372 There are also methods to create preserved nodes from scratch. See
374 the "preserved_(scalar|mapping|sequence)" "METHODS" below.
375 load_string
377 my $doc = $ypp->load_string("foo: bar");
378 my @docs = $ypp->load_string("foo: bar\n---\n- a");
379 Input should be Unicode characters.
381 So if you read from a file, you should decode it, for example with
383 "Encode::decode()".
384 Note that in scalar context, "load_string" and "load_file" return the
386 first document (like YAML::Syck), while YAML and YAML::XS return the
387 last.
388 load_file
390 my $doc = $ypp->load_file("file.yaml");
391 my @docs = $ypp->load_file("file.yaml");
392 Strings will be loaded as unicode characters.
394 dump_string
396 my $yaml = $ypp->dump_string($doc);
397 my $yaml = $ypp->dump_string($doc1, $doc2);
398 my $yaml = $ypp->dump_string(@docs);
399 Input strings should be Unicode characters.
401 Output will return Unicode characters.
403 So if you want to write that to a file (or pass to YAML::XS, for
405 example), you typically encode it via "Encode::encode()".
406 dump_file
408 $ypp->dump_file("file.yaml", $doc);
409 $ypp->dump_file("file.yaml", $doc1, $doc2);
410 $ypp->dump_file("file.yaml", @docs);
411 Input data should be Unicode characters.
413 dump
415 This will dump to a predefined writer. By default it will just use the
416 YAML::PP::Writer and output a string.
417 my $writer = MyWriter->new(\my $output);
419 my $yp = YAML::PP->new(
420 writer => $writer,
421 );
422 $yp->dump($data);
423 preserved_scalar
425 Since version 0.024
426 Experimental. Please report bugs or let me know this is useful and
428 works.
429 You can define a certain scalar style when dumping data. Figuring out
431 the best style is a hard task and practically impossible to get it
432 right for all cases. It's also a matter of taste.
433 use YAML::PP::Common qw/ PRESERVE_SCALAR_STYLE YAML_LITERAL_SCALAR_STYLE /;
435 my $yp = YAML::PP->new(
436 preserve => PRESERVE_SCALAR_STYLE,
437 );
438 # a single linebreak would normally be dumped with double quotes: "\n"
439 my $scalar = $yp->preserved_scalar("\n", style => YAML_LITERAL_SCALAR_STYLE );
440 my $data = { literal => $scalar };
442 my $dump = $yp->dump_string($data);
443 # output
444 ---
445 literal: |+
446 ...
448 preserved_mapping, preserved_sequence
450 Since version 0.024
451 Experimental. Please report bugs or let me know this is useful and
453 works.
454 With this you can define which nodes are dumped with the more compact
456 flow style instead of block style.
457 If you add "PRESERVE_ORDER" to the "preserve" option, it will also keep
459 the order of the keys in a hash.
460 use YAML::PP::Common qw/
462 PRESERVE_ORDER PRESERVE_FLOW_STYLE
463 YAML_FLOW_MAPPING_STYLE YAML_FLOW_SEQUENCE_STYLE
464 /;
465 my $yp = YAML::PP->new(
466 preserve => PRESERVE_FLOW_STYLE | PRESERVE_ORDER
467 );
468 my $hash = $yp->preserved_mapping({}, style => YAML_FLOW_MAPPING_STYLE);
470 # Add values after initialization to preserve order
471 %$hash = (z => 1, a => 2, y => 3, b => 4);
472 my $array = $yp->preserved_sequence([23, 24], style => YAML_FLOW_SEQUENCE_STYLE);
474 my $data = $yp->preserved_mapping({});
476 %$data = ( map => $hash, seq => $array );
477 my $dump = $yp->dump_string($data);
479 # output
480 ---
481 map: {z: 1, a: 2, y: 3, b: 4}
482 seq: [23, 24]
483 loader
485 Returns or sets the loader object, by default YAML::PP::Loader
486 dumper
488 Returns or sets the dumper object, by default YAML::PP::Dumper
489 schema
491 Returns or sets the schema object
492 default_schema
494 Creates and returns the default schema
495
497 The functions "Load", "LoadFile", "Dump" and "DumpFile" are provided as
498 a drop-in replacement for other existing YAML processors. No function
499 is exported by default.
500 Note that in scalar context, "Load" and "LoadFile" return the first
502 document (like YAML::Syck), while YAML and YAML::XS return the last.
503 Load
505 use YAML::PP qw/ Load /;
506 my $doc = Load($yaml);
507 my @docs = Load($yaml);
508 Works like "load_string".
510 LoadFile
512 use YAML::PP qw/ LoadFile /;
513 my $doc = LoadFile($file);
514 my @docs = LoadFile($file);
515 my @docs = LoadFile($filehandle);
516 Works like "load_file".
518 Dump
520 use YAML::PP qw/ Dump /;
521 my $yaml = Dump($doc);
522 my $yaml = Dump(@docs);
523 Works like "dump_string".
525 DumpFile
527 use YAML::PP qw/ DumpFile /;
528 DumpFile($file, $doc);
529 DumpFile($file, @docs);
530 DumpFile($filehandle, @docs);
531 Works like "dump_file".
533
535 You can alter the behaviour of YAML::PP by using the following schema
536 classes:
537 YAML::PP::Schema::Failsafe
539 One of the three YAML 1.2 official schemas
540 YAML::PP::Schema::JSON
542 One of the three YAML 1.2 official schemas.
543 YAML::PP::Schema::Core
545 One of the three YAML 1.2 official schemas. Default
546 YAML::PP::Schema::YAML1_1
548 Schema implementing the most common YAML 1.1 types
549 YAML::PP::Schema::Perl
551 Serializing Perl objects and types
552 YAML::PP::Schema::Binary
554 Serializing binary data
555 YAML::PP::Schema::Tie::IxHash
557 Deprecated. See option "preserve"
558 YAML::PP::Schema::Merge
560 YAML 1.1 merge keys for mappings
561 YAML::PP::Schema::Include
563 Include other YAML files via "!include" tags
564 To make the parsing process faster, you can plugin the libyaml parser
566 with YAML::PP::LibYAML.
567
569 The process of loading and dumping is split into the following steps:
570 Load:
572 YAML Stream Tokens Event List Data Structure
574 ---------> ---------> --------->
575 lex parse construct
576 Dump:
579 Data Structure Event List YAML Stream
581 ---------> --------->
582 represent emit
583 You can dump basic perl types like hashes, arrays, scalars (strings,
585 numbers). For dumping blessed objects and things like coderefs have a
586 look at YAML::PP::Perl/YAML::PP::Schema::Perl.
587 YAML::PP::Lexer
589 The Lexer is reading the YAML stream into tokens. This makes it
590 possible to generate syntax highlighted YAML output.
591 Note that the API to retrieve the tokens will change.
593 YAML::PP::Parser
595 The Parser retrieves the tokens from the Lexer. The main YAML
596 content is then parsed with the Grammar.
597 YAML::PP::Grammar
599 YAML::PP::Constructor
600 The Constructor creates a data structure from the Parser events.
601 YAML::PP::Loader
603 The Loader combines the constructor and parser.
604 YAML::PP::Dumper
606 The Dumper will delegate to the Representer
607 YAML::PP::Representer
609 The Representer will create Emitter events from the given data
610 structure.
611 YAML::PP::Emitter
613 The Emitter creates a YAML stream.
614 YAML::PP::Parser
616 Still TODO:
617 Implicit collection keys
619 ---
620 [ a, b, c ]: value
621 Implicit mapping in flow style sequences
623 This is supported since 0.029 (except some not relevant cases):
624 ---
626 [ a, b, c: d ]
627 # equals
628 [ a, b, { c: d } ]
629 Plain mapping keys ending with colons
631 ---
632 key ends with two colons::: value
633 Supported Characters
635 If you have valid YAML that's not parsed, or the other way round,
636 please create an issue.
637 Line and Column Numbers
639 You will see line and column numbers in the error message. The
640 column numbers might still be wrong in some cases.
641 Error Messages
643 The error messages need to be improved.
644 Unicode Surrogate Pairs
646 Currently loaded as single characters without validating
647 Possibly more
649 YAML::PP::Constructor
651 The Constructor now supports all three YAML 1.2 Schemas, Failsafe, JSON
652 and Core. Additionally you can choose the schema for YAML 1.1 as
653 "YAML1_1".
654 Too see what strings are resolved as booleans, numbers, null etc. look
656 at <https://perlpunk.github.io/YAML-PP-p5/schema-examples.html>.
657 You can choose the Schema like this:
659 my $ypp = YAML::PP->new(schema => ['JSON']); # default is 'Core'
661 The Tags "!!seq" and "!!map" are still ignored for now.
663 It supports:
665 Handling of Anchors/Aliases
667 Like in modules like YAML, the Constructor will use references for
668 mappings and sequences, but obviously not for scalars.
669 YAML::XS uses real aliases, which allows also aliasing scalars. I
671 might add an option for that since aliasing is now available in
672 pure perl.
673 Boolean Handling
675 You can choose between 'perl' (1/'', currently default), 'JSON::PP'
676 and 'boolean'.pm for handling boolean types. That allows you to
677 dump the data structure with one of the JSON modules without losing
678 information about booleans.
679 Numbers
681 Numbers are created as real numbers instead of strings, so that
682 they are dumped correctly by modules like JSON::PP or JSON::XS, for
683 example.
684 Complex Keys
686 Mapping Keys in YAML can be more than just scalars. Of course, you
687 can't load that into a native perl structure. The Constructor will
688 stringify those keys with Data::Dumper instead of just returning
689 something like "HASH(0x55dc1b5d0178)".
690 Example:
692 use YAML::PP;
694 use JSON::PP;
695 my $ypp = YAML::PP->new;
696 my $coder = JSON::PP->new->ascii->pretty->allow_nonref->canonical;
697 my $yaml = <<'EOM';
698 complex:
699 ?
700 ?
701 a: 1
702 c: 2
703 : 23
704 : 42
705 EOM
706 my $data = $yppl->load_string($yaml);
707 say $coder->encode($data);
708 __END__
709 {
710 "complex" : {
711 "{'{a => 1,c => 2}' => 23}" : 42
712 }
713 }
714 TODO:
716 Parse Tree
718 I would like to generate a complete parse tree, that allows you to
719 manipulate the data structure and also dump it, including all
720 whitespaces and comments. The spec says that this is throwaway
721 content, but I read that many people wish to be able to keep the
722 comments.
723 YAML::PP::Dumper, YAML::PP::Emitter
725 The Dumper should be able to dump strings correctly, adding quotes
726 whenever a plain scalar would look like a special string, like "true",
727 or when it contains or starts with characters that are not allowed.
728 Most strings will be dumped as plain scalars without quotes. If they
730 contain special characters or have a special meaning, they will be
731 dumped with single quotes. If they contain control characters,
732 including <"\n">, they will be dumped with double quotes.
733 It will recognize JSON::PP::Boolean and boolean.pm objects and dump
735 them correctly.
736 Numbers which also have a "PV" flag will be recognized as numbers and
738 not as strings:
739 my $int = 23;
741 say "int: $int"; # $int will now also have a PV flag
742 That means that if you accidentally use a string in numeric context, it
744 will also be recognized as a number:
745 my $string = "23";
747 my $something = $string + 0;
748 print $yp->dump_string($string);
749 # will be emitted as an integer without quotes!
750 The layout is like libyaml output:
752 key:
754 - a
755 - b
756 - c
757 ---
758 - key1: 1
759 key2: 2
760 key3: 3
761 ---
762 - - a1
763 - a2
764 - - b1
765 - b2
766
768 All the available parsers and loaders for Perl are behaving
769 differently, and more important, aren't conforming to the spec.
770 YAML::XS is doing pretty well, but "libyaml" only handles YAML 1.1 and
771 diverges a bit from the spec. The pure perl loaders lack support for a
772 number of features.
773 I was going over YAML.pm issues end of 2016, integrating old patches
775 from rt.cpan.org and creating some pull requests myself. I realized
776 that it would be difficult to patch YAML.pm to parse YAML 1.1 or even
777 1.2, and it would also break existing usages relying on the current
778 behaviour.
779 In 2016 Ingy döt Net initiated two really cool projects:
781 "YAML TEST SUITE"
783 "YAML EDITOR"
784 These projects are a big help for any developer. So I got the idea to
786 write my own parser and started on New Year's Day 2017. Without the
787 test suite and the editor I would have never started this.
788 I also started another YAML Test project which allows one to get a
790 quick overview of which frameworks support which YAML features:
791 "YAML TEST MATRIX"
793 YAML TEST SUITE
795 <https://github.com/yaml/yaml-test-suite>
796 It contains almost 400 test cases and expected parsing events and more.
798 There will be more tests coming. This test suite allows you to write
799 parsers without turning the examples from the Specification into tests
800 yourself. Also the examples aren't completely covering all cases - the
801 test suite aims to do that.
802 The suite contains .tml files, and in a separate 'data' release you
804 will find the content in separate files, if you can't or don't want to
805 use TestML.
806 Thanks also to Felix Krause, who is writing a YAML parser in Nim. He
808 turned all the spec examples into test cases.
809 YAML EDITOR
811 This is a tool to play around with several YAML parsers and loaders in
812 vim.
813 <https://github.com/yaml/yaml-editor>
815 The project contains the code to build the frameworks (16 as of this
817 writing) and put it into one big Docker image.
818 It also contains the yaml-editor itself, which will start a vim in the
820 docker container. It uses a lot of funky vimscript that makes playing
821 with it easy and useful. You can choose which frameworks you want to
822 test and see the output in a grid of vim windows.
823 Especially when writing a parser it is extremely helpful to have all
825 the test cases and be able to play around with your own examples to see
826 how they are handled.
827 YAML TEST MATRIX
829 I was curious to see how the different frameworks handle the test
830 cases, so, using the test suite and the docker image, I wrote some code
831 that runs the tests, manipulates the output to compare it with the
832 expected output, and created a matrix view.
833 <https://github.com/perlpunk/yaml-test-matrix>
835 You can find the latest build at <https://matrix.yaml.info>
837
839 Ingy döt Net
840 Ingy is one of the creators of YAML. In 2016 he started the YAML
841 Test Suite and the YAML Editor. He also made useful suggestions on
842 the class hierarchy of YAML::PP.
843 Felix "flyx" Krause
845 Felix answered countless questions about the YAML Specification.
846
848 YAML
849 YAML::XS
850 YAML::Syck
851 YAML::Tiny
852 YAML::PP::LibYAML
853 YAML::LibYAML::API
854 <https://www.yaml.info>
855
857 The Perl Foundation <https://www.perlfoundation.org/> sponsored this
858 project (and the YAML Test Suite) with a grant of 2500 USD in
859 2017-2018.
860
862 Copyright 2017-2020 by Tina Müller
863 This library is free software and may be distributed under the same
865 terms as perl itself.
866perl v5.34.0 2022-01-21 YAML::PP(3)