Result:
found more than 868 distributions - search limited to the first 2001 files matching your query
( run in 3.237 )
LoadHtml
view release on metacpan or search on metacpan
lib/LoadHtml.pm view on Meta::CPAN
There are four special variables that have meaning within a loop construct:
* :# Current increment value. If no increment expression or index list is specified, the loop is driven by the 1st array or hash argument. In that case, the increment value is the zero-based iteration of the loop. This value is always numeric and...
* :* Always the current zero-based iteration of the loop (numeric). Normally, this is the same as :#, but if an increment expression or index list is specified before the parameters, then :# is set to each element of the increment expression/inde...
* :% Current key value of the 1st (driving) hash (if the 1st argument is a hash-reference). Otherwise, this variable is empty (ie. if the loop is driven by an array).
* :^ Always contains the number of iterations (one-based) that the loop will perform.
Naming and nesting IF and LOOP constructs.
IF and LOOP constructs can be nested with each other. If nested within the same construct, however, they must be named (in order for the parser to match up the proper closing tags). This allows for qualifying the special variables (:#, :*, etc.) to...
Locale-CLDR-Transformations
view release on metacpan or search on metacpan
'Test::More' => '0.98',
},
add_to_cleanup => [ 'Locale-CLDR-Transformations-*' ],
configure_requires => { 'Module::Build' => '0.40' },
release_status => 'stable',
dist_abstract => q<Locale::CLDR - Data Package ( Perl localization data for transliterations )>,
meta_add => {
keywords => [ qw( locale CLDR locale-data-pack ) ],
resources => {
homepage => 'https://github.com/ThePilgrim/perlcldr',
bugtracker => 'https://github.com/ThePilgrim/perlcldr/issues',
Locale-Unicode
view release on metacpan or search on metacpan
lib/Locale/Unicode.pm view on Meta::CPAN
=back
=head2 Transform extensions
This is used for transliterations, transcriptions, translations, etc, as per L<RFC6497|https://datatracker.ietf.org/doc/html/rfc6497>
For example:
=over 4
Log-Abstraction
view release on metacpan or search on metacpan
t/edge_cases.t view on Meta::CPAN
$logger->level('debug');
}
$logger->debug("msg $i");
}
# Only odd iterations have level=debug when debug() is called
my $m = $logger->messages();
ok(scalar(@{$m}) > 0, 'some messages logged during level oscillation');
ok(scalar(@{$m}) < 200, 'some messages filtered during level oscillation');
};
Log-Any-Progress
view release on metacpan or search on metacpan
lib/Log/Any/Progress.pm view on Meta::CPAN
progress, similar in concept to L<Term::ProgressBar>. It can be
useful for monitoring the progress of a long-running process and to
get an idea of how long that process might take to finish.
It is generally applied to a processing loop. In the typical case
where the expected number of iterations is known in advance, it
produces output containing the iteration count, percent completion,
elapsed time, average time per iteration, and estimated time remaining.
For example:
Progress: Iteration:0/5 0% STARTING
lib/Log/Any/Progress.pm view on Meta::CPAN
Progress: Iteration:4/5 80% Elapsed:8.001s Avg:2.000s Remaining:2.000s
Progress: Iteration:5/5 100% FINISHED Elapsed:10.002s Avg:2.000s
The remaining time estimate as of any particular iteration is a
simple linear calculation based on the average time per iteration up
to that point, and the number of remaining iterations.
If the expected number of iterations is not known in advance, it still
reports on incremental progress, but cannot compute either percent
completion or estimated remaining time. For example:
Progress: Iteration:0 STARTING
Progress: Iteration:1 Elapsed:2.000s Avg:2.000s
lib/Log/Any/Progress.pm view on Meta::CPAN
=over 4
=item count
A mandatory non-zero count of the expected number of iterations for
progress tracking.
Specifying C<-1> indicates that the expected number of iterations is
unknown, in which case abbreviated statistics will be logged for each
iteration (percent completion and estimated finish time cannot be
computed without knowing the expected number of iterations in advance).
=item delayed_start
An optional boolean value controlling whether or not L</start> should
be automatically called at time of object construction. It defaults
lib/Log/Any/Progress.pm view on Meta::CPAN
calling L</update>). Values specifying fractional seconds are allowed
(e.g. C<0.5>). It defaults to C<10> seconds.
Setting C<min_sec_between_messages> appropriately can be used to
control log verbosity in cases where many hundreds or thousands of
iterations are being processed and it's not necessary to report after
each iteration. Setting it to C<0> will result in every incremental
progress message will be emitted.
=item prefix
Log-Dispatch
view release on metacpan or search on metacpan
-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="
Log-Fmt-XS
view release on metacpan or search on metacpan
# Allow up to 128 KB of growth for noise (arena rounding, etc.)
my $max_growth = 128 * 1024;
cmp_ok($growth, '<=', $max_growth,
sprintf("memory growth after 100k iterations: %d bytes (limit %d)",
$growth, $max_growth));
if ($growth > $max_growth) {
diag sprintf("before: %d bytes, after: %d bytes, growth: %d bytes",
$before, $after, $growth);
Loop-Control
view release on metacpan or search on metacpan
use Test::Differences;
my $output = '';
sub record { $output .= join '' => @_ }
sub doit {
my ($level, $iterations) = @_;
return if $level > 2;
record "level $level: begin\n";
for (1 .. $iterations) {
FIRST { record "level $level, block 1, iter $_: FIRST A\n" };
record "level $level, block 1, iter $_: before\n";
record "level $level, block 1, iter $_: middle\n";
FIRST { record "level $level, block 1, iter $_: FIRST B\n" };
record "level $level, block 1, iter $_: after\n";
}
record "\n";
doit($level + 1, $iterations);
for (1 .. $iterations) {
FIRST { record "level $level, block 2, iter $_: FIRST A\n" };
record "level $level, block 2, iter $_: before\n";
record "level $level, block 2, iter $_: middle\n";
FIRST { record "level $level, block 2, iter $_: FIRST B\n" };
record "level $level, block 2, iter $_: after\n";
Loop-Util
view release on metacpan or search on metacpan
lib/Loop/Util.pm view on Meta::CPAN
loop. (The C<next> and C<redo> keywords also work as expected.)
=item * C<iffirst [LABEL] BLOCK [else BLOCK]>
Runs C<BLOCK> only on the first loop iteration; if an C<else> block is present
it runs for subsequent iterations.
When C<LABEL> is present, C<iffirst> checks that labeled loop context instead
of the innermost loop. This is useful in nested loops:
OUTER: loop(2) {
lib/Loop/Util.pm view on Meta::CPAN
error.
=item * C<iflast [LABEL] BLOCK [else BLOCK]>
Runs C<BLOCK> only on the last loop iteration; if an C<else> block is present
it runs for not-last iterations.
When C<LABEL> is present, C<iflast> checks that
labeled loop context instead of the
innermost loop.
lib/Loop/Util.pm view on Meta::CPAN
loops over arrays and lists. Calling C<iflast> in other loop kinds throws a
runtime error.
=item * C<ifodd [LABEL] BLOCK [else BLOCK]>
Runs C<BLOCK> for odd-numbered iterations (1st, 3rd, 5th...).
If an C<else> block is present, it runs on even-numbered iterations.
Note that if you loop through an array, the first iteration (an odd
iteration) has index number 0 (an even number).
When C<LABEL> is present, C<ifodd> checks that
lib/Loop/Util.pm view on Meta::CPAN
arrays and lists. Calling C<ifodd> in other loop kinds throws a runtime
error.
=item * C<ifeven [LABEL] BLOCK [else BLOCK]>
Runs C<BLOCK> for even-numbered iterations (2nd, 4th, 6th...).
If an C<else> block is present, it runs on odd-numbered iterations.
Note that if you loop through an array, the first iteration (an odd
iteration) has index number 0 (an even number).
When C<LABEL> is present, C<ifeven> checks that
Lox
view release on metacpan or search on metacpan
test/benchmark/binary_trees.lox view on Meta::CPAN
print "check:";
print Tree(0, stretchDepth).check();
var longLivedTree = Tree(0, maxDepth);
// iterations = 2 ** maxDepth
var iterations = 1;
var d = 0;
while (d < maxDepth) {
iterations = iterations * 2;
d = d + 1;
}
var depth = minDepth;
while (depth < stretchDepth) {
var check = 0;
var i = 1;
while (i <= iterations) {
check = check + Tree(i, depth).check() + Tree(-i, depth).check();
i = i + 1;
}
print "num trees:";
print iterations * 2;
print "depth:";
print depth;
print "check:";
print check;
iterations = iterations / 4;
depth = depth + 2;
}
print "long lived tree of depth:";
print maxDepth;
Lugh
view release on metacpan or search on metacpan
t/0009-performance.t view on Meta::CPAN
# Warm up
$inference->forward_simple(\@tokens);
# Benchmark
my $start = time();
my $iterations = 5;
for (1..$iterations) {
$inference->forward_simple(\@tokens);
}
my $elapsed = time() - $start;
my $avg_ms = ($elapsed / $iterations) * 1000;
ok($avg_ms > 0, "CPU forward pass takes measurable time (avg: ${avg_ms}ms)");
ok($avg_ms < 10000, "CPU forward pass completes in reasonable time (<10s)");
diag("CPU forward avg: ${avg_ms}ms per iteration");
}
t/0009-performance.t view on Meta::CPAN
# Warm up
$inference->forward_simple(\@tokens);
# Benchmark
my $start = time();
my $iterations = 5;
for (1..$iterations) {
$inference->forward_simple(\@tokens);
}
my $elapsed = time() - $start;
my $avg_ms = ($elapsed / $iterations) * 1000;
ok($avg_ms > 0, "Best backend ($best) forward pass takes measurable time (avg: ${avg_ms}ms)");
ok($avg_ms < 10000, "Best backend forward pass completes in reasonable time (<10s)");
diag("Best backend ($best) forward avg: ${avg_ms}ms per iteration");
}
t/0009-performance.t view on Meta::CPAN
my @logits_pool = $inference->forward_pool($pool, \@tokens);
ok(@logits_pool > 0, 'forward_pool returns logits');
# Multiple passes with same pool (should be efficient)
my $start = time();
my $iterations = 5;
for (1..$iterations) {
my @logits = $inference->forward_pool($pool, \@tokens);
}
my $elapsed = time() - $start;
my $avg_ms = ($elapsed / $iterations) * 1000;
ok($avg_ms > 0, "forward_pool avg: ${avg_ms}ms");
ok($pool->reset(), 'Pool reset works');
diag("Memory pool forward avg: ${avg_ms}ms per iteration");
}
MARC-Detrans
view release on metacpan or search on metacpan
lib/MARC/Detrans/Name.pm view on Meta::CPAN
=head1 DESCRIPTION
MARC::Detrans::Rule represents a single non-standard detransliteration mapping
for a MARC field. For example personal names often have non-standard
transliterations, so to get them back to the original script a non-rules based
detransliteration has to occur.
MARC::Detrans::Name and MARC::Detrans::Names aid in this process by allowing you
to create a single mapping of one field to another, and then adding them to a
rule set.
MCDB_File
view release on metacpan or search on metacpan
MCDB_File.pm view on Meta::CPAN
After the C<tie> shown above, accesses to C<%h> will refer
to the B<mcdb> file C<file.mcdb>, as described in L<perlfunc/tie>.
C<keys>, C<values>, and C<each> can be used to iterate through records.
Note that only one iteration loop can be in progress at any one time.
Performing multiple iterations at the same time (i.e. in nested loops)
will not have independent iterators and therefore should be avoided.
Note that it is safe to use the find('key') method while iterating.
See PERFORMANCE section below for sample usage.
=head2 Creating an mcdb constant database
MCP-K8s
view release on metacpan or search on metacpan
examples/raider-configmap-demo.pl view on Meta::CPAN
# ── Raider ───────────────────────────────────────────────────────────
my $iteration_t0;
my $raider = Langertha::Raider->new(
engine => $engine,
max_iterations => 15,
on_iteration => sub {
my ($raider, $iteration) = @_;
# Show timing for previous iteration
if ($iteration_t0 && $iteration > 2) {
examples/raider-configmap-demo.pl view on Meta::CPAN
banner("Session Metrics");
my $m = $raider->metrics;
label("Total time:", fmt_ms($raid_elapsed));
label("Iterations:", $m->{iterations});
label("Tool calls:", $m->{tool_calls});
if ($raider->has_last_prompt_tokens) {
label("Last prompt tokens:", $raider->_last_prompt_tokens);
}
MCP-Run
view release on metacpan or search on metacpan
.claude/skills/perl-mcp/SKILL.md view on Meta::CPAN
# 4b. Or Raider for multi-turn
my $raider = Langertha::Raider->new(
engine => $engine,
mission => 'You are a calculator.',
max_iterations => 10,
);
my $result = await $raider->raid_f('Add 42 and 17');
}
main()->get;
MHFS-XS
view release on metacpan or search on metacpan
miniaudio/miniaudio.h view on Meta::CPAN
}
MA_API ma_result ma_slot_allocator_alloc(ma_slot_allocator* pAllocator, ma_uint64* pSlot)
{
ma_uint32 iAttempt;
const ma_uint32 maxAttempts = 2; /* The number of iterations to perform until returning MA_OUT_OF_MEMORY if no slots can be found. */
if (pAllocator == NULL || pSlot == NULL) {
return MA_INVALID_ARGS;
}
miniaudio/miniaudio.h view on Meta::CPAN
/* This is an error. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Play cursor has moved in front of the write cursor (same loop iteration). physicalPlayCursorInBytes=%ld, virtualWriteCurs...
availableBytesPlayback = 0;
}
} else {
/* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
} else {
/* This is an error. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCur...
availableBytesPlayback = 0;
}
}
/* If there's no room available for writing we need to wait for more. */
miniaudio/miniaudio.h view on Meta::CPAN
lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
/* Same loop iteration. Go up to the end of the buffer. */
lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
} else {
/* Different loop iterations. Go up to the physical play cursor. */
lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
}
hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
if (FAILED(hr)) {
miniaudio/miniaudio.h view on Meta::CPAN
if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
availableBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
availableBytesPlayback += physicalPlayCursorInBytes; /* Wrap around. */
} else {
/* This is an error. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Play cursor has moved in front of the write cursor (same loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld....
availableBytesPlayback = 0;
}
} else {
/* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
} else {
/* This is an error. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld....
availableBytesPlayback = 0;
}
}
/* If there's no room available for writing we need to wait for more. */
miniaudio/miniaudio.h view on Meta::CPAN
lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
/* Same loop iteration. Go up to the end of the buffer. */
lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
} else {
/* Different loop iterations. Go up to the physical play cursor. */
lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
}
hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
if (FAILED(hr)) {
miniaudio/miniaudio.h view on Meta::CPAN
availableBytesPlayback += physicalPlayCursorInBytes; /* Wrap around. */
} else {
break;
}
} else {
/* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
} else {
break;
}
miniaudio/miniaudio.h view on Meta::CPAN
MA_AT_END. To loop back to the start, all we need to do is seek back to the first frame.
*/
if (result == MA_AT_END) {
/*
The result needs to be reset back to MA_SUCCESS (from MA_AT_END) so that we don't
accidentally return MA_AT_END when data has been read in prior loop iterations. at the
end of this function, the result will be checked for MA_SUCCESS, and if the total
number of frames processed is 0, will be explicitly set to MA_AT_END.
*/
result = MA_SUCCESS;
miniaudio/miniaudio.h view on Meta::CPAN
{
MA_ASSERT(pInputBus != NULL);
MA_ASSERT(pOutputBus != NULL);
/*
Mark the output bus as detached first. This will prevent future iterations on the audio thread
from iterating this output bus.
*/
ma_node_output_bus_set_is_attached(pOutputBus, MA_FALSE);
/*
MILA-Transliterate
view release on metacpan or search on metacpan
lib/MILA/Transliterate.pm view on Meta::CPAN
our @ISA = qw(Exporter);
our @EXPORT_OK = qw(hebrew2treebank treebank2hebrew hebrew2erel erel2hebrew hebrew2fsma fsma2hebrew);
our $VERSION = 0.01;
=head1 NAME
MILA::Transliterate - A Perl Module for transliterating text from Hebrew to various transliterations used in the Knowledge Center for Processing Hebrew (MILA) and vise versa
=head1 SYNOPSIS
use MILA::Transliterate qw((hebrew2treebank hebrew2erel hebrew2fsma);
my $erel_transliterated = hebrew2erel($utf8_encoded_hebrew_text);
MIME-Lite-Generator
view release on metacpan or search on metacpan
t/02_generate.t view on Meta::CPAN
$gen_data .= $$str;
$i++;
}
is(trim $gen_data, trim $msg->as_string, 'simple msg - ' . $encoding);
ok($i > 1, 'simple msg generated in several iterations - ' . $encoding);
}
for my $encoding (qw/BINARY 8BIT 7BIT QUOTED-PRINTABLE BASE64/) {
my $msg = MIME::Lite->new(
From => 'me@myhost.com',
MIME-tools
view release on metacpan or search on metacpan
helpful input.* *Thanks to Klaus Seidenfaden for good feedback on
5.x Alpha!*
Version 4.123 (1999/05/12)
Cleaned up some of the tests for non-Unix OS'es. Will require a few
iterations, no doubt.
Version 4.122 (1999/02/09)
Resolved CORE::open warnings for 5.005. *Thanks to several folks for
this bug report.*
MR-Tarantool
view release on metacpan or search on metacpan
lib/MR/IProto/Connection/Async.pm view on Meta::CPAN
my $callbacks = $self->_callbacks;
for( 1 .. 50 ) {
$sync = $self->$orig();
return $sync unless exists $callbacks->{$sync};
}
die "Can't choose sync value after 50 iterations";
};
sub Close { die "This is not what should be done" }
=back
MRS-Client
view release on metacpan or search on metacpan
lib/MRS/Client/blast.result.xml.template view on Meta::CPAN
<Parameters_gap-open>${PARGAPOPEN}</Parameters_gap-open>
<Parameters_gap-extend>${PARGAPEXTEND}</Parameters_gap-extend>
${PARFILTER}
</Parameters>
</BlastOutput_param>
<BlastOutput_iterations>
<Iteration>
<Iteration_iter-num>1</Iteration_iter-num>
<Iteration_hits>$$HITSTART
<Hit>
<Hit_num>${HITNR}</Hit_num>
lib/MRS/Client/blast.result.xml.template view on Meta::CPAN
<Statistics_lambda>${LAMBDA}</Statistics_lambda>
<Statistics_entropy>${ENTROPY}</Statistics_entropy>
</Statistics>
</Iteration_stat>
</Iteration>
</BlastOutput_iterations>
</BlastOutput>
Mac-Glue
view release on metacpan or search on metacpan
}
#=============================================================================#
# merge additions, dialect, and glue classes together
# wow, this is ugly. i wonder if there is a better/faster way. probably.
# or maybe a way to cache the results between iterations ... ?
# but then, how do we deal with added/removed classes?
sub _merge_classes {
my($db) = @_;
if (!exists $MERGEDCLASSES->{ $db->{ID} }) {
because the glue structures need to be loaded in. However, once a
script has started, a difference in speed from the raw interfaces should
be minimal (though not a lot of testing has been done on that). With the
code above, on a PowerBook G3/292, running Mac OS 8.6:
Benchmark: timing 100 iterations of glue, glue2, raw, simple...
glue: 10 secs ( 9.98 usr 0.00 sys = 9.98 cpu)
glue2: 8 secs ( 8.35 usr 0.00 sys = 8.35 cpu)
raw: 8 secs ( 7.88 usr 0.00 sys = 7.88 cpu)
simple: 7 secs ( 7.50 usr 0.00 sys = 7.50 cpu)
Mac-PopClip-Quick
view release on metacpan or search on metacpan
--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4
Mail-SpamAssassin
view release on metacpan or search on metacpan
lib/Mail/SpamAssassin/DnsResolver.pm view on Meta::CPAN
foreach my $bucket (0..255) {
# find the bucket containing n-th turned-on bit
my $cnt = $bucket_counts_ref->[$bucket];
if ($cnt > $n) { last } else { $n -= $cnt; $ind += 256 }
}
while ($ind <= 65535) { # scans one bucket, runs at most 256 iterations
# find the n-th turned-on bit within the corresponding bucket
if (vec($ports_bitset, $ind, 1)) {
if ($n <= 0) { $port_number = $ind; last } else { $n-- }
}
$ind++;
Mail-Transport-Dbx
view release on metacpan or search on metacpan
print "I contain emails";
} else {
print "I contain subfolders";
}
This is useful for iterations:
for my $msg ($dbx->emails) {
...
}
Map-Metro
view release on metacpan or search on metacpan
lib/Map/Metro/Plugin/Map.pm view on Meta::CPAN
B<Alternative names> are used when the I<same station> is known as both names. This is not very common.
B<Search names> is mostly useful when a station has changed names (keep the old name as a search name)
Overriding station names through a hook (as L<Map::Metro::Plugin::Hook::Helsinki::Swedish> does) can be a good way to present translations or transliterations of station names.
Just make sure that no names collide.
=head1 WHAT NOW?
Markdent
view release on metacpan or search on metacpan
-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="
Markup-Tree
view release on metacpan or search on metacpan
lib/Markup/Tree.pm view on Meta::CPAN
=back
B<RETURN VALUES MATTER!>
Returning a false value will end the iterations and cause the method to return.
Return true to keep processing.
=item copy_of
Returns a copy, not a reference, of the tree.
Marpa-R2
view release on metacpan or search on metacpan
engine/read_only/ltmain.sh view on Meta::CPAN
# Relative path, prepend $cwd.
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
;;
esac
# Cancel out all the simple stuff to save iterations. We also want
# the path to end with a slash for ease of parsing, so make sure
# there is one (and only one) here.
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
while :; do
MarpaX-Hoonlint
view release on metacpan or search on metacpan
hoons/arvo/lib/tester.hoon view on Meta::CPAN
((hard tang) .*(q.v(+6 (init-test eny)) q.call))
::
:> # %per-test
:> data initialized on a per-test basis.
::
++ init-test |=({eny/@uvJ} %*(. tester eny eny, check-iterations 10))
::
++ tester
|_ $: eny=@uvJ :< entropy
check-iterations=@u :< # of check trials
current-iteration=@u :< current iteration
==
:> #
:> # %check
:> #
:> gates for quick check style tests.
+|
+- check
|* [generator=$-(@uvJ *) test=$-(* ?)]
|- ^- tang
?: (gth current-iteration check-iterations)
~
:: todo: wrap generator in mule so it can crash.
=+ sample=(generator eny)
:: todo: wrap test in mule so it can crash.
?: (test sample)
( run in 3.237 seconds using v1.01-cache-2.11-cpan-71847e10f99 )