head

code

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

# This file contains the Portuguese Slang of the Raku Programming Language



L10N::PT - Portuguese localization of Raku


=begin code :lang<raku>

use L10N::PT;
diga "Hello World";

=end code


L10N::PT contains the logic to provide a Portuguese localization of the Raku
Programming Language.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.



#- start of generated part of localization ------------------------------------
#- Generated on 2023-12-17T18:02:41+01:00 by ./update-localization
#- PLEASE DON'T CHANGE ANYTHING BELOW THIS LINE

role L10N::PT {
    use experimental :rakuast;
    token block-default { predefinita}
    token block-else { "se-não"}
    token block-elsif { "se-não-se"}
    token block-for { por}
    token block-given { dado}
    token block-if { se}
    token block-loop { ciclo}
    token block-orwith { "ou-com"}
    token block-repeat { ripita}
    token block-unless { "a-não-ser"}
    token block-until { até}
    token block-when { quando}
    token block-whenever { "assim-que"}
    token block-while { enquanto}
    token block-with { com}
    token block-without { sem}
    token constraint-where { quando}
    token infix-pcontp { "(cont)"}
    token infix-pelemp { "(elem)"}
    token infix-cff { "^ff"}
    token infix-cffc { "^ff^"}
    token infix-cfff { "^fff"}
    token infix-cfffc { "^fff^"}
    token infix-after { depois}
    token infix-and { e}
    token infix-andthen { "e-então"}
    token infix-before { antes}
    token infix-but { mas}
    token infix-cmp { cmp}
    token infix-coll { coll}
    token infix-div { div}
    token infix-does { faz}
    token infix-eq { eq}
    token infix-ff { ff}
    token infix-ffc { "ff^"}
    token infix-fff { fff}
    token infix-fffc { "fff^"}
    token infix-gcd { gcd}
    token infix-ge { ge}
    token infix-gt { gt}
    token infix-lcm { lcm}
    token infix-le { le}
    token infix-leg { leg}
    token infix-lt { lt}
    token infix-max { max}
    token infix-min { min}
    token infix-minmax { minmax}
    token infix-mod { mod}
    token infix-ne { ne}
    token infix-notandthen { "não-então"}
    token infix-o { o}
    token infix-or { ou}
    token infix-orelse { "ou-senão"}
    token infix-unicmp { unicmp}
    token infix-x { x}
    token infix-X { X}
    token infix-xx { xx}
    token infix-Z { Z}
    token meta-R { R}
    token meta-X { X}
    token meta-Z { Z}
    token modifier-for { por}
    token modifier-given { dado}
    token modifier-if { se}
    token modifier-unless { "a-não-ser"}
    token modifier-until { "até-que"}
    token modifier-when { quando}
    token modifier-while { enquanto}
    token modifier-with { com}
    token modifier-without { sem}
    token multi-multi { multi}
    token multi-only { só}
    token multi-proto { proto}
    token package-class { classe}
    token package-grammar { gramática}
    token package-module { módulo}
    token package-package { pacote}
    token package-role { papel}
    token phaser-BEGIN { COMEÇO}
    token phaser-CATCH { PEGA}
    token phaser-CHECK { CHECAGEM}
    token phaser-CLOSE { FECHO}
    token phaser-CONTROL { CONTROLE}
    token phaser-DOC { DOC}
    token phaser-END { FIM}
    token phaser-ENTER { ENTRADA}
    token phaser-FIRST { PRIMEIRA}
    token phaser-INIT { INIT}
    token phaser-KEEP { TEM}
    token phaser-LAST { ÚLTIMO}
    token phaser-LEAVE { SAIDA}
    token phaser-NEXT { PRÓXIMO}
    token phaser-POST { POST}
    token phaser-PRE { PRE}
    token phaser-QUIT { QUIT}
    token phaser-UNDO { DESFAZ}
    token prefix-not { não}
    token prefix-so { so}
    token quote-lang-m { m}
    token quote-lang-ms { ms}
    token quote-lang-q { q}
    token quote-lang-Q { Q}
    token quote-lang-qq { qq}
    token quote-lang-rx { rx}
    token quote-lang-s { s}
    token quote-lang-S { S}
    token quote-lang-ss { ss}
    token quote-lang-Ss { Ss}
    token routine-method { método}
    token routine-regex { regex}
    token routine-rule { regra}
    token routine-sub { sub}
    token routine-submethod { submethod}
    token routine-token { token}
    token scope-anon { anon}
    token scope-augment { augment}
    token scope-constant { constante}
    token scope-has { tem}
    token scope-HAS { TEM}
    token scope-my { meu}
    token scope-our { nosso}
    token scope-state { estado}
    token scope-unit { unidade}
    token stmt-prefix-also { também}
    token stmt-prefix-do { faz}
    token stmt-prefix-eager { impaciente}
    token stmt-prefix-gather { recolhe}
    token stmt-prefix-hyper { hyper}
    token stmt-prefix-lazy { preguiçoso}
    token stmt-prefix-quietly { tranquilamente}
    token stmt-prefix-race { race}
    token stmt-prefix-react { reaja}
    token stmt-prefix-sink { cale}
    token stmt-prefix-start { comece}
    token stmt-prefix-supply { supply}
    token stmt-prefix-try { tente}
    token term-nano { nano}
    token term-now { agora}
    token term-pi { pi}
    token term-rand { rand}
    token term-self { "si-mesmo"}
    token term-tau { tau}
    token term-time { tempo}
    token traitmod-does { faz}
    token traitmod-handles { cuida}
    token traitmod-hides { esconde}
    token traitmod-is { é}
    token traitmod-of { do}
    token traitmod-returns { retorna}
    token traitmod-trusts { trusts}
    token typer-enum { enum}
    token typer-subset { subset}
    token use-import { importa}
    token use-need { precisa}
    token use-no { não}
    token use-require { requer}
    token use-use { usa}
    method core2ast {
        my %mapping = "todos", "all", "algum", "any", "insere-no-final", "append", "adiciona-e-retorna-atomicamente", "atomic-add-fetch", "define-valor-atomicamente", "atomic-assign", "decrementa-e-retorna-atomicamente", "atomic-dec-fetch", "retorna-atomicamente", "atomic-fetch", "retorna-e-adiciona-atomicamente", "atomic-fetch-add", "retorna-e-decrementa-atomicamente", "atomic-fetch-dec", "retorna-e-incrementa-atomicamente", "atomic-fetch-inc", "retorna-e-subtrai-atomicamente", "atomic-fetch-sub", "incrementa-e-retorna-atomicamente", "atomic-inc-fetch", "subtrai-e-retorna-atomicamente", "atomic-sub-fetch", "espera", "await", "bolsa", "bag", "abençoa", "bless", "classifique", "classify", "combinações", "combinations", "cruz", "cross", "definido", "defined", "morra", "die", "feito", "done", "emita", "emit", "fim", "end", "termina-com", "ends-with", "saia", "exit", "falhe", "fail", "primo", "first", "plano", "flat", "chão", "floor", "pegue", "get", "essencia", "gist", "cabeça", "head", "indente", "indent", "indice", "index", "é", "is", "não-é", "isnt", "junta", "join", "chave", "key", "chaves", "keys", "cv", "kv", "último", "last", "última-chamada", "lastcall", "linhas", "lines", "lista", "list", "faça", "make", "mova", "move", "próximo", "next", "próxima-chamada", "nextcallee", "próximo-mesmo", "nextsame", "próximo-com", "nextwith", "nenhum", "none", "não", "not", "nota", "note", "um", "one", "aberto", "open", "par", "pair", "pares", "pairs", "permutações", "permutations", "escreva", "print", "escreva-formatado", "printf", "siga", "proceed", "refaça", "redo", "reduza", "reduce", "repetido", "repeated", "retorne", "return", "retorne-rw", "return-rw", "diga", "say", "assine", "sign", "sinal", "signal", "pula", "skip", "durma", "sleep", "durma-até", "sleep-until", "ordene", "sort", "encolha", "squish", "some", "sum", "cauda", "tail", "pegue", "take", "pegue-rw", "take-rw", "valor", "value", "valores", "values", "avise", "warn", "palavras", "words";
        my $ast := self.ast;
        my $name := $ast ?? $ast.simple-identifier !! self.Str;
        if %mapping{$name} -> $original {
            RakuAST::Name.from-identifier($original)
        }
        else {
            $ast // RakuAST::Name.from-identifier($name)
        }
    }
    method trait-is2ast {
        self.ast // RakuAST::Name.from-identifier(self.Str)
    }
    method adverb-pc2str (str $key) {
        $key
    }
    method adverb-q2str (str $key) {
        $key
    }
    method adverb-rx2str (str $key) {
        $key
    }
    method named2str (str $key) {
        $key
    }
    method pragma2str (str $key) {
        $key
    }
    method system2str (str $key) {
        $key
    }
}

# The EXPORT sub that actually does the slanging
my sub EXPORT($dontslang?) {
    unless $dontslang {
        my $LANG := $*LANG;
        $LANG.define_slang('MAIN',
          $LANG.slang_grammar('MAIN').^mixin(L10N::PT)
        );
    }

    BEGIN Map.new
}

#- PLEASE DON'T CHANGE ANYTHING ABOVE THIS LINE
#- end of generated part of localization --------------------------------------

# vim: expandtab shiftwidth=4


# This file contains the Dutch Slang of the Raku Programming Language



=begin code :lang<raku>

use L10N::NL;
zeg "Hello World";

=end code


L10N::NL contains the logic to provide a Dutch localization of the Raku
Programming Language.



#- start of generated part of localization ------------------------------------
#- Generated on 2023-12-17T12:05:32+01:00 by ./update-localization
#- PLEASE DON'T CHANGE ANYTHING BELOW THIS LINE

role L10N::NL {
    use experimental :rakuast;
    token block-default { ingebreke}
    token block-else { anders}
    token block-elsif { andersals}
    token block-for { vooralle}
    token block-given { gegeven}
    token block-if { als}
    token block-loop { lus}
    token block-orwith { ofmet}
    token block-repeat { herhaal}
    token block-unless { tenzij}
    token block-until { totdat}
    token block-when { indien}
    token block-whenever { zodra}
    token block-while { zolang}
    token block-with { met}
    token block-without { zonder}
    token constraint-where { waarbij}
    token infix-pcontp { "(bevat)"}
    token infix-pelemp { "(element)"}
    token infix-cff { "^ff"}
    token infix-cffc { "^ff^"}
    token infix-cfff { "^fff"}
    token infix-cfffc { "^fff^"}
    token infix-after { na}
    token infix-and { en}
    token infix-andthen { endan}
    token infix-before { voor}
    token infix-but { maar}
    token infix-cmp { vergelijk}
    token infix-coll { coll}
    token infix-div { deel}
    token infix-does { doet}
    token infix-eq { ge}
    token infix-ff { ff}
    token infix-ffc { "ff^"}
    token infix-fff { fff}
    token infix-fffc { "fff^"}
    token infix-gcd { gcd}
    token infix-ge { gg}
    token infix-gt { gt}
    token infix-lcm { lcm}
    token infix-le { kg}
    token infix-leg { kgg}
    token infix-lt { kn}
    token infix-max { max}
    token infix-min { min}
    token infix-minmax { minmax}
    token infix-mod { modulo}
    token infix-ne { ongelijk}
    token infix-notandthen { nietendan}
    token infix-o { o}
    token infix-or { of}
    token infix-orelse { ofanders}
    token infix-unicmp { unicmp}
    token infix-x { x}
    token infix-X { X}
    token infix-xx { xx}
    token infix-Z { R}
    token meta-R { O}
    token meta-X { X}
    token meta-Z { R}
    token modifier-for { vooralle}
    token modifier-given { gegeven}
    token modifier-if { als}
    token modifier-unless { tenzij}
    token modifier-until { tot}
    token modifier-when { indien}
    token modifier-while { terwijl}
    token modifier-with { met}
    token modifier-without { zonder}
    token multi-multi { multi}
    token multi-only { alleen}
    token multi-proto { proto}
    token package-class { klasse}
    token package-grammar { grammatica}
    token package-module { module}
    token package-package { pakket}
    token package-role { rol}
    token phaser-BEGIN { BEGIN}
    token phaser-CATCH { VANGFOUT}
    token phaser-CHECK { CHECK}
    token phaser-CLOSE { CLOSE}
    token phaser-CONTROL { VANGBERICHT}
    token phaser-DOC { DOC}
    token phaser-END { EINDE}
    token phaser-ENTER { BINNENKOMST}
    token phaser-FIRST { EERSTE}
    token phaser-INIT { INITIALISATIE}
    token phaser-KEEP { ACCEPTEER}
    token phaser-LAST { LAATSTE}
    token phaser-LEAVE { AFSCHEID}
    token phaser-NEXT { VOLGENDE}
    token phaser-POST { ACHTERAF}
    token phaser-PRE { VOORAF}
    token phaser-QUIT { STOP}
    token phaser-UNDO { NEGEER}
    token prefix-not { niet}
    token prefix-so { wel}
    token quote-lang-m { m}
    token quote-lang-ms { ms}
    token quote-lang-q { q}
    token quote-lang-Q { Q}
    token quote-lang-qq { dq}
    token quote-lang-rx { rx}
    token quote-lang-s { s}
    token quote-lang-S { S}
    token quote-lang-ss { ss}
    token quote-lang-Ss { Ss}
    token routine-method { methode}
    token routine-regex { regex}
    token routine-rule { regel}
    token routine-sub { functie}
    token routine-submethod { submethode}
    token routine-token { token}
    token scope-anon { anoniem}
    token scope-augment { verbeter}
    token scope-constant { constant}
    token scope-has { heeft}
    token scope-HAS { HEEFT}
    token scope-my { mijn}
    token scope-our { onze}
    token scope-state { steeds}
    token scope-unit { eenheid}
    token stmt-prefix-also { eveneens}
    token stmt-prefix-do { doe}
    token stmt-prefix-eager { vlijtig}
    token stmt-prefix-gather { verzamel}
    token stmt-prefix-hyper { hyper}
    token stmt-prefix-lazy { lui}
    token stmt-prefix-quietly { stilletjes}
    token stmt-prefix-race { race}
    token stmt-prefix-react { reageer}
    token stmt-prefix-sink { zink}
    token stmt-prefix-start { start}
    token stmt-prefix-supply { lever}
    token stmt-prefix-try { probeer}
    token term-nano { nano}
    token term-now { nu}
    token term-pi { pi}
    token term-rand { willekeurig}
    token term-self { zelf}
    token term-tau { tau}
    token term-time { tijd}
    token traitmod-does { doet}
    token traitmod-handles { begrijpt}
    token traitmod-hides { verbergt}
    token traitmod-is { is}
    token traitmod-of { netals}
    token traitmod-returns { "geeft-terug"}
    token traitmod-trusts { vertrouwd}
    token typer-enum { enum}
    token typer-subset { subset}
    token use-import { importeer}
    token use-need { behoeft}
    token use-no { geen}
    token use-require { vereist}
    token use-use { gebruik}
    method core2ast {
        my %mapping = "alle", "all", "antiparen", "antipairs", "elke", "any", "voeg-achteraan", "append", "wacht-op", "await", "tas", "bag", "geef-op", "bail-out", "zegen", "bless", "kan-ok", "can-ok", "categoriseer", "categorize", "plafond", "ceiling", "letters", "chars", "kap-regeleinde", "chomp", "kap", "chop", "als-letter", "chr", "als-letters", "chrs", "classificeer", "classify", "sluit", "close", "kam", "comb", "combinaties", "combinations", "bevat", "contains", "kruis", "cross", "decodeer", "decode", "diep-arrangeer", "deepmap", "gedefinieerd", "defined", "sterf", "die", "klaar", "done", "duik-arrangeer", "duckmap", "elementen", "elems", "zend", "emit", "codeer", "encode", "einde", "end", "eindigt-met", "ends-with", "eval-sterft-ok", "eval-dies-ok", "eval-leeft-ok", "eval-lives-ok", "verlaat", "exit", "faal", "fail", "faalt-als", "fails-like", "vouw-kast", "fc", "eerste", "first", "plat", "flat", "draaiom", "flip", "vloer", "floor", "gezakt", "flunk", "pak", "get", "pakc", "getc", "kern", "gist", "filter", "grep", "moes", "hash", "hoofd", "head", "indenteer", "indent", "is-ongeveer", "is-approx", "is-helemaal", "is-deeply", "is-priem", "is-prime", "iseen-ok", "isa-ok", "isniet", "isnt", "plak", "join", "sleutel", "key", "sleutels", "keys", "sw", "kv", "laatste", "last", "laatste-aanroep", "lastcall", "onder-kast", "lc", "lijkt-op", "like", "regels", "lines", "koppeling", "link", "lijst", "list", "leeft-ok", "lives-ok", "minst-belangrijke-bit", "lsb", "maak", "make", "arrangeer", "map", "verplaats", "move", "belangrijkste-bit", "msb", "nieuw", "new", "volgende", "next", "niet-ok", "nok", "geen", "none", "niet", "not", "merk-op", "note", "een", "one", "als-getal", "ord", "als-getallen", "ords", "paar", "pair", "paren", "pairs", "ontleed-nummer", "parse-base", "geslaagd", "pass", "permutaties", "permutations", "kies", "pick", "verwacht", "plan", "floep", "pop", "voeg-voor", "prepend", "druk", "print", "drukf", "printf", "ga-door", "proceed", "vraag", "prompt", "stapel-op", "push", "zeg-het", "put", "willekeurig", "rand", "nog-eens", "redo", "reduceer", "reduce", "herhaaldelijk", "repeated", "retour", "return", "retour-rw", "return-rw", "keer-om", "reverse", "om-index", "rindex", "gooi", "roll", "wortels", "roots", "roteer", "rotate", "rond-af", "round", "ieder-een", "roundrobin", "voer-uit", "run", "zelfde-kast", "samecase", "zelfde-accent", "samemark", "zelfde-met", "samewith", "zeg", "say", "verzameling", "set", "onderuit", "shift", "teken", "sign", "signaal", "signal", "sla-over", "skip", "sla-rest-over", "skip-rest", "slaap", "sleep", "wekker", "sleep-timer", "slaap-tot", "sleep-until", "glip", "slip", "knip", "snip", "spiek", "snitch", "dus", "so", "sorteer", "sort", "splits-lijst", "splice", "splits-letters", "split", "sdrukf", "sprintf", "spuit", "spurt", "wortel", "sqrt", "plet", "squish", "zo-willekeurig", "srand", "begint-met", "starts-with", "substitueer", "subst", "substr-gelijk", "substr-eq", "slaag", "succeed", "sommeer", "sum", "symbolische-koppeling", "symlink", "staart", "tail", "neem", "take", "neem-rw", "take-rw", "titel-kast", "tc", "titel-onder-kast", "tclc", "knalt-als", "throws-like", "tedoen", "todo", "vertaal", "trans", "trim-vooraan", "trim-leading", "trim-achteraan", "trim-trailing", "kap-af", "truncate", "boven-kast", "uc", "uniek", "unique", "lijkt-niet-als", "unlike", "ontkoppel", "unlink", "onderin", "unshift", "gebruik-ok", "use-ok", "als-nummers", "val", "waarde", "value", "waardes", "values", "waarschuw", "warn", "woord-kast", "wordcase", "woorden", "words", "rits", "zip";
        my $ast := self.ast;
        my $name := $ast ?? $ast.simple-identifier !! self.Str;
        if %mapping{$name} -> $original {
            RakuAST::Name.from-identifier($original)
        }
        else {
            $ast // RakuAST::Name.from-identifier($name)
        }
    }
    method trait-is2ast {
        my %mapping = "kopie", "copy", "verstek", "default", "VEROUDERD", "DEPRECATED", "equivalent", "equiv", "implementatie-detail", "implementation-detail", "losser", "looser", "puur", "pure", "rauw", "raw", "lezen-schrijven", "rw", "test-assertie", "test-assertion", "strakker", "tighter";
        my $ast := self.ast;
        my $name := $ast ?? $ast.simple-identifier !! self.Str;
        if %mapping{$name} -> $original {
            RakuAST::Name.from-identifier($original)
        }
        else {
            $ast // RakuAST::Name.from-identifier($name)
        }
    }
    method adverb-pc2str (str $key) {
        my %mapping = "verwijder", "delete", "bestaat", "exists", "s", "k", "sw", "kv", "w", "v";
        %mapping{$key} // $key
    }
    method adverb-q2str (str $key) {
        my %mapping = "dubbel", "double", "voer-uit", "exec", "functies", "function", "tot-teken", "heredoc", "enkel", "single", "tot", "to", "allomorph", "val", "woorden", "words";
        %mapping{$key} // $key
    }
    method adverb-rx2str (str $key) {
        my %mapping = "continueer", "continue", "ui", "ex", "uitputtend", "exhaustive", "globaal", "global", "nk", "i", "negeerkast", "ignorecase", "negeeraccent", "ignoremark", "zk", "ii", "na", "m", "za", "mm", "de", "nd", "de", "nth", "ratel", "ratchet", "de", "rd", "zelfdekast", "samecase", "zelfdeaccent", "samemark", "zelfdespatie", "samespace", "sigspatie", "sigspace", "zs", "ss", "ste", "st", "tot", "to", "keer", "x";
        %mapping{$key} // $key
    }
    method named2str (str $key) {
        my %mapping = "absoluut", "absolute", "acties", "actions", "voegtoe", "append", "vangfout", "catch", "kap-regeleinde", "chomp", "sluit", "close", "commando", "command", "volledig", "completely", "continueer", "continue", "controle", "control", "aantal", "count", "maak-aan", "create", "maak-nieuw-aan", "createonly", "datum", "date", "dag", "day", "vrijheidsgraad", "degree", "verwijder", "delete", "elementen", "elems", "cod", "enc", "codering", "encoding", "vaneinde", "end", "elke", "every", "ui", "ex", "exclusief", "exclusive", "uitputtend", "exhaustive", "verloopt", "expires", "familie", "family", "bestandsnaam", "filename", "globaal", "global", "uur", "hour", "nk", "i", "negeerkast", "ignorecase", "negeeraccent", "ignoremark", "zk", "ii", "s", "k", "sleutel", "key", "sw", "kv", "luister", "listen", "minuut", "minute", "za", "mm", "maand", "month", "naam", "name", "de", "nd", "de", "nth", "uit", "off", "gedeeltelijk", "partial", "delen", "parts", "poort", "port", "eerste", "primary", "vierde", "quaternary", "de", "rd", "vervanging", "replacement", "zelfdekast", "samecase", "zelfdeaccent", "samemark", "zelfdespatie", "samespace", "seconde", "second", "tweede", "secondary", "seconden", "seconds", "grootte", "size", "drukplat", "squash", "zs", "ss", "ste", "st", "derde", "tertiary", "de", "th", "herhalingen", "times", "tijdzone", "timezone", "kap-af", "truncate", "w", "v", "waarde", "value", "waar", "where", "keer", "x", "jaar", "year";
        %mapping{$key} // $key
    }
    method pragma2str (str $key) {
        my %mapping = "dynamische-ruimte", "dynamic-scope", "fataal", "fatal", "interne-functies", "internals", "aanroeper", "invocant", "bibliotheek", "lib", "compilatie-vooraf", "precompilation", "zacht", "soft", "strikt", "strict", "verloop", "trace", "variablen", "variables", "zorgen", "worries";
        %mapping{$key} // $key
    }
    method system2str (str $key) {
        my %mapping = "ACCEPTEERT", "ACCEPTS", "BOUW", "BUILD", "AANROEP", "CALL-ME", "VERANDER-IN", "COERCE", "WIJKUIT", "FALLBACK", "HOOFD", "MAIN", "VERFIJN", "TWEAK", "VERBETER-RAT", "UPGRADE-RAT";
        %mapping{$key} // $key
    }
}

# The EXPORT sub that actually does the slanging
my sub EXPORT($dontslang?) {
    unless $dontslang {
        my $LANG := $*LANG;
        $LANG.define_slang('MAIN',
          $LANG.slang_grammar('MAIN').^mixin(L10N::NL)
        );
    }

    BEGIN Map.new
}

#- PLEASE DON'T CHANGE ANYTHING ABOVE THIS LINE
#- end of generated part of localization --------------------------------------

# vim: expandtab shiftwidth=4


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

NAME

SYNOPSIS

DESCRIPTION

AUTHORS

COPYRIGHT AND LICENSE

L10N::NL v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation