1String::Print(3) User Contributed Perl Documentation String::Print(3)
2
6 String::Print - printf alternative
7
9 ### Functional interface
10 use String::Print; # simpelest way
12 use String::Print qw/printi printp/, %config;
13 printi 'age {years}', years => 12;
14 # interpolation of arrays and hashes (serializers)
16 printi 'price-list: {prices}', prices => \@p, _join => "+";
17 printi 'dump: {c}', c => \%config;
18 # same with positional parameters
20 printp 'age %d", 12;
21 printp 'price-list: %.2f', \@prices;
22 printp 'dump: %s', \%settings;
23 # modifiers
25 printi 'price: {price%.2f}', price => 3.14*VAT*EURO;
26 # [0.91] more complex interpolation names
28 printi 'filename: {c.filename}', c => \%config;
29 printi 'username: {user.name}', user => $user_object;
30 printi 'price: {product.price €}', product => $db->product(3);
31 ### Object Oriented interface
33 use String::Print 'oo'; # import nothing
35 my $f = String::Print->new(%config);
36 $f->printi('age {years}', years => 12);
37 $f->printp('age %d', 12);
38 ### via Log::Report's __* functions (optional translation)
40 use Log::Report; # or Log::Report::Optional
42 print __x"age {years}", years => 12;
43 ### via Log::Report::Template (Template Toolkit extension)
45 [% SET name = 'John Doe' %]
47 [% loc("Dear {name},") %] # includes translation
48
50 This module inserts values into (format) strings. It provides "printf"
51 and "sprintf" alternatives via both an object oriented and a functional
52 interface.
53 Read in the "DETAILS" chapter below, why this module provides a better
55 alternative for printf(). Also, some extended examples can be found
56 down there. Take a look at them first, when you start using this
57 module!
58
60 The Object Oriented interface
61 See functions printi(), sprinti(), printp(), and sprintp(): you can
62 also call them as method.
63 use String::Print 'oo';
65 my $f = String::Print->new(%config);
66 $f->printi($format, @params);
67 # exactly the same functionality:
69 use String::Print 'printi', %config;
70 printi $format, @params;
71 The Object Oriented interface wins when you need the same configuration
73 in multiple source files, or when you need different configurations
74 within one program. In these cases, the hassle of explicitly using the
75 object has some benefits.
76 Constructors
78 String::Print->new(%options)
80 -Option --Default
81 encode_for undef
82 missing_key <warning>
83 modifiers [ qr/^%\S+/ = \&format_printf]>
84 serializers <useful defaults>
85 encode_for => HASH|'HTML'
87 [0.91] The format string and the inserted values will get encoded
88 according to some syntax rules. For instance, encode_entities()
89 of HTML::Entities when you specify the predefined string "HTML".
90 See encodeFor().
91 missing_key => CODE
93 [0.91] During interpolation, it may be discovered that a key is
94 missing from the parameter list. In that case, a warning is
95 produced and "undef" inserted. May can overrule that behavior.
96 modifiers => ARRAY
98 Add one or more modifier handlers to power of the formatter.
99 They will get preference over the predefined modifiers, but lower
100 than the modifiers passed to "print[ip]" itself.
101 serializers => HASH|ARRAY
103 How to serialize data elements.
104 example:
106 my $f = String::Print->new
108 ( modifiers => [ EUR => sub {sprintf "%5.2f e", $_[0]} ]
109 , serializers => [ UNDEF => sub {'-'} ]
110 , encode_for => 'HTML'
111 );
112 $f->printi("price: {p EUR}", p => 3.1415); # price: ␣␣3.14 e
114 $f->printi("count: {c}", c => undef); # count: -
115 Attributes
117 $obj->addModifiers(PAIRS)
119 The PAIRS are a combination of an selector and a CODE which
120 processes the value when the modifier matches. The selector is a
121 string or (preferred) a regular expression. Later modifiers with
122 the same name overrule earlier definitions. You may also specify
123 an ARRAY of modifiers per "print".
124 See section "Interpolation: Modifiers" about the details.
126 $obj->encodeFor(HASH|undef|($predefined, %overrule))
128 [0.91] Enable/define the output encoding. Read section "Output
129 encoding" about the details.
130 Printing
132 The following are provided as method and as function. You find their
134 explanation further down on this page.
135 $obj->printi([$fh], $format, PAIRS|HASH);
137 $obj->printp([$fh], $format, PAIRS|HASH);
139 $obj->sprinti($format, PAIRS|HASH);
141 $obj->sprintp($format, LIST, PAIRS);
143
145 The functional interface creates a hidden object. You may import any
146 of these functions explicitly, or all together by not specifying the
147 names.
148 . Example
150 use String::Print; # all
152 use String::Print 'sprinti'; # only sprinti
153 use String::Print 'printi' # only printi
155 , modifiers => [ EUR => sub {sprintf "%5.2f e", $_[0]} ]
156 , serializers => [ UNDEF => sub {'-'} ];
157 printi "price: {p EUR}", p => 3.1415; # price: ␣␣3.14 e
159 printi "count: {c}", c => undef; # count: -
160 printi( [$fh], $format, PAIRS|HASH )
162 Calls sprinti() to fill the data in PAIRS or HASH in $format, and
163 then sends it to the $fh (by default the selected file)
164 open my $fh, '>', $file;
166 printi $fh, ...
167 printi \*STDERR, ...
169 printp( [$fh], $format, PAIRS|HASH )
171 Calls sprintp() to fill the data in PAIRS or HASH in $format, and
172 then sends it to the $fh (by default the selected file)
173 sprinti($format, PAIRS|HASH|OBJECT)
175 The $format refers to some string, maybe the result of a
176 translation.
177 The PAIRS (which may be passed as LIST, HASH, or blessed HASH)
179 contains a mixture of special and normal variables to be filled in.
180 The names of the special variables (the options) start with an
181 underscore ("_").
182 -Option --Default
184 _append undef
185 _count undef
186 _join ', '
187 _prepend undef
188 _append => STRING|OBJECT
190 Text as STRING appended after $format, without interpolation.
191 _count => INTEGER
193 Result of the translation process: when Log::Report subroutine
194 __xn is are used for count-sensitive translation. Those function
195 may add more specials to the parameter list.
196 _join => STRING
198 Which STRING to use when an ARRAY is being filled-in as
199 parameter.
200 _prepend => STRING|OBJECT
202 Text as STRING prepended before $format, without interpolation.
203 This may also be an OBJECT which gets stringified, but variables
204 not filled-in.
205 sprintp($format, LIST, PAIRS)
207 Where sprinti() uses named parameters --especially useful when the
208 strings need translation-- this function stays close to the
209 standard sprintf(). All features of POSIX formats are supported.
210 This should say enough: you can use "%3$0#5.*d", if you like.
211 It may be useful to know that the positional $format is rewritten
213 and then fed into sprinti(). Be careful with the length of the
214 LIST: superfluous parameter PAIRS are passed along to sprinti(),
215 and should only contain "specials": parameter names which start
216 with '_'.
217 example: of the rewrite
219 # positional parameters
221 my $x = sprintp "dumpfiles: %s\n", \@dumpfiles
222 , _join => ':';
223 # is rewritten into, and then processed as
225 my $x = sprinti "dumpfiles: {_1}\n"
226 , _1 => \@dumpfiles, _join => ':';
227
229 Why use printi(), not printf()?
230 The printf() function is provided by Perl's CORE; you do not need to
231 install any module to use it. Why would you use consider using this
232 module?
233 translating
235 printf() uses positional parameters, where printi() uses names to
236 refer to the values to be filled-in. Especially in a set-up with
237 translations, where the format strings get extracted into PO-files,
238 it is much clearer to use names. This is also a disadvantage of
239 printp()
240 pluggable serializers
242 printi() supports serialization for specific data-types: how to
243 interpolate "undef", HASHes, etc.
244 pluggable modifiers
246 Especially useful in context of translations, the FORMAT string may
247 contain (language specific) helpers to insert the values correctly.
248 correct use of utf8
250 Sized string formatting in printf() is broken: it takes your string
251 as bytes, not Perl strings (which may be utf8). In unicode, one
252 "character" may use many bytes. Also, some characters are
253 displayed double wide, for instance in Chinese. The printi()
254 implementation will use Unicode::GCString for correct behavior.
255 automatic output encoding (for HTML)
257 You can globally declare that all produced strings must be encoded
258 in a certain format, for instance that HTML entities should be
259 encoded.
260 Four components
262 To fill-in a FORMAT, four clearly separated components play a role:
263 1. modifiers
265 How to change the provided values, for instance to hide locale
266 differences.
267 2. serializer
269 How to represent (the modified) the values correctly, for instance
270 "undef" and ARRAYs.
271 3. conversion
273 The standard UNIX format rules, like %d. One conversion rule has
274 been added 'S', which provides unicode correct behavior.
275 4. encoding
277 Prepare the output for a certain syntax, like HTML.
278 Simplified:
280 # sprinti() replaces "{$key$modifiers$conversion}" by
282 $encode->($format->($serializer->($modifiers->($args{$key}))))
283 # sprintp() replaces "%pos{$modifiers}$conversion" by
285 $encode->($format->($serializer->($modifiers->($arg[$pos]))))
286 Example:
288 #XXX Your manual-page reader may not support the unicode used
290 #XXX in the examples below.
291 printi "price: {price € %-10s}", price => $cost;
292 printi "price: {price € %-10s}", { price => $cost };
293 printp "price: %-10{€}s", $cost;
294 $value = $cost (in €)
296 $modifier = convert € to local currency £
297 $serializer = show float as string
298 $format = column width %-10s
299 $encode = £ into £ # when encodingFor('HTML')
300 Interpolation: keys
302 A key is a bareword (like a variable name) or a list of barewords
303 separated by dots (no blanks!)
304 Please use explanatory key names, to help the translation process once
306 you need that (in the future).
307 Simple keys
309 A simple key directly refers to a named parameter of the function or
311 method:
312 printi "Username: {name}", name => 'John';
314 You may also pass them as HASH or CODE:
316 printi "Username: {name}", { name => 'John' };
318 printi "Username: {name}", name => sub { 'John' };
319 printi "Username: {name}", { name => sub { 'John' } };
320 printi "Username: {name}", name => sub { sub {'John'} };
321 The smartness of pre-processing CODE is part of serialization.
323 Complex keys
325 [0.91] In the previous section, we kept our addressing it simple: let's
327 change that now. Two alternatives for the same:
328 my $user = { name => 'John' };
330 printi "Username: {name}", name => $user->{name}; # simple key
331 printi "Username: {user.name}", user => $user; # complex key
332 The way these complex keys work, is close to the flexibility of
334 template toolkit: the only thing you cannot do, is passing parameters
335 to called CODE.
336 You can pass a parameter name as HASH, which contains values. This may
338 even be nested into multiple levels. You may also pass objects, class
339 (package names), and code references.
340 In above case of "user.name", when "user" is a HASH it will take the
342 value which belongs to the key "name". When "user" is a CODE, it will
343 run code to get a value. When "user" is an object, the method "name"
344 is called to get a value back. When "user" is a class name, the "name"
345 refers to an instance method on that class.
346 More examples which do work:
348 # when name is a column in the database query result
350 printi "Username: {user.name}", user => $sth->fetchrow_hashref;
351 # call a sub which does the database query, returning a HASH
353 printi "Username: {user.name}", user => sub { $db->getUser('John') };
354 # using an instance method (object)
356 { package User;
357 sub new { bless { myname => $_[1] }, $_[0] }
358 sub name { $_[0]->{myname} }
359 }
360 my $user = User->new('John');
361 printi "Username: {user.name}", user => $user;
362 # using a class method
364 sub User::count { 42 }
365 printi "Username: {user.count}", user => 'User';
366 # nesting, mixing
368 printi "Complain to {product.factory.address}", product => $p;
369 # mixed, here CODE, HASH, and Object
371 printi "Username: {document.author.name}", document => sub {
372 return +{ author => User->new('John') }
373 };
374 Limitation: you cannot pass arguments to CODE calls.
376 Interpolation: Serialization
378 The 'interpolation' functions have named VARIABLES to be filled-in, but
379 also additional OPTIONS. To distinguish between the OPTIONS and
380 VARIABLES (both a list of key-value pairs), the keys of the OPTIONS
381 start with an underscore "_". As result of this, please avoid the use
382 of keys which start with an underscore in variable names. On the other
383 hand, you are allowed to interpolate OPTION values in your strings.
384 There is no way of checking beforehand whether you have provided all
386 values to be interpolated in the translated string. When you refer to
387 value which is missing, it will be interpreted as "undef".
388 strings
390 Simple scalar values are interpolated "as is"
391 CODE
393 When a value is passed as CODE reference, that function will get
394 called to return the value to be filled in. For interpolating, the
395 following rules apply:
396 SCALAR
398 Takes the value where the scalar reference points to.
399 ARRAY
401 All members will be interpolated with ",␣" between the elements.
402 Alternatively (maybe nicer), you can pass an interpolation
403 parameter via the "_join" OPTION.
404 printi "matching files: {files}", files => \@files, _join => ', '
406 HASH
408 By default, HASHes are interpolated with sorted keys,
409 $key => $value, $key2 => $value2, ...
411 There is no quoting on the keys or values (yet). Usually, this
413 will produce an ugly result anyway.
414 Objects
416 With the "serialization" parameter, you can overrule the
417 interpolation of above defaults, but also add rules for your own
418 objects. By default, objects get stringified.
419 serialization => [ $myclass => \&name_in_reverse ]
421 sub name_in_reverse($$$)
423 { my ($formatter, $object, $args) = @_;
424 # the $args are all parameters to be filled-in
425 scalar reverse $object->name;
426 }
427 Interpolation: Modifiers
429 Modifiers are used to change the value to be inserted, before the
430 characters get interpolated in the line. This is a powerful
431 simplification. Let's discuss this with an example.
432 In traditional (gnu) gettext, you would write:
434 printf(gettext("approx pi: %.6f\n"), PI);
436 to get PI printed with six digits in the fragment. Locale::TextDomain
438 has two ways to achieve that:
439 printf __"approx pi: %.6f\n", PI;
441 print __x"approx pi: {approx}\n", approx => sprintf("%.6f", PI);
442 The first does not respect the wish to be able to reorder the arguments
444 during translation (although there are ways to work around that) The
445 second version is quite long. The string to be translated differs
446 between the two examples.
447 With "Log::Report", above syntaxes do work as well, but you can also
449 do:
450 # with optional translations
452 print __x"approx pi: {pi%.6f}\n", pi => PI;
453 The base for "__x()" is the printi() provided by this module.
455 Internally, it will call "printi" to fill-in parameters:
456 printi "approx pi: {pi%.6f}\n", pi => PI;
458 Another example:
460 printi "{perms} {links%2d} {user%-8s} {size%10d} {fn}\n",
462 perms => '-rw-r--r--', links => 7, user => 'me',
463 size => 12345, fn => $filename;
464 An additional advantage (when you use translation) is the fact that not
466 all languages produce comparable length strings. Now, the translators
467 can change the format, such that the layout of tables is optimal for
468 their language.
469 Above example in printp() syntax, shorter but less maintainable:
471 printp "%s %2d %-8s 10d %s\n",
473 '-rw-r--r--', 7, 'me', 12345, $filename;
474 Interpolation: default modifiers
476 Default modifier: POSIX format
477 As shown in the examples above, you can specify a format. This can,
479 for instance, help you with rounding or columns:
480 printp "π = {pi%.3f}", pi => 3.1415;
482 printp "weight is {kilogram%d}", kilogram => 127*OUNCE_PER_KILO;
483 printp "{filename%-20.20s}\n", filename => $fn;
484 - improvements on POSIX format
486 The POSIX printf() does not handle unicode strings. Perl does
488 understand that the 's' modifier may need to insert utf8 so does not
489 count bytes but characters. printi() does not use characters but
490 "grapheme clusters" via Unicode::GCString. Now, also composed
491 characters do work correctly.
492 Additionally, you can use the new 'S' conversion to count in columns.
494 In fixed-width fonts, graphemes can have width 0, 1 or 2. For
495 instance, Chinese characters have width 2. When printing in fixed-
496 width, this 'S' is probably the better choice over 's'. When the field
497 does not specify its width, then there is no performance penalty for
498 using 'S'.
499 # name right aligned, commas on same position, always
501 printp "name: {name%20S},\n", name => $some_chinese;
502 Default modifier: BYTES
504 [0.91] Too often, you have to translate a (file) size into humanly
506 readible format. The "BYTES" modifier simplifies this a lot:
507 printp "{size BYTES} {fn}\n", fn => $fn, size => -s $fn;
509 The output will always be 6 characters. Examples are "999 B", "1.2
511 kB", and " 27 MB".
512 Default modifiers: YEAR, DATE, TIME, DT, and DT()
514 [0.91] A set of modifiers help displaying dates and times. They are a
516 little flexible in values they accept, but do not expect miracles: when
517 it get harder, you will need to process it yourself.
518 The actual treatment of a time value depends on the value: three
520 different situations:
521 1. numeric
523 A pure numeric value is considered "seconds since epoch", unless it
524 is smaller than 21000000, in which case it is taken as date without
525 separators.
526 2. date format without time-zone
528 The same formats are understood as in the next option, but without
529 time-zone information. The date is processed as text as if in the
530 local time zone, and the output in the local time-zone.
531 3. date format with time-zone
533 By far not all possible date formats are supported, just a few
534 common versions, like
535 2017-06-27 10:04:15 +02:00
537 2017-06-27 17:34:28.571491+02 # psql timestamp with zone
538 20170627100415+2
539 2017-06-27T10:04:15Z # iso 8601
540 20170627 # only for YEAR and DATE
541 2017-6-1 # only for YEAR and DATE
542 12:34 # only for TIME
543 The meaning of 05-04-2017 is unclear, so not supported.
545 Milliseconds get ignored.
546 When the provided value has a timezone indication, it will get
548 converted into the local timezone of the observer.
549 The output of "YEAR" is in format 'YYYY', for "DATE" it will always be
551 'YYYY-MM-DD', where "TIME" produces 'HH:mm:ss'.
552 The short form "DT" is an alias for DT(FT). The DT modifier can
554 produce different formats:
555 DT(ASC) : %a %b %e %T %Y asctime output
557 DT(FT) : %F %T YYYY-MM-DD HH:mm:ss
558 DT(ISO) : %FT%T%z iso8601
559 DT(RFC822) : %a, %d %b %y %T %z email old
560 DT(RFC2822) : %a, %d %b %Y %T %z email newer
561 You may suggest additional formats, or add your own modifier.
563 Default modifiers: //word, //"string", //'string'
565 [0.91] By default, an undefined value is shown as text 'undef'. Empty
567 strings are shown as nothing. This may not be nice. You may want to
568 be more specific when a value is missing.
569 "visitors: {count //0}"
571 "published: {date DT//'not yet'}"
572 "copyright: {year//2017 YEAR}
573 Modifiers will usually return "undef" when they are called with an
575 undefined or empty value. By the right order of '//', you may product
576 different kinds of output:
577 "price: {price//5 EUR}"
579 "price: {price EUR//unknown}"
580 Private modifiers
582 You may pass your own modifiers. A modifier consists of a selector and
584 a CODE, which is called when the selector matches. The selector is
585 either a string or a regular expression.
586 # in Object Oriented syntax:
588 my $f = String::Print->new
589 ( modifiers => [ qr/[€₤]/ => \&money ]
590 );
591 # in function syntax:
593 use String::Print 'printi', 'sprinti'
594 , modifiers => [ qr/[€₤]/ => \&money ];
595 # the implementation:
597 sub money$$$$)
598 { my ($formatter, $modif, $value, $args) = @_;
599 $modif eq '€' ? sprintf("%.2f EUR", $value+0.0001)
601 : $modif eq '₤' ? sprintf("%.2f GBP", $value/1.16+0.0001)
602 : 'ERROR';
603 }
604 Using printp() makes it a little shorter, but will become quite complex
606 when there are more parameter in one string.
607 printi "price: {p€}", p => $pi; # price: 3.14 EUR
609 printi "price: {p₤}", p => $pi; # price: 2.71 GBP
610 printp "price: %{€}s", $pi; # price: 3.14 EUR
612 printp "price: %{₤}s", $pi; # price: 2.71 GBP
613 This is very useful in the translation context, where the translator
615 can specify abstract formatting rules. As example, see the (GNU)
616 gettext files, in the translation table for Dutch into English. The
617 translator tells us which currency to use in the display.
618 msgid "kostprijs: {p€}"
620 msgstr "price: {p₤}"
621 Another example. Now, we want to add timestamps. In this case, we
623 decide for modifier names in "\w", so we need a blank to separate the
624 parameter from the modifer.
625 Modifiers: stacking
627 You can add more than one modifier. The modifiers detect the extend of
629 their own information (via a regular expression), and therefore the
630 formatter understands where one ends and the next begins.
631 The modifiers are called in order:
633 printi "price: {p€%9s}\n", p => $p; # price: ␣␣␣123.45
635 printi ">{t T%10s}<", t => $now; # >␣␣12:59:17<
636 printp "price: %9{€}s\n", $p; # price: ␣␣␣123.45
638 printp ">%10{T}s<", $now; # >␣␣12:59:17<
639 Output encoding
641 [0.91] This module is also used by Log::Report::Template, which is used
642 to insert (translated) strings with parameters into HTML templates.
643 You can imagine that some of the parameter may need to be encoded to
644 HTML in the template, and other not.
645 example with Log::Report::Template
647 In pure Template Toolkit, you would write
649 # in your TT-template
651 <div>Username: [% username | html %]</div>
652 # in your code
653 username => $user->name,
654 With plain String::Print with output encoding enabled, you can do:
656 # in your TT-template
658 <div>[% show_username %]</div>
659 # in your code with encodeFor('HTML')
660 show_username => printi("Username: {user}", user => $user->name),
661 # or
662 show_username => printp("Username: %s", $user->name),
663 That does not look very efficient, however it changes for the good when
665 this is combined with Log::Report::Lexicon (translations) You can
666 either do:
667 # in your TT-template
669 <div>[% show_username %]</div>
670 # in your code with encodeFor('HTML')
671 show_username => __x("Username: {user}", user => $user->name),
672 Shorter:
674 # in your TT-template with encodeFor('HTML')
676 <div>[% loc("Username: {user}", user => username) %]</div>
677 # in your code
678 username => $user->name,
679 Even shorter:
681 # in your TT-template with encodeFor('HTML')
683 <div>[% loc("Username: {user.name}", user => userobj) %]</div>
684 # in your code
685 userobj => $user,
686 Shortest:
688 # in your TT-template with encodeFor('HTML')
690 <div>[% loc("Username: {user.name}") %]</div>
691 # in your code
692 user => $user,
693 Shorter that the original, and translations for free! More examples in
695 Log::Report::Template.
696 Output encoding exclusion
698 In some cases, the data which is inserted is already encoded in the
700 output syntax. For instance, you already have HTML to be included.
701 The default exclusion rule for HTML output is "qr/html$/i", which means
703 that all inserted named parameters, where the name ends on "html" will
704 not get html-entity encoded.
705 This will work by default:
707 # with encodeFor('HTML')
709 printp "Me & Co: {name}, {description_html}",
710 name => 'René', description_html => $descr;
711 This may result in:
713 Me & Co: René, <font color="red">new member</font>
715 Better not to have HTML in your program: leave it to the template. But
717 in some cases, you have no choice.
718 Compared to other modules on CPAN
720 There are a quite a number of modules on CPAN which extend the
721 functionality of printf(). To name a few: String::Format
722 <http://search.cpan.org/~darren/String-Format>, String::Errf
723 <http://http://search.cpan.org/~rjbs/String-Errf>, String::Formatter
724 <http://http://search.cpan.org/~rjbs/String-Formatter>,
725 Text::Sprintf::Named <http://search.cpan.org/~shlomif/Text-Sprintf-
726 Named>, Acme::StringFormat <http://search.cpan.org/~gfuji/Acme-
727 StringFormat>, Text::sprintf <http://search.cpan.org/~sharyanto/Text-
728 sprintfn>, Log::Sprintf <http://search.cpan.org/~frew/Log-Sprintf>, and
729 String::Sprintf <http://search.cpan.org/~bartl/String-Sprintf>. They
730 are all slightly different.
731 When the "String::Print" module was created, none of the modules
733 mentioned above handled unicode correctly. Global configuration of
734 serializers and modifiers is also usually not possible, sometimes
735 provided per explicit function call. Only "String::Print" cleanly
736 separates the roles of serializers, modifiers, and conversions.
737 "String::Print" is nicely integrated with Log::Report.
739
741 This module is part of String-Print distribution version 0.94, built on
742 March 01, 2020. Website: http://perl.overmeer.net/CPAN/
743
745 Copyrights 2016-2020 by [Mark Overmeer <markov@cpan.org>]. For other
746 contributors see ChangeLog.
747 This program is free software; you can redistribute it and/or modify it
749 under the same terms as Perl itself. See http://dev.perl.org/licenses/
750perl v5.38.0 2023-07-21 String::Print(3)