head

Image

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

Needle::Compile - compile a search needle specification


=begin code :lang<raku>

use Needle::Compile;

my &basic = compile-needle("bar");
say basic("foo bar baz");             # True
say basic("Huey, Dewey, and Louie");  # False

my &capitals-ok = compile-needle("bar", :ignorecase);
say capitals-ok("foo bar baz");             # True
say capitals-ok("FOO BAR BAZ");             # True
say capitals-ok("Huey, Dewey, and Louie");  # False

=end code


Needle::Compile exports a single subroutine "compile-needle" that takes
a number of arguments that specify a search query needle, and returns a
C<Callable> that can be called with a given haystack to see if there is
a match.


It can as such be used as the argument to the C<rak> subroutine provided
by the L<C<rak>|https://raku.land/zef:lizmat/rak> distribution.


A query can consist of multiple needles of different types.  A type of
needle can be specified in 3 ways:


=begin code :lang<raku>

# accept haystack if "bar" as word is found
my &needle = compile-needle("§bar");

=end code


By using textual markers at the start and end of the given string needle
(see: type is "auto").


=begin code :lang<raku>

# accept haystack if "bar" as word is found
my &needle = compile-needle("words" => "bar");

=end code


By specifying a needle as a C<Pair>, with the key being a string describing
the type.


=begin code :lang<raku>

my role Type { has $.type }

# accept haystack if "bar" as word is found
my &needle = compile-needle("bar" but Type("words"));

=end code


If the needle specified supports a C<.type> method, then that method will
be called to determine the type.


Many types of matches support C<ignorecase> and C<ignoremark> semantics.
These can be specified explicitely (with the C<:ignorecase> and
C<:ignoremark> named arguments), or implicitely with the C<:smartcase>
and C<:smartmark> named arguments.


=begin code :lang<raku>

# accept haystack if "bar" is found, regardless of case
my &needle = compile-needle("bar", :ignorecase);

=end code


Allow characters to match even if they are of mixed case.


=begin code :lang<raku>

# accept haystack if "bar" is found, regardless of case
my &anycase = compile-needle("bar", :smartcase);

# accept haystack if "Bar" is found
my &exactcase = compile-needle("Bar", :smartcase);

=end code


If the needle is a string and does B<not> contain any uppercase characters,
then C<ignorecase> semantics will be assumed.


=begin code :lang<raku>

# accept haystack if "bar" is found, regardless of any accents
my &anycase = compile-needle("bar", :ignoremark);

=end code


Allow characters to match even if they have accents (or not).


=begin code :lang<raku>

# accept haystack if "bar" is found, regardless of any accents
my &anymark = compile-needle("bar", :smartmark);

# accept haystack if "bår" is found
my &exactmark = compile-needle("bår", :smartcase);

=end code


If the needle is a string and does B<not> contain any characters with accents,
then C<ignoremark> semantics will be assumed.


This is the default type of match.  It looks at the given string for a
number of markers, and adjust the type of match and the string accordingly.
The following markers are recognized:


=begin code :lang<raku>

# accept haystack if "bar" is NOT found
my &needle = compile-needle('!bar');

=end code


This is a meta-marker.  Assumes the string given (without the C<!>) should
be processed, and its result negated (see: type is "not")


=begin code :lang<raku>

# accept haystack if "bar" is found as a word
my &needle = compile-needle('§bar');

=end code


Assumes the string given (without the C<§>) should match with
word-boundary semantics applied (see: type is "words").


=begin code :lang<raku>

# accept haystack if alphabetically before "bar"
my &is-before = compile-needle('* before "bar"');

# return every haystack uppercased
my &uppercased = compile-needle('*.uc');

=end code


Assumes the given string is a valid C<WhateverCode> specification and
attempts to produce that specification accordingly (see: type is "code").


=begin code :lang<raku>

# accept haystack if it starts with "bar"
my &needle = compile-needle('^bar');

=end code


Assumes the string given (without the C<^>) should match with
C<.starts-with> semantics applied (see: type is "starts-with").


=begin code :lang<raku>

# accept haystack if it ends with "bar"
my &needle = compile-needle('bar$');

=end code


Assumes the string given (without the C<$>) should match with
C<.ends-with> semantics applied (see: type is "ends-with").


Needle-Compile

NativeHelpers::Array - helper subroutines for native arrays


This provides a number of exported subroutines that may be useful for
working with native L<CArray>s.  The subroutines aren't particularly
complicated but it saves having to have the same code in multiple modules.


sub copy-to-carray(@items, Mu $type) returns CArray is export


Copy the array to the new CArray typed as per C<$type>. If the supplied type
is not a valid native type there will be an exception.  If the elements of the
array are out of range for the type then the values in the CArray may be
truncated.


sub copy-to-array(CArray $carray, Int $items) returns Array is export


Copy the supplied CArray of the given length to a new Array.


sub copy-buf-to-carray(Buf $buf) returns CArray[uint8] is export


Copy the elements of the supplied L<Buf> to a L<CArray[uint8]>.


sub copy-carray-to-buf(CArray $array, Int $no-elems) returns Buf is export


Copy the L<CArray[uint8]> of the specified number of elements to a L<Buf>




module NativeHelpers::Array {

    use NativeCall;

    sub copy-to-carray(@items, Mu $type --> CArray ) is export {
        my $array = CArray[$type].new;
        $array[$_] = @items[$_] for ^@items.elems;
        $array;
    }

    sub copy-to-array(CArray $carray, Int $items --> Array ) is export {
        my @array;
        @array[$_] = $carray[$_] for ^$items;
        @array;
    }

    sub copy-buf-to-carray(Buf $buf --> CArray[uint8] ) is export {
        my $carray = CArray[uint8].new;
        $carray[$_] = $buf[$_] for ^$buf.elems;
        $carray;
    }

    sub copy-carray-to-buf(CArray $array, Int $no-elems --> Buf ) is export {
        my $buf = Buf.new;
        $buf[$_] = $array[$_] for ^$no-elems;
        $buf;
    }

}
# vim: expandtab shiftwidth=4 ft=raku


Array

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

NativeHelpers::Array

image i_github_com_jonathanstowe_nativehelpers_array_workflows_ci_badge_svg not found

Description

Installation

Support

Licence

NativeHelpers::Array v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation