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

my sub atkeyish(Mu \h, \k) {
    use nqp;
    nqp::atkey(nqp::findmethod(h, 'hash')(h), k)
}

my role Tuxic {
    token routine-declarator:sym<sub> {
        <.routine-sub>
        <.end-keyword>?
        <routine-def=.key-origin('routine-def', 'sub')>
    }

    token term:sym<identifier> {
        :my $pos;
        <identifier>
        <!{
            my $ident = atkeyish($/, 'identifier').Str;
            $ident eq 'sub'|'if'|'elsif'|'while'|'until'|'for'
              || $*R.is-identifier-type([$ident])
        }>
        <?before <.unsp>|\s*'('> \s* <![:]>
        { $pos := $/.CURSOR.pos }
        <args>
#        {    # XXX not yet supported in RakuAST
#            self.add-mystery(
#              atkeyish($/,'identifier'),
#              atkeyish($/,'args').from,
#              atkeyish($/,'args').Str.substr(0, 1)
#            )
#        }
    }

    token methodop($*DOTTY) {
        [
          | <longname>
            {
                self.malformed("class-qualified postfix call")
                  if ~$<longname> eq '::';
            }

          | <?[$@&]>
            <variable>
            { self.check-variable(atkeyish($/, 'variable')) }

          | <?['"]>
            [ <!{$*QSIGIL}> || <!before '"' <-["]>*? [\s|$] > ] # dwim on "$foo."
            <quote>
            [ <?before '(' | '.(' | '\\'>
                || <.panic: "Quoted method name requires parenthesized arguments. If you meant to concatenate two strings, use '~'.">
            ]
            <.dotty-non-ident($*DOTTY)>
        ] \s* <.unspace>?
        [
          [
            |  <?before  \s*'('>  \s* <args>
            | ':' <?before \s | '{'> <!{ $*QSIGIL }> <args=.arglist>
          ]
          || <!{ $*QSIGIL }> <?>
          || <?{ $*QSIGIL }> <?[.]> <?>
        ] <.unspace>?
    }
}

my role Tuxic::Legacy {
    use NQPHLL:from<NQP>;

    token routine_declarator:sym<sub> {
        :my $*LINE_NO := HLL::Compiler.lineof(self.orig(), self.from(), :cache(1));
        <sym>
        <.end_keyword>?
        <routine_def('sub')>
    }

    token term:sym<identifier> {
        :my $pos;
        <identifier>
        <!{
            my $ident = atkeyish($/, 'identifier').Str;
            $ident eq 'sub'|'if'|'elsif'|'while'|'until'|'for' || $*W.is_type([$ident])
        }>
        <?before <.unsp>|\s*'('> \s* <![:]>
        { $pos := $/.CURSOR.pos }
        <args>
        {
            self.add_mystery(
              atkeyish($/,'identifier'),
              atkeyish($/,'args').from,
              atkeyish($/,'args').Str.substr(0, 1)
            )
        }
    }

    token methodop {
        [
          | <longname>
          | <?[$@&]>
            <variable>
            { self.check_variable(atkeyish($/, 'variable')) }

          | <?['"]>
            [ <!{$*QSIGIL}> || <!before '"' <-["]>*? [\s|$] > ] # dwim on "$foo."
            <quote>
            [ <?before '(' | '.(' | '\\'>
                || <.panic: "Quoted method name requires parenthesized arguments. If you meant to concatenate two strings, use '~'.">
            ]
        ] \s* <.unsp>?
        [
          [
            |  <?before  \s*'('>  \s* <args>
            | ':' <?before \s | '{'> <!{ $*QSIGIL }> <args=.arglist>
          ]
          || <!{ $*QSIGIL }> <?>
          || <?{ $*QSIGIL }> <?[.]> <?>
        ] <.unsp>?
    }
}

use Slangify Tuxic, Mu, Tuxic::Legacy, Mu;



Slang::Tuxic - allow whitespace between subroutine and the opening parenthesis


=begin code :lang<raku>

foo 3, 5;   # 15, as usual
foo(3, 5);  # also 15, as usual
foo (3, 5); # 15, /o\

# It also allows to put space before argument lists in method calls:
42.fmt('-%d-');  # -42-
42.fmt: '-%d-';  # -42-
42.fmt ('-%d-'); # -42-

=end code


The C<Slang::Tuxic> module adapts the Raku Programming Language syntax
to allow you to put whitespace between the name of a subroutine and
the opening parenthesis when calling a subroutine.


Be aware that this introduces ambiguous situations, like when you
want to pass a List to a sub, or when you need parenthesis around
the condition after the keywords `if`, `while` and so on.


Source can be located at: https://github.com/raku-community-modules/Slang-Tuxic .
Comments and Pull Requests are welcome.


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


Tuxic

use v6.d;
module Slang::Subscripts:ver<0.0.4>:auth<zef:lizmat> { }

sub EXPORT(|) {
    my role Subscripts {
        token identifier {
            <.ident> [ [ <.apostrophe> | <[₀₁₂₃₄₅₆₇₈₉]>+ ] <.ident> ]* <[₀₁₂₃₄₅₆₇₈₉]>*
        }
    }

    $*LANG.define_slang: 'MAIN', $*LANG.slang_grammar('MAIN').^mixin: Subscripts;
    {}
}



Slang::Subscripts - Allow subscripts in identifiers, just as digits


=begin code :lang<perl6>

  use Slang::Subscripts;

  my $x₁ = 42; say $x₁;  # 42

=end code


Slang::Subscripts modifies the Raku grammar to make it possible to use
numeric subscripts ₀₁₂₃₄₅₆₇₈₉ at the end of identifiers.


Idea shamelessly copied from L<Slang::Piersing> by Tobias Leich.


Subscripts

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

CREDITS

AUTHOR

COPYRIGHT AND LICENSE

Slang::Subscripts v0.0.4

Authors

License

Dependencies

Test Dependencies

Provides

Documentation