head

Html

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

NAME

AUTHOR

VERSION

To format lists using this module, use the provided sub C<format-list>:


There are three named options available:



unit module List;
use Intl::UserLanguage;

my Callable %cache;

# Unicode uses a set of placeholder values.
# Although it is possible for some language to do things differently,
# as of December 2020, all languages conform with the following two principles:
#   (A) the order is always {0} followed by {1}
#   (B) the placeholders always flank the string (that is, they always match
#       the regex /^'{0}' .* '{1}'$/
# This allows us to efficiently process each one, and store it into cache for cleaner/faster code above
# as it's likely it will be used again
# Jan 2020: 'ff' may be a counter example

sub generate-list-formatter-vanilla($language, $type, $length, :$ast = False) {
    # Get CLDR information
    use Intl::CLDR;
    my $format = cldr{$language}.list-patterns{$type}{$length};
    my ($start, $middle, $end, $two) = $format<start middle end two>.map: *.substr(3,*-3).raku;

    # Generate code
    my $code = q:s:to/FORMATCODE/;
        sub format-list(+@items) {
            if    @items  > 2 { @items[0] ~ $start ~ @items[1..*-2].join($middle) ~ $end ~ @items[*-1] }
            elsif @items == 2 { @items[0] ~ $two ~ @items[1] }
            elsif @items == 1 { @items[0] }
            else              { '' }
        }
        FORMATCODE

    # compile and return
    use MONKEY-SEE-NO-EVAL;
    EVAL $code;
}


sub generate-list-formatter-rakuast(|c --> Callable) {
    use MONKEY-SEE-NO-EVAL;
    EVAL format-list-rakuast |c
}


sub format-list-rakuast($language, $type, $length) is export(:rakuast) {
    use experimental :rakuast;

    use Intl::CLDR;

    my $pattern = cldr{$language}.list-patterns{$type}{$length};
    my $two-infix = $pattern.two.substr: 3, *-3;
    my $more-first-infix = $pattern.start.substr: 3, *-3;
    my $more-middle-infix = $pattern.middle.substr: 3, *-3;
    my $more-final-infix = $pattern.end.substr: 3, *-3;


    my sub wrap-in-block($expression) {
        RakuAST::Block.new(
          body => RakuAST::Blockoid.new(
            RakuAST::StatementList.new(
              RakuAST::Statement::Expression.new(:$expression)
            )
          )
        )
    }

    # ''
    my $none = wrap-in-block RakuAST::StrLiteral.new('');

    # @list.head
    my $one = wrap-in-block RakuAST::ApplyPostfix.new(
        operand => RakuAST::Var::Lexical.new('@list'),
        postfix => RakuAST::Call::Method.new(
            name => RakuAST::Name.from-identifier('head')
        )
    );

    # @list.join($two-infix)
    my $two = wrap-in-block RakuAST::ApplyPostfix.new(
        operand => RakuAST::Var::Lexical.new('@list'),
        postfix => RakuAST::Call::Method.new(
            name => RakuAST::Name.from-identifier('join'),
            args => RakuAST::ArgList.new(
                RakuAST::StrLiteral.new($two-infix)
            )
        )
    );

    # @list.head
    my $more-first-item = RakuAST::ApplyPostfix.new(
      operand => RakuAST::Var::Lexical.new('@list'),
      postfix => RakuAST::Call::Method.new(
        name => RakuAST::Name.from-identifier('head')
      )
    );

    # @list[1, * - 2].join($more-middle-infix)
    my $more-mid-items = RakuAST::ApplyPostfix.new(
        # @list[1, @list - 2
        operand => RakuAST::ApplyPostfix.new(
            operand => RakuAST::Var::Lexical.new('@list'),
            postfix => RakuAST::Postcircumfix::ArrayIndex.new(
                # (1 .. @list - 2)
                RakuAST::SemiList.new(
                    RakuAST::ApplyInfix.new(
                        left => RakuAST::IntLiteral.new(1),
                        infix => RakuAST::Infix.new('..'),
                        # @list - 2
                        right => RakuAST::ApplyInfix.new(
                            left => RakuAST::Var::Lexical.new('@list'),
                            infix => RakuAST::Infix.new('-'),
                            right => RakuAST::IntLiteral.new(2)
                        )
                    )
                )
            )
        ),
        # .join($more-middle-infix)
        postfix => RakuAST::Call::Method.new(
            name => RakuAST::Name.from-identifier('join'),
            args => RakuAST::ArgList.new(
              RakuAST::StrLiteral.new($more-middle-infix)
            )
        )
    );

    # @list.tail
    my $more-final-item = RakuAST::ApplyPostfix.new(
        operand => RakuAST::Var::Lexical.new('@list'),
        postfix => RakuAST::Call::Method.new(
            name => RakuAST::Name.from-identifier('tail')
        )
    );

    # [~] ...
    my $more = wrap-in-block RakuAST::Term::Reduce.new(
        infix => RakuAST::Infix.new('~'),
        args => RakuAST::ArgList.new(
            $more-first-item,
            RakuAST::StrLiteral.new($more-first-infix),
            $more-mid-items,
            RakuAST::StrLiteral.new($more-final-infix),
            $more-final-item,
        )
    );

    # @list > 2
    my $more-than-two = RakuAST::Statement::Expression.new(
        expression => RakuAST::ApplyInfix.new(
            left => RakuAST::Var::Lexical.new('@list'),
            infix => RakuAST::Infix.new('>'),
            right => RakuAST::IntLiteral.new(2)
        )
    );

    # @list == 2
    my $exactly-two = RakuAST::Statement::Expression.new(
        expression => RakuAST::ApplyInfix.new(
            left => RakuAST::Var::Lexical.new('@list'),
            infix => RakuAST::Infix.new('=='),
            right => RakuAST::IntLiteral.new(2)
        )
    );

    # @list == 1
    my $exactly-one = RakuAST::Statement::Expression.new(
        expression => RakuAST::ApplyInfix.new(
            left => RakuAST::Var::Lexical.new('@list'),
            infix => RakuAST::Infix.new('=='),
            right => RakuAST::IntLiteral.new(1)
        )
    );

    my $if = RakuAST::Statement::If.new(
        condition => $more-than-two,
        then => $more,
        elsifs => [
            RakuAST::Statement::Elsif.new(
                condition => $exactly-two,
                then => $two
            ),
            RakuAST::Statement::Elsif.new(
                condition => $exactly-one,
                then => $one
            )
        ],
        else => $none
    );

    return RakuAST::PointyBlock.new(
        signature => RakuAST::Signature.new(
            parameters => (
                RakuAST::Parameter.new(
                    target => RakuAST::ParameterTarget::Var.new('@list'),
                    slurpy => RakuAST::Parameter::Slurpy::SingleArgument
                ),
            ),
        ),
        body => RakuAST::Blockoid.new(
            RakuAST::StatementList.new(
                RakuAST::Statement::Expression.new(
                    expression => $if
                )
            )
        )
    )
}



INIT my &generate-list-formatter =
    $*RAKU.compiler.name eq 'rakudo' && $*RAKU.compiler.version < v2022.12.813.g.02043.da.92
        ?? &generate-list-formatter-vanilla
        !! &generate-list-formatter-rakuast;
use User::Language;

#| Formats a list in a manner that is appropriate for the given language
sub format-list (
        +@items,                    #= The list of items to format (each will be stringified with .Str)
        :$language = user-language, #= The locale to use for formatting (defaults to user-language)
        :$type = 'and',             #= The type of the list (and, unit, or); defaults to 'and'.
        :$length = 'standard'       #= The length of the format (standard, short, or narrow); defaults to 'standard'.
) is export(:DEFAULT) {
    my $code = $language ~ $type ~ $length;
    # Get a formatter, generating it if it's not been requested before
    my &formatter  = %cache{$code}
                  // %cache{$code} = generate-list-formatter($language, $type, $length);

    formatter @items;
}

Intl::Format::List


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

IntlFormatList

Examples

For developers

Version history

License and Copyright

Intl::Format::List v0.6.0+

Authors

License

Dependencies

Test Dependencies

Provides

Documentation