Image

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

unit module Str::Splice:ver<0.0.4>:auth<zef:thundergnat>;
use nqp;

role Splice {
    multi method splice (Str:D: Int(Real) $start, Int(Real) $chars, Str(Any) $add = '' --> Str) {
        fail "Start offset ($start) must be positive" if $start < 0;
        fail "Characters ($chars) must be positive" if $chars < 0;
        splice-it(self, $start, $chars, $add)
    }

    multi method splice (Str:D: Int(Real) $start, Str $add = '' --> Str) {
        fail "Start offset ($start) can not be negative" if $start < 0;
        fail "Last parameter ($add) must be a string" unless $add.^name ~~ Str;
        splice-it(self, $start, 0, $add)
    }

    multi method splice (Str:D: WhateverCode $w, Int(Real) $chars, Str(Any) $add = '' --> Str) {
        fail "Last parameter ($add) must be a string" unless $add.^name ~~ Str;
        splice-it(self, (self.chars).&($w), $chars, $add)
    }

    multi method splice (Str:D: WhateverCode $w, Str $add = '' --> Str) {
        fail "Last parameter ($add) must be a string" unless $add.^name ~~ Str;
        splice-it(self, (self.chars).&($w) max 0, 0, $add)
    }
}

proto sub splice (Str(Any) $, |c) is pure {*};

multi splice (Str(Any) $str, Int(Real) $start, Int(Real) $chars, Str(Any) $add = '' --> Str) is export {
    fail "Start offset ($start) can not be negative" if $start < 0;
    fail "Characters ($chars) must be positive" if $chars < 0;
    splice-it($str, $start, $chars, $add)
}

multi splice (Str(Any) $str, Int(Real) $start, Str $add = '' --> Str) is export {
    fail "Start offset ($start) can not be negative" if $start < 0;
    fail "Last parameter ($add) must be a string" unless $add.^name ~~ Str;
    splice-it($str, $start, 0, $add)
}

multi splice (Str(Any) $str, WhateverCode $w, Int(Real) $chars, Str(Any) $add = '' --> Str) is export {
    fail "Characters ($chars) must be positive" if $chars < 0;
    splice-it($str, ($str.chars).&($w), $chars, $add)
}

multi splice (Str(Any) $str, WhateverCode $w, Str $add = '' --> Str) is export {
    fail "Last parameter ($add) must be a string" unless $add.^name ~~ Str;
    splice-it($str, ($str.chars).&($w) max 0, 0, $add)
}

sub splice-it ($str, $start, $chars = 0, $add = '') {
    $str.chars < $start ??
    ($str ~  ' ' x $start - $str.chars ~ $add) !!
    (nqp::substr($str, 0, $start) ~ $add ~ nqp::substr($str, $start + $chars))
}




String::Splice - splice, but for Strings instead of Arrays


=begin code :lang<raku>

use String::Splice;

say 'Perl 6 is awesome'.&splice(0, 6, 'Raku');
# Raku is awesome

say splice('This is Rakudo', *-2, 2);
# This is Raku

say "Tonight I'm gonna party like it's 1999"
  .&splice(18, 5, 'program').&splice(*-4, 2, 20);
# Tonight I'm gonna program like it's 2099

=end code


String::Splice is intended to give a simple interface to slicing and dicing
Strings  much in the same way that CORE Array.splice makes it easy to slice and
dice Arrays.


Works very similarly on strings as the CORE splice works on Arrays.


Available as both a Role C<Splice> which may be used as a mixin, or to augment
strings, and as a subroutine (that primarily operates on strings).


=begin code :lang<raku>

multi sub splice($String:D, $start, $chars?, $replacement = '' --> Str)

=end code


The splice routine may be called with either three or four parameters.


Need to supply a defined string to operate on, a starting point (in chars),
optionally the number of chars to affect, and an optional replacement string
(defaults to ''). The starting point may be a positive integer, any Real numeric
value that can be coerced to a positive integer, or a WhateverCode that will
offset from the string end.


Use a WhateverCode if you want to modify a string some set offset from the end
of an unknown length string rather than from the start.


C<'Be home by 6:00PM'.&splice(*-2, 1, 'A')>
C<# Be home by 6:00AM>


You may supply a start point larger than the string and the string will be
padded with spaces to achieve that starting point.


C<splice('Raku', 9, 'rocks')> is valid, as is C<splice('Raku', *+5, 'rocks')>


The major difference in how String.splice differs from Array.splice is in that
the starting position does not default to zero. It must be given.


Three parameter splice is mostly useful as an "insert" operation. You supply a
receiving string, an "insert position" and a string to insert. The returned
string will be the receiving string with the insertion string added at the start
position. Technically, you could do a two argument splice, supplying a receiving
string and a start position, and it will then insert a blank string at the start
position, but that's kind-of pointless.


Four parameter splice is useful for remove or replace operations. You supply a
receiving string, an "insert position", the number of characters to replace, and
a string to insert. Remove portions of the string by replacing the substring
with a blank, or change the string by replacing the substring with a different
string.


The replace parameter does not necessarily need to be a string. Anything that
may be coerced to a string may be supplied and will likely work as expected.
When using 3 parameter splice: (String, start, insert), insert _must_ be a
string to disambiguify the signature to the dispatcher. You can always use the
four parameter form with a 0 chars parameter to get the automatic coercion.


I debated whether it was a good idea call this method/routine splice as splice
is already used in core. The existing splice only works on Arrays and Bufs
though, so there isn't much likelihood of confusion. I kicked around a few other
name options (slice? dice?, nah, slice is already in use and not a very similar
operation. dice maybe, but no historical corollation, and I really like the
strange consistency between Array splice and String splice.)


Honestly, I am slightly surprised that something like this does not already
exist in CORE what with Perls reputation as a text wrangling utility. I would be
quite willing to contribute the idea and code if there were interest in folding
it in. Better to start out as a module though to prove it out.


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


Splice

unit module String::Rotate:ver<0.0.2>:auth<zef:thundergnat>;

role Rotate is export {
    multi method rotate (Str:D: Int \ch = 1 --> Str) {
        my \shft = abs(ch % self.chars);
        self.substr(shft) ~ self.substr(0, shft)
    }
}

sub rotate (Str(Any) \str, Int \ch = 1 --> Str) is export {
    my \shft = abs(ch % str.chars);
    str.substr(shft) ~ str.substr(0, shft)
}




String::Rotate - Rotate, but for Strings directly instead of through Lists


=begin code :lang<perl6>

use String::Rotate;

say 'Rakudo'.&rotate; # akudoR

say 'Rakudo'.&rotate(-1); # oRakud

say rotate 'Rakudo', 3; # udoRak

=end code


Also export a Role C<Rotate> which may be used to augment strings


=begin code :lang<perl6>

use String::Rotate;
use MONKEY-TYPING;

augment class Str does Rotate { }

say 'Rakudo'.rotate; # akudoR

say 'Rakudo'.rotate(-1); # oRakud

=end code


Rotate routine, but for Strings instead of Lists. Seems a little
redundant at first glance, you could easily do C<'Rakudo'.comb.list.rotate.join>
for the same effect, but the purpose built routines are, at a minimum, twice as
fast and may be tens or hundreds times faster for longer strings.


This routine takes a String, returns a String and only perform String
operations. It runs in near constant time no matter how long the string is.
C<.comb.list.rotate.join> is heavily influenced by the size of the string.


Rotate

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

AUTHOR

COPYRIGHT AND LICENSE

String::Rotate v0.0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation