perltutorial

Threads: why locking is required when using shared variables (ikegami)

I was recently faced with a thread that used .= on a shared variable, and I wondered if that was safe. I figured I'd write up a introductory tutorial on the answer I found. For simplicity, we'll look at ++ first.

The following code outputs 400,000:

my $count     = 100_000;my $num_calls = 4;my $sum = 0;sub inc { ++$sum for 1..$count; }inc() for 1..$num_calls;print("$sum\n");   # 400000

If you ran the 4 calls to inc in parallel, would the answer still be 400,000? Not likely, if you don't change inc.

use threads;use threads::shared;my $count     = 100_000;my $num_calls = 4;my $sum : shared = 0;sub inc { ++$sum for 1..$count; }$_->join for map { threads->create( \&inc ) } 1..$num_calls;print("$sum\n");   # 314813

That's because there is a [wp://race condition].

+=======================+|          CPU          |+-----------+-----------+| thread 1  | thread 2  |+===========+===========+| ...       |           |   T| load $sum |           |   i| inc       |           |   m+-----------+-----------+   e|           | ...       |   ||           | load $sum |   ||           | inc       |   v|           | save $sum ||           | ...       |+-----------+-----------+| save $sum |           || ...       |           |+===========+===========+

The solution is to protect the [wp://critical section] using a thread synchronization mechanism such as lock.

use threads;use threads::shared;my $count     = 100_000;my $num_calls = 4;my $sum : shared = 0;sub inc { for (1..$count) { lock($sum); ++$sum } }$_->join for map { threads->create( \&inc ) } 1..$num_calls;print("$sum\n");   # 400000

Whenever an transformation operation (read ⇒ manipulate ⇒ write) is performed on a shared variable, locking is needed. See [mod://threads::shared] for tools to do this.

The program behind the below outputs results similar to the following:

++s     sum = 233564 (expecting 400000)s+=1    sum = 143915 (expecting 400000)c.=l    length = 248149 (expecting 400000)c=c.l   length = 123360 (expecting 400000)

As you can see, +=, .= and = . are also not atomic. The program can only prove that an operator isn't atomic (i.e. is interruptable). It cannot prove that an operator is atomic (i.e. is not interruptable). If you're getting the "expecting" result, try upping $count and/or $threads.

use v5.8.0;use strict;use warnings;use threads;use threads::shared;{   my $count   = 100_000;   my $threads = 4;   my $sum : shared = 0;   sub inc {      for (1..$count) {         ++$sum;      }   }   $_->join      for map { threads->create( \&inc ) }          0..$threads-1;   print("++s     sum = $sum (expecting " . ($count*$threads). ")\n");}{   my $count   = 100_000;   my $threads = 4;   my $sum : shared = 0;   sub inc_assign {      for (1..$count) {         $sum += 1;      }   }   $_->join      for map { threads->create( \&inc_assign ) }          0..$threads-1;   print("s+=1    sum = $sum (expecting " . ($count*$threads). ")\n");}{   my $count   = 100_000;   my $threads = 4;   my $content : shared = '';   sub append {      my ($letter) = @_;      for (1..$count) {         $content .= $letter;      }   }   $_->join      for map { threads->create( \&append, chr(ord('a')+$_) ) }          0..$threads-1;   print("c.=l    length = " . length($content) .         " (expecting " . ($count*$threads). ")\n");}{   my $count   = 100_000;   my $threads = 4;   my $content : shared = '';   sub concatenate {      my ($letter) = @_;      for (1..$count) {         $content = $content . $letter;      }   }   $_->join      for map { threads->create( \&concatenate, chr(ord('a')+$_) ) }          0..$threads-1;   print("c=c.l   length = " . length($content) .         " (expecting " . ($count*$threads). ")\n");}

Update: Added the preface and links to Wikipedia.

Added to [Tutorials] by [planetscape] ( keep:0 edit:6 reap:0 )

Big-O Notation - What is it good for? (Limbic~Region)

[All],
If you have ever felt that people debating the big-oh notation of some algorithm sound like they are speaking a foreign language, then this tutorial is for you. You may have even decided to educate yourself by checking out the [wp://Big_o_notation|Wikipedia entry] and have been convinced it was a foreign language. You are not alone.

You may have already read [id://227909] by [dws] which is excellent. This tutorial will repeat much of the same information in a much more elementary manner as well as go into detail about how useful or not the notation is. It is likely I won't be completely accurate about a number of things in the tutorial. My hope is that by the end, your understanding of the topic will be sufficient enough that you can understand the corrections others make (as I am sure they will).

What Is The Big-O

This tutorial covers the Big-O as it relates to computer science. If you were thinking of something else (perhaps Fridays in the Chatterbox), you can stop reading now. Simply put, it describes how the algorithm scales (performs) in the worst case scenario as it is is run with more input. Since my simple explanation may not be simple enough - let me give an example. If we have a sub that searches an array item by item looking for a given element, the scenario that the Big-O describes is when the target element is last (or not present at all). This particular algorithm is O(N) so the same algorithm working on an array with 25 elements should take approximately 5 times longer than an array with 5 elements.

It is easy to lose sight of the fact that there is more to consider about an algorithm other than how fast it runs. The Big-O can also be used to describe other behavior such as memory consumption. We often optimize by trading memory for time. You may need to choose a slower algorithm because it also consumes less of a resource that you need to be frugal with.

What The Big-O Is Not

Constants: The Big-O is not concerned with factors that do not change as the input increases. Let me give an example that may be suprising. Let's say we have an algorithm that needs to compare every element in an array to every other element in the array. A simple implementation may look like:

for my $i (0 .. $#array) {    for my $j (0 .. $#array) {        next if $j == $i;        # Compare $i, $j    }}

This is O(N^2). After a little bit of testing we decide that this is far too slow, so we make a little optimization.

for my $i (0 .. $#array - 1) {    for my $j ($i + 1 .. $#array) {        # Compare $i, $j    }}

We have just cut our run time in half - YAY! Guess what, the Big-O has stayed the same O(N^2). This is because N^2 / 2 only has one variable part. The divided by 2 does not affect how the algorithm scales. If you remember a little linear algebra, the slope of a line is the change in height (execution time) as the length (size of input) increases. While the second algorithm's line will always be half as high as the first, it's slope will be exactly the same.

Implementation Details: The Big-O is an uncaring cold-hearted jerk. It does not care if you can't afford to buy the extra RAM needed for your problem and have to resort to tying your hash to disk. You are on your own. It also doesn't care that the data structure you would need to implement to achieve O(Log Log N) is so complex you will never be able to maintain it. In a nutshell, the Big-O lives in the land of theory and doesn't care very much about the real world.

What The Big-O Is Good For

The good news is that the Big-O belongs to an entire family of notation. This tutorial will not cover it but family members include describing the average and best cases. It also serves as a good indicator of what algorithm to use once you take your individual circumstances into consideration. Let me give a contrived example:

Let's consider using cacheing as an optimization. In theory, the Big-O is going to ignore it saying your input is all different and you will never benefit from it. In reality, you test it and discover that you have a 60% hit rate. You do a little more experimenting and discover that the input size required for a more complex algorithm to be faster is larger than your real maximum input size. This all despite the more complex alorithm having a more favorable Big-O.

In a nutshell, the Big-O of a given algorithm combined with the specific problem knowledge is a great way to choose the best algorithm for your situation.

What Do Those Symbols Mean?

So by this point you should realize that Big-O (theory) without context (real world) is not very useful. You are now armed with the knowledge necessary to start using Big-O as the mercenary it is. Ok Big-O, what exactly do you mean that algorithm is O(N Log N)? I am going to duck at this point and suggest you read the node by [dws] or the Wikipedia entry I linked to earlier. You may now be wondering if Big-O is really inanimate, perhaps even an abstract concept and not at all real as I have made it out to be. If so, how then can you determine the Big-O of a given algorithm? [http://algo.inria.fr/AofA/|Analysis of algorithms] is not for the faint of heart, so I must once again duck.

I have not really added anything to any of the other links I referenced. I do hope however that I have put it in plain enough english to be understood by even the most extreme novice. I welcome those more knowledgeable than myself to add corrections as well as provide additional content. I would only ask that you do so in the same spirit of this tutorial (understandable by non-CS majors).

Also see [id://25833] by [jeffa]

Cheers - [Limbic~Region|L~R]

Common Causes for "Modification of a read-only value attempted" (imp)

You tried, directly or indirectly, to change the value of aconstant. This type of error frequently occurs at a distance and is difficult to trace. The magic of $_ is often involved, but is not responsible.

Common causes:

Treating a loop variable as an lvalue
Modifying $_ inside foreach, map or grep
Modifying elements of @_ directly
Modifying $a or $b inside sort
Autovivifying $a or $b inside sort
Modifying an unlocalized $_

Treating a loop variable as an lvalue

for my $x (1,2) {  $x++;}

In this example $x is aliased to the constant '1', so when the loop body attempts to increment $x an error is triggered. See Lists With Constant Values for more details.

Modifying $_ inside [doc://perlsyn#Foreach-Loops-for-foreach|foreach], [doc://map] or [doc://grep]

for (1,2) {  chomp;}for ("foo", @list) {  s/foo/bar/;}@array = map  { $_++ } (1,2);@array = grep { $_++ } (1,2);

In all of these examples $_ is aliased to a constant, and when the loop body attempts to modify $_ an error is triggered. See Lists With Constant Values for more details.

Modifying elements of @_ directly

sub incr {  $_[0]++;}my $n = 1;incr($n); # goodincr(1);  # bad

Modifying elements of @_ directly allows you tomodify the variable that was passed to the function. For example, in the above example $n is now 2. But an error will occur when a constant is passed, as in the second call.

Modifying $a or $b inside [doc://sort]

@array = sort { $a++ } (1,2);

It is permissible (but ill-advised) to modify $a and $b within sort. However, modifying a constant that is aliased to $a or $b is still an error.

Autovivifying $a or $b inside [doc://sort]

my @bad;$bad[0] = [1];$bad[2] = [2];@bad = sort {$a->[0] <=> $b->[0]} @bad;

The variables $a and $b are aliased to each item in the list being sorted, and as such modifying them is possible - but will cause an error if the current element is unmodifiable. A common cause of this is sorting an array of references when where the list has a gap. In this situation $a will be undef, and autovivification by dereferencing will trigger an error.

Modifying an unlocalized $_

for (1,2) {  my $data = prompt_user();}sub prompt_user {   print "Enter a number\n";   while () {     # Do stuff   }}

This example will cause an error because the [doc://perlsyn#Foreach-Loops-for-foreach|for] loop aliases $_ to the literal '1', and then calls prompt_user which attempts to read a line from STDIN and store it in $_ - which is still aliased to '1'.

The error will also occur in this simplified scenario:

for (1,2) {    while () {    }}

Guidelines to avoid read-only errors:

Don't treat loop variables as a lvalue if there is any chance a constant value will be included
Don't modify an unlocalized $_
Don't modify $_ inside map or grep
Don't modify $a or $b inside sort
Don't dereference $a or $b inside sort without checking that they exist and are references
Don't use $_ for the loop variable unless it is a very trivial loop
Don't modify elements of @_ directly

Notes

Lists With Constant Values

Within the context of this document the important thing to understand is what expressions result in modifiable objects.The following expressions have constants in them:

$_++ for (1,2);$_++ for (1,@array);@array = map {$_++} (1,@array);

And the following are safe:

my @array = (1,2);for (@array) {  $_++;}

my ($x,$y) = (1,2);for ($x,$y) {  $_++;}

For an explanation of lists versus arrays I recommend the following:

[id://451421]
[href://http://japhy.perlmonk.org/articles/pm/2000-02.html|"List" Is a Four-Letter Word]

mod_perl / Apache::Registry accidental closures (imp)

When working with Apache::Registry it is very easy to create accidental closures.
This is due to the way Apache::Registry makes a fake package for your script, as I'll demonstrate in this tutorial.

The only indication that something is amiss (other than the unpredictable behaviour) will be the following line in your error log: Variable "$foo" will not stay shared at ...

The following code demonstrates the problem with accidental closures when using Apache::Registry.

use strict;use warnings;my $foo = 5;print "Content-type: text/plain\n";print "Content-disposition: inline; filename=foo.txt\n\n";printf "Package: %s\n", __PACKAGE__;printf "[%s] Before: %s\n", $$, $foo;badness(5);printf "[%s] After: %s\n", $$, $foo;sub badness {    my $val = shift;    printf "[%s] badness: %s\n", $$, $foo;    $foo += $val;}

Apache::Registry will take the above code and create a new package for it based on the ServerName and the name of the script, and then wrap the code in a sub handler {} block.

If your script is running on "foo.com" and is named "test.pl", then this is what the above code will look like after Apache::Registry is done:

package Apache::ROOTfoo_2ecom::test_2epl;use Apache qw(exit);sub handler {#line 1 /www/foo.com/test.pluse strict;use warnings;my $foo = 5;print "Content-type: text/plain\n";print "Content-disposition: inline; filename=foo.txt\n\n";printf "Package: %s\n", __PACKAGE__;printf "[%s] Before: %s\n", $$, $foo;badness(5);printf "[%s] After: %s\n", $$, $foo;sub badness {    my $val = shift;    printf "[%s] badness: %s\n", $$, $foo;    $foo += $val;}}

First run:

Package: Apache::ROOTfoo_2ecom::test_2epl[13520] Before: 5[13520] badness: 5[13520] After: 10

Second:

Package: Apache::ROOTfoo_2ecom::test_2epl[19331] Before: 5[19331] badness: 5[19331] After: 10

Third:

Package: Apache::ROOTfoo_2ecom::test_2epl[19331] Before: 5[19331] badness: 10[19331] After: 5

Fourth:

Package: Apache::ROOTfoo_2ecom::test_2epl[19331] Before: 5[19331] badness: 15[19331] After: 5

Notice how the number within the badness sub is increasing for each process, but the $foo that is seen by the instance script is never modified after 'badness' after the first execution for that process.

This is because the badness function is actually an inner function now,and it keeps a reference to the instance of $foo that was created for the first run.

Edit - example of how to avoid this issue added, per rhesa's suggestion

Thankfully it is easy to avoid these problems once you know why they occur.
Tips:

Keep your toplevel script minimal
Subroutines should only use the variables that were passed
Encapsulate behaviour in supporting objects

Example of a working alternative:

use strict;use warnings;my $foo = 5;print "Content-type: text/plain\n";print "Content-disposition: inline; filename=foo.txt\n\n";printf "Package: %s\n", __PACKAGE__;printf "[%s] Before: %s\n", $$, $foo;badness(\$foo, 5);badness(\$foo, 5);printf "[%s] After: %s\n", $$, $foo;sub badness {    my ($foo,$val) = @_;    printf "[%s] badness: %s\n", $$, $$foo;    $$foo += $val;}

mbito de variables en Perl: lo bsico (Hue-Bond)

Translated to spanish from [id://23317]'s original [id://66677].

mbito

Una de las cosas necesarias para dominar Perl es cmo manejar los mecanismos de mbito que te ofrece. Que queremos globales? Las tenemos. Que queremos evitar "colisiones" (dos variables con el mismo nombre pisndose una a la otra)? Podemos, y hay ms de una forma de conseguirlo. Pero las reglas de mbito de Perl no son siempre tan claras, y no es slo la diferencia entre my y local lo que hace tropezar a la gente, aunque aclarar eso es uno de mis objetivos.

He aprendido mucho de Coping with scoping y de varios libros de Perl (por ejemplo, Effective Perl Programming), por lo que debo dar crdito a sus autores ([Dominus] por el primero, y Joseph N. Hall y [merlyn] por el segundo). [Dominus] tambin ha hecho varias correcciones a los errores (algunos de ellos notables) de una versin anterior de este tutorial, as que l debera considerarse como mnimo el segundo autor (N del T: aunque [Dominus] no est de acuerdo con esto). Sin embargo la documentacin que viene con tu versin de Perl es la ms actualizada que puedes consultar, as que no dudes en usar perldoc perlop y perldoc -f foo en tu propio sistema.

Resumen

S, al principio...

my proporciona mbito lxico; una variable declarada con my slo es visible en el bloque en que ha sido declarada.
Los bloques de cdigo son trozos delimitados por llaves { }. Un archivo tambin se considera un bloque.
Usar use vars qw([nombres de variables]) o our ([nombres de variables]) para crear globales.
local guarda el valor de una global y lo sustituye por un valor nuevo a efectos del cdigo que est en el bloqueactual y al que llamemos desde tal bloque.

Espacios de nombres

Una de las ideas bsicas, aunque no es necesario dominarla para muchos programas, es la de espacios de nombres. Las variables globales (las que no se declaran con my) estn en un paquete. Los paquetes proporcionan espacios de nombres, que voy a explicar usando como metfora los apellidos. En los pases de habla hispana, "Roberto" es un nombre bastante comn, as que es posible que conozcamos a ms de un "Roberto" (asumiendo que vivimos en uno de estos pases). Normalmente, para los humanos, el contexto de la conversacin basta para que nuestra audiencia sepa de qu "Roberto" estamos hablando (en el vestbulo de la piscina, "Roberto" es el que controla de dardos; pero en el trabajo "Roberto" es el director de la empresa).

Por supuesto, estas personas tambin tienen apellidos (pero existen personas distintas con el mismo apellido, as que despus de todo esta metfora no es perfecta), y si quisiramos ser explcitos podramos aadirlos para que quien nos oye sepa de qu "Roberto" hablamos. $Garcia::Roberto es una cosa distinta de $Gonzalez::Roberto. Cuando tenemos dos variables distintas con el mismo "nombre de pila", podemos referirnos a cualquiera de ellas, sin importar el lugar del cdigo en que nos encontremos, usando el nombre completo de la variable.

Se usa el operador package para cambiar el paquete actual. Cuando usamos package Garcia en el programa, estamos, en efecto, diciendo que todas las variables y funciones no calificadas (es decir, que no tienen "apellido" explcito) deben ser entendidas como si estuvieran en el paquete Garcia. Es como decir "en esta parte del programa, voy a hablar de la familia Garcia".

De forma implcita, hay un package main al principio de los programas, esto es, excepto que declaremos explcitamente un paquete distinto, todas las variables que se declaren (teniendo en cuenta el uso de my) estarn en main. A las variables que estn en un paquete se les llama, y con razn, "globales de paquete", porque se puede acceder a ellas sin ms desde todos los operadores y subrutinas que estn en tal paquete (y si somos explcitos con sus nombres, tambin son accesibles desde fuera de l).

Usar paquetes hace que acceder a las variables sea como moverse en distintos crculos. Por ejemplo, en el trabajo, se entiende que "Roberto" es "Roberto Szywiecki", el jefe. En la piscina, "Roberto" es "Roberto Yamauchi", el experto en dardos. Aqu tenemos un pequeo programa para mostrar el uso de paquetes:

#!/usr/bin/perl -wpackage Szywiecki;$Robert = "el jefe";sub terminate {  my $name = shift;  print "$Robert ha despedido a ${name}\n";}terminate("arturo"); # muestra "el jefe ha despedido a arturo"package main;# terminate("arturo"); # produce un error si se descomenta__OUTPUT__el jefe ha despedido a arturo

El nombre completo de la variable $Robert es $Szywiecki::Robert (ntese que el $ se desplaza al principio, antes del nombre del paquete, indicando que este es el escalar Robert que est en el paquete Szywiecki). Para el cdigo y, ms importante, las subrutinas del paquete Szywiecki, un $Robert sin calificar se refiere a $Szywiecki::Robert -- excepto que $Robert haya sido "enmascarado" por una declaracin my o local (hablaremos de esto despus).

Ahora, al hacer use strict (y se debera! consulta [strict.pm] por ejemplo), tendremos que declarar todas esas variables globales antes de poder usarlas, EXCEPTO que querramos usar siempre sus nombres completos. Esa es la razn por la que la segunda llamada a terminate fallara si la descomentramos. Perl espera encontrar una subrutina terminate en el paquete main, pero no la hemos definido. Es decir, esto:

#!/usr/bin/perl -wuse strict;$Robert = "el jefe";  # error!print "\$Robert = $Robert\n";

producir un error, mientras que si ponemos el nombre entero (recordando que existe un package main implcito), no hay problema:

#!/usr/bin/perl -wuse strict;$main::Robert = "el jefe";print "\$main::Robert = $main::Robert\n";

Para satisfacer a strict 'vars' (la parte de strict que se encarga de las declaraciones de variables), tenemos dos opciones; producen resultados distintos y una de ellas slo est disponible en Perl 5.6.0 y ms recientes:

El operador our ($foo, $bar) (en Perl 5.6.0 y superiores) declara $foo como una variable en el paquete actual.
use vars qw($foo $bar) (versiones anteriores, pero todava funciona en 5.6) le dice a strict 'vars' que es correcto usar estas variables sin calificarlas del todo.

Una de las diferencias entre our y el ms antiguo use vars es que our proporciona mbito lxico (ms acerca de esto en la seccin de my, ms abajo).

Otra diferencia es que con use vars, debemos usar un array de nombres de variables, no las variables propiamente dichas (tal como con our). Ambos mecanismos nos permiten usar globales al mismo tiempo que mantenemos uno de los principales beneficios de strict 'vars': el estar protegidos de crear variables accidentalmente si nos equivocamos al teclear. strict 'vars' exige que las variables se declaren explcitamente (como diciendo "estas son las globales que voy a usar"). Los dos mecanismos permiten hacer esto con globales de paquete.

Algo que debemos tener en cuenta (que es potencialmente algo malo, dependiendo de lo fantico que uno sea de la privacidad") es que las variables globales no son slo globales a ese paquete, sino que son accesibles desde cualquier parte del cdigo, siempre que se usen sus nombres completos. Podemos hablar de Roberto, el experto de dardos, en el trabajo si decimos "Roberto Yamauchi" (en este cdigo no uso strict por brevedad):

#!/usr/bin/perl -wpackage Szywiecki;$Robert = "el jefe";package PoolHall;$Robert = "el experto en dardos";package Szywiecki; # a trabajar otra vez!print "Aqu en el trabajo, 'Robert' es $Robert, pero en la piscina, 'Robert' es $PoolHall::Robert\n";__OUTPUT__Aqu en el trabajo, 'Robert' es el jefe, pero en la piscina, 'Robert' es el experto en dardos

Lo veis? Entender los paquetes no es tan difcil. En trminos generales, un paquete es como una familia de variables (y de subrutinas! el nombre completo de aquel terminate en un ejemplo anterior es &Szywiecki::terminate -- lo mismo sirve para hashes y arrays, por supuesto).

`my` (y un poco ms sobre `our`) a.k.a mbito lxico

Las variables declaradas con my no son globales, aunque pueden actuar como tales. Uno de los usos principales de my es operar con una variable que slo sirva en un bucle o subrutina, pero desde luego que hay muchos ms. He aqu algunos conceptos acerca de my:

El mbito de una variable my es un bloque de cdigo.
Un bloque se define normalmente con llaves { }, pero en lo que a Perl concierne, un archivo tambin es un bloque.
Las variables declaradas con my no pertenecen a ningn paquete, slo "pertenecen" a su bloque.
Aunque podemos dar nombre a los bloques (por ejemplo, BEGIN), no podemos calificar el nombre del bloque para acceder a la variable my.
Las variables my a nivel de archivo son las que se declaran en un archivo pero fuera de un bloque de cdigo.
No se puede acceder a una variable my de archivo desde fuera del archivo en que se declare (excepto que sea el valor de retorno de una subrutina, por ejemplo).

Mientras slo escribamos programas de un solo archivo (por ejemplo, los que no importan mdulos), algunos de estos conceptos no importan mucho. Pero si estamos interesados en privacidad y encapsulacin (por ejemplo, si escribimos mdulos), tendremos que entender todas esas cosas.

He aqu un programa comentado para explicar algunas:

#!/usr/bin/perl -wuse strict;#recordemos que estamos en el paquete mainuse vars qw($foo);$foo = "Yo!"; # damos valor a $main::fooprint "\$foo: $foo\n"; # muestra "Yo!"my $foo = "Hey!"; # variable my a nivel de archivoprint "\$foo: $foo\n"; # muestra "Hey!" -- la variable nueva 'pisa' a la vieja{ # comenzamos un bloque   my $foo = "Yacht-Z";     print "\$foo: $foo\n";   # muestra "Yacht-Z" -- hay una nueva variable $foo visible  print "\$main::foo: $main::foo\n";  # todava podemos ver $main::foo  subroutine();   } # fin del bloqueprint "\$foo: $foo\n"; # nuestra variable $foo a nivel de archivo se ve otra vez!print "\$main::foo: $main::foo\n"; # $main::foo todava est aqusub subroutine {  print "\$foo: $foo\n"; # muestra "Hey!"  # Por qu? porque la variable declarada en el bloque sin nombre est en    # su mbito -- ahora tenemos otras llaves distintas rodeando esto. Pero la  # variable de archivo todava est en mbito, y todava "pisa" a la  # declaracin de $main::foo.}package Bar;print "\$foo: $foo\n"; # muestra "Hey!" -- la variable my todava es visible# si no hubiramos hecho la declaracin arriba, esto provocara un error: el# intrprete nos dira que Bar::foo no ha sido definida.__OUTPUT__   $foo: Yo!      $foo: Hey!     $foo: Yacht-Z  $main::foo: Yo!$foo: Hey!$foo: Hey!$main::foo: Yo!  $foo: Hey!

Tal como la parte de abajo del ejemplo nos dice, dado que no estn en ningn paquete, las variables my pueden ser visibles incluso aunque hayamos declarado un paquete nuevo, dado que el bloque de cdigo es el archivo (al menos en este ejemplo).

Este ejemplo usa un bloque sin nombre, no hay estructura de control asociada (por ejemplo if o while). Pero de ser as tampoco habra diferencias.

Las variables my de archivo SON accesibles desde los bloques definidos en ese archivo (tal como el ejemplo muestra), esta es una manera de la que pueden actuar como globales. Si, no obstante, subroutine se hubiera definido en otro archivo, tendramos un error en tiempo de ejecucin. Una vez sabemos cmo funciona my, podemos saber, slo fijndonos en la sintaxis del archivo, dnde va a ser visible. Esta es una razn por la que el mbito que proporciona se llama "lxico". En esto, use vars y el nuevo operador our difieren: si ponemos our $foo en el paquete Bar pero fuera de un bloque, estamos diciendo que (hasta que aparezca otro operador de mbito) debe entenderse que las ocurrencias de $foo se refieren a $Bar::foo. Esto ilustra la diferencia entre use vars y el nuevo our:

#!/usr/bin/perl -wuse strict;our ($bob);use vars qw($carol);$carol = "ted";$bob = "alice";print "Bob => $bob, Carol => $carol\n";package Movie;print "Bob => $bob, Carol => $carol\n";

El segundo print produce un error, porque $carol se toma como $Movie::carol, mientras que $bob es $main::bob.

Mientras que esta "expansin sobre paquetes" (que slo se muestra en el caso de our) es una similaridad funcional entre los dos tipos distintos de operadores de mbito, no debemos olvidar la diferencia entre ellos, que es que our declara una global, pero my no.

`local` a.k.a. mbito dinmico

Ahora llegamos a local, que es como my, pero debido a su nombre, su funcin se confunde con frecuencia con la de my. Aqu est el detalle: local $foo almacena el valor actual de la variable global $foo, y hace que en el bloque actual y en el cdigo al que se llame desde el bloque actual, $foo se refiera al valor que le demos en tal bloque (hacer local $foo le dar a $foo el valor undef, lo mismo que con my). Actualmente, local slo funciona en globales, no se puede usar sobre una variable my.

Ya que local puede afectar a cosas que ocurren fuera del bloque en que lo hemos usado, local proporciona mbito denominado dinmico, ya que su efecto se determina a partir de lo que ocurre cuando se ejecuta el programa. Esto es, el compilador no puede saber cuando local har efecto o no durante la compilacin del programa (que ocurre antes de la ejecucin del mismo). Esto distingue el mbito dinmico del lxico proporcionado por my y our, que tienen efectos visibles en tiempo de compilacin.

El resultado bsico de esta diferencia es que si localizamos una variable dentro de un bloque y llamamos a una subrutina desde ese bloque, la subrutina ver el valor de la variable localizada. Esta es una diferencia importante entre my y local. Comparar el ejemplo anterior con este:

#!/usr/bin/perl -wuse strict;use vars qw ($foo); # "our $foo" si usamos 5.6$foo = "global value";print "\$foo: $foo\n"; # muestra "global value"print "mysub    result '", &mysub(),    "'\n"; # "global value"print "localsub result '", &localsub(), "'\n"; # "local value"print "no sub   result '", &showfoo(),  "'\n"; # "global value"sub mysub { my $foo = "my value"; showfoo();}sub localsub { local $foo = "local value"; showfoo(); # SIEMPRE muestra "local value"}sub showfoo {  return $foo;}__OUTPUT__$foo: global valuemysub    result 'global value'localsub result 'local value'no sub   result 'global value'

Ntese que showfoo ignora (en apariencia) la declaracin my de mysub (ya que hemos abandonado el bloque en el que la declaracin my tiene efecto) pero la declaracin local de localsub no se ignora. Y despus de abandonar ese bloque, el valor original de $foo se vuelve a ver.

Espero que hayis aprendido tanto al leer esto como yo al escribirlo!

POD en 5 minutos (Hue-Bond)

Translated to spanish from [node://Juerd]'s original [id://252477].

Plain Old Documentation en 5 minutos

La documentacin es importante

Todos el mundo lo sabe, y sabe por qu. Me voy a saltar esta seccin porque cualquier discusin detallada de por qu la documentacin es importante rompera mi promesa de que se puede aprender a documentar en cinco minutos.

Documentacin en Perl

El cdigo fuente en Perl puede contener documentacin en formato POD. POD significa "Plain Old Documentation" (documentacin sencilla y antigua). Se puede mezclar POD con cdigo, poner todo el POD al principio o ponerlo al final. Slo depende del gusto de cada uno. T eliges.

Encabezados en POD

La estructura lgica es importante, por tanto se suelen usar encabezados. Hay cuatro niveles, y con esto debera llegar. Se usan los comandos =head1 .. =head4 (oficialmente se les llama comandos de prrafo. Son prrafos porque estn separados del resto del POD mediante lneas enblanco).

=head1 NOMBREMy::Module - Un mdulo de ejemplo

Secciones habituales

Para mantener las cosas claras, se usan las mismas secciones en todas partes. Ya hemos visto la seccin NOMBRE. S, es costumbre escribir los prrafos head1 en MAYSCULAS. Si haces mdulos para CPAN, debes usar este estilo. Si no, o si usas POD para otras cosas que documentacin (tambin es un formato bueno para escribir artculos o informes), queda a tu eleccin.

NOMBRE contiene el nombre del mdulo o script, un guin y una descripcin corta.
SINOPSIS significa "ver todo junto" y muestra ejemplos de uso.
DESCRIPCIN contiene una descripcin larga de lo que hace el mdulo y lista sus funciones.
BUGS o ADVERTENCIAS habla de los bugs o problemas que el usuario debera conocer.
AGRADECIMIENTOS es donde el autor agracede a los que arreglan bugs y prueban el programa.
COPYRIGHT o LICENCIA menciona las restricciones de copyright. Sin embargo, no hay que poner toda la GPL :).
DISPONIBILIDAD anuncia dnde se pueden encontrar versiones ms recientes.
AUTOR explica quin ha hecho el programa, si no lo hace ya la seccin COPYRIGHT.
VASE TAMBIN refiere al lector a un lugar con ms documentacin.

Todos estos son para =head1.

Las funciones, mtodos y todo eso se explican normalmente en una seccin =head2 bajo DESCRIPCIN.

Como mnimo, hay que documentar los argumentos que reciben las funciones y los valores que se devuelven. Si hay condiciones necesarias para algo, se deben mencionar. Si una funcin devuelve undef cuando hay errores, hay que hacrselo saber a la gente.

Est bien escribir frases cortas. Es mejor evitar las largas.

Ejemplos de cdigo

Los prrafos tabulados se toman como cdigo, con la tabulacin intacta. As de fcil!:

=head1 SINOPSIS    use My::Module;    my $object = My::Module->new();     print $object->as_string;

Esto se llama un prrafo textual.

Marcado

POD soporta un pequeo conjunto de elementos de marcado. Para mantener mi promesa, me voy a limitar a enumerarlos:

B<texto en negrita>
B<texto en cursiva>
B<texto subrayado>
B<cdigo>
B<y se pueden I<anidar>>

Tambin hay F, S, X y Z pero apenas se usan y no merece la pena explicarlos en un tutorial pequeo como este.

Si alguna vez hace falta incluir un carcter '>' dentro de cdigo, hay dos opciones. Si queremos poner $foo->bar con fuente de cdigo, podemos hacer esto:

C<$foo-E<gt>bar>
C<< $foo->bar >> (los espacios son necesarios!)
C<<< $foo->bar >>> (los espacios son necesarios!)

Entidades

Hemos visto que se puede usar E para entidades. Son como las entidades de HTML; tambin tenemos estas:

verbar para una barra vertical.
sol para una barra (solidus).

Las entidades numricas pueden ir en decimal, octal (con el prefijo '0') y en hexadecimal (con el prefijo '0x').

Listas

En este caso un ejemplo es mucho ms claro que una explicacin:

=head2 Mtodos=over 12=item CDevuelve un objeto My::Module nuevo.=item CDevuelve una representacin delobjeto en forma de cadena. Sirveprincipalmente para depuracin.=back

Como puede verse, se empieza esta lista con =over y la acabamos con =back. Entre ambos comandos hay =items. El nmero despus de =over es el nivel de tabulacin, usado principalmente por los renderizadores de texto para conseguir un diseo horizontal. pod2text convierte el ejemplo anterior en:

  Methods      "new"       Returns a new                  My::Module object.      "as_string" Returns a stringified                   representation of the                   object. This is mainly                  for debugging purposes.

Otras cositas de POD

Se puede usar L para enlazar a secciones del mismo documento o a otros documentos. POD se termina con =cut para volver a Perl. Hay comandos especiales para los distintos formatos de salida. Para leer la documentacin completa de POD, teclear:

perldoc perlpod

Un ejemplo completo

=head1 NOMBREMy::Module - Un mdulo de ejemplo=head1 SINOPSIS    use My::Module;    my $object = My::Module->new();    print $object->as_string;=head1 DESCRIPCINEste mdulo no existe en realidad, sehizo con el nico objetivo de mostrarcmo funciona POD.=head2 Mtodos=over 12=item CDevuelve un objeto My::Module nuevo.=item CDevuelve una representacin delobjeto en forma de cadena. Sirveprincipalmente para depuracin.=back=head1 AUTORJuerd - =head1 VASE TAMBINL, L=cut

Conclusin

Documentar con POD es fcil. A divertirse!

perlunitut: Unicode in Perl (Juerd)

NAME
DESCRIPTION

Definitions

Unicode
UTF-8
Text strings (character strings)
Binary strings (byte strings)
Encoding
Decoding
Internal format

Your new toolkit
I/O flow (the actual 5 minute tutorial)
Q and A

This isn't really a Unicode tutorial, is it?
What about binary data, like images?
What about the UTF-8 flag?
When should I decode or encode?
What if I don't decode?
What if I don't encode?
Is there a way to automatically decode or encode?
Cheat?! Tell me, how can I cheat?
What if I don't know which encoding was used?
Can I use Unicode in my Perl sources?
Data::Dumper doesn't restore the UTF-8 flag; is it broken?
How can I determine if a string is a text string or a binary string?
How do I convert from encoding FOO to encoding BAR?
What about the use bytes pragma?
What are decode_utf8 and encode_utf8?
What's the difference between UTF-8 and utf8?
What character encodings does Perl support?
Which version of perl should I use?

SUMMARY
ACKNOWLEDGEMENTS
AUTHOR
SEE ALSO

NAME

perlunitut - Perl Unicode Tutorial

DESCRIPTION

The days of just flinging strings around are over. It's well established thatmodern programs need to be capable of communicating funny accented letters, andthings like euro symbols. This means that programmers need new habits. It'seasy to program Unicode capable software, but it does require discipline to doit right.

There's a lot to know about character sets, and text encodings. It's probablybest to spend a full day learning all this, but the basics can be learned inminutes.

These are not the very basics, though. It is assumed that you alreadyknow the difference between bytes and characters, and realise (and accept!)that there are many different character sets and encodings, and that yourprogram has to be explicit about them. Recommended reading is ``The AbsoluteMinimum Every Software Developer Absolutely, Positively Must Know About Unicodeand Character Sets (No Excuses!)'' by Joel Spolsky, athttp://joelonsoftware.com/articles/Unicode.html.

This tutorial speaks in rather absolute terms, and provides only a limited viewof the wealth of character string related features that Perl has to offer. Formost projects, this information will probably suffice.

Definitions

It's important to set a few things straight first. This is the most importantpart of this tutorial. This view may conflict with other information that youmay have found on the web, but that's mostly because many sources are wrong.

You may have to re-read this entire section a few times...

Unicode

Unicode is a character set with room for lots of characters. The ordinalvalue of a character is called a code point.

There are many, many code points, but computers work with bytes, and a byte canhave only 256 values. Unicode has many more characters, so you need a methodto make these accessible.

Unicode is encoded using several competing encodings, of which UTF-8 is themost used. In a Unicode encoding, multiple subsequent bytes can be used tostore a single code point, or simply: character.

UTF-8

UTF-8 is a Unicode encoding. Many people think that Unicode and UTF-8 arethe same thing, but they're not. There are more Unicode encodings, but much ofthe world has standardized on UTF-8.

UTF-8 treats the first 128 codepoints, 0..127, the same as ASCII. They takeonly one byte per character. All other characters are encoded as two or more(up to six) bytes using a complex scheme. Fortunately, Perl handles this forus, so we don't have to worry about this.

Text strings (character strings)

Text strings, or character strings are made of characters. Bytes areirrelevant here, and so are encodings. Each character is just that: thecharacter.

On a text string, you would do things like:

    $text =~ s/foo/bar/;    if ($string =~ /^\d+$/) { ... }    $text = ucfirst $text;    my $character_count = length $text;

The value of a character (ord, chr) is the corresponding Unicode codepoint.

Binary strings (byte strings)

Binary strings, or byte strings are made of bytes. Here, you don't havecharacters, just bytes. All communication with the outside world (anythingoutside of your current Perl process) is done in binary.

On a binary string, you would do things like:

    my (@length_content) = unpack "(V/a)*", $binary;    $binary =~ s/\x00\x0F/\xFF\xF0/;  # for the brave :)    print {$fh} $binary;    my $byte_count = length $binary;

Encoding

Encoding (as a verb) is the conversion from text to binary. To encode,you have to supply the target encoding, for example iso-8859-1 or UTF-8.Some encodings, like the iso-8859 (``latin'') range, do not support theUnicode standard; characters that can't be represented are lost in theconversion.

Decoding

Decoding is the conversion from binary to text. To decode, you have toknow what encoding was used during the encoding phase. And most of all, it mustbe something decodable. It doesn't make much sense to decode a PNG image into atext string.

Internal format

Perl has an internal format, an encoding that it uses to encode text stringsso it can store them in memory. All text strings are in this internal format.In fact, text strings are never in any other format!

You shouldn't worry about what this format is, because conversion isautomatically done when you decode or encode.

Your new toolkit

Add to your standard heading the following line:

    use Encode qw(encode decode);

Or, if you're lazy, just:

    use Encode;

I/O flow (the actual 5 minute tutorial)

The typical input/output flow of a program is:

    1. Receive and decode    2. Process    3. Encode and output

If your input is binary, and is supposed to remain binary, you shouldn't decodeit to a text string, of course. But in all other cases, you should decode it.

Decoding can't happen reliably if you don't know how the data was encoded. Ifyou get to choose, it's a good idea to standardize on UTF-8.

    my $foo   = decode('UTF-8', get 'http://example.com/');    my $bar   = decode('ISO-8859-1', readline STDIN);    my $xyzzy = decode('Windows-1251', $cgi->param('foo'));

Processing happens as you knew before. The only difference is that you're nowusing characters instead of bytes. That's very useful if you use things likesubstr, or length.

It's important to realize that there are no bytes in a text string. Of course,Perl has its internal encoding to store the string in memory, but ignore that.If you have to do anything with the number of bytes, it's probably best to movethat part to step 3, just after you've encoded the string. Then you knowexactly how many bytes it will be in the destination string.

The syntax for encoding text strings to binary strings is as simple as decoding:

    $body = encode('UTF-8', $body);

If you needed to know the length of the string in bytes, now's the perfect timefor that. Because $body is now a byte string, length will report thenumber of bytes, instead of the number of characters. The number ofcharacters is no longer known, because characters only exist in text strings.

    my $byte_count = length $body;

And if the protocol you're using supports a way of letting the recipient knowwhich character encoding you used, please help the receiving end by using thatfeature! For example, E-mail and HTTP support MIME headers, so you can use theContent-Type header. They can also have Content-Length to indicate thenumber of bytes, which is always a good idea to supply if the number isknown.

    "Content-Type: text/plain; charset=UTF-8",    "Content-Length: $byte_count"

Q and A

This isn't really a Unicode tutorial, is it?

No, Perl has an abstracted interface for all supported character encodings, sothis is actually a generic Encode tutorial. But many people think thatUnicode is special and magical, and I did't want to disappoint them, so Idecided to call this document a Unicode tutorial.

What about binary data, like images?

Well, apart from a bare binmode $fh, you shouldn't treat them specially.(The binmode is needed because otherwise Perl may convert line endings on Win32systems.)

Be careful, though, to never combine text strings with binary strings. If youneed text in a binary stream, encode your text strings first using theappropriate encoding, then join them with binary strings. See also: ``What if Idon't encode?''.

What about the UTF-8 flag?

Please, unless you're hacking the internals, or debugging weirdness, don'tthink about the UTF-8 flag at all. That means that you very probably shouldn'tuse is_utf8, _utf8_on or _utf8_off at all.

Perl's internal format happens to be UTF-8. Unfortunately, Perl can't keep asecret, so everyone knows about this. That is the source of much confusion.It's better to pretend that the internal format is some unknown encoding,and that you always have to encode and decode explicitly.

When should I decode or encode?

Whenever you're communicating with anything that is external to your perlprocess, like a database, a text file, a socket, or another program. Even ifthe thing you're communicating with is also written in Perl.

What if I don't decode?

Whenever your encoded, binary string is used together with a text string, Perlwill assume that your binary string was encoded with ISO-8859-1, also known aslatin-1. If it wasn't latin-1, then your data is unpleasantly converted. Forexample, if it was UTF-8, the individual bytes of multibyte characters are seenas separate characters, and then again converted to UTF-8. Such double encodingcan be compared to double HTML encoding (&gt;), or double URI encoding(%253E).

This silent implicit decoding is known as ``upgrading''. That may soundpositive, but it's best to avoid it.

What if I don't encode?

Your text string will be sent using the bytes in Perl's internal format. Insome cases, Perl will warn you that you're doing something wrong, with afriendly warning:

    Wide character in print at example.pl line 2.

Because the internal format is really UTF-8, these bugs are hard to spot,because UTF-8 is usually the encoding you wanted! But don't be lazy, and don'tuse the fact that Perl's internal format is UTF-8 to your advantage. Encodeexplicitly to avoid weird bugs, and to show to maintenance programmers that youthought this through.

Is there a way to automatically decode or encode?

If all data that comes from a certain handle is encoded in exactly the sameway, you can tell the PerlIO system to automatically decode everything, withthe encoding layer.

You can provide this layer when opening the file:

    open my $fh, '>:encoding(UTF-8)', $filename;  # auto encoding on write    open my $fh, '<:encoding(UTF-8)', $filename;  # auto decoding on read

Or if you already have an open filehandle:

    binmode $fh, ':encoding(UTF-8)';

Some database drivers for DBI can also automatically encode and decode, butthat is typically limited to the UTF-8 encoding, because they cheat.

Cheat?! Tell me, how can I cheat?

Well, because Perl's internal format is UTF-8, you can just skip the encodingor decoding step, and manipulate the UTF-8 flag directly.

Instead of :encoding(UTF-8), you can simply use :utf8. This is widelyaccepted as good behavior.

Instead of decode and encode, you could use _utf8_on and _utf8_off.But this is, contrary to :utf8, considered bad style.

There are some shortcuts for oneliners; see -C in perlrun.

What if I don't know which encoding was used?

Do whatever you can to find out, and if you have to: guess. (Don't forget todocument your guess with a comment.)

You could open the document in a web browser, and change the character set orcharacter encoding until you can visually confirm that all characters look theway they should.

There is no way to reliably detect the encoding automatically, so if peoplekeep sending you data without charset indication, you may have to educate them.

Can I use Unicode in my Perl sources?

Yes, you can! If your sources are UTF-8 encoded, you can indicate that with theuse utf8 pragma.

    use utf8;

This doesn't do anything to your input, or to your output. It only influencesthe way your sources are read. You can use Unicode in string literals, inidentifiers (but they still have to be ``word characters'' according to \w),and even in custom delimiters.

Data::Dumper doesn't restore the UTF-8 flag; is it broken?

No, Data::Dumper's Unicode abilities are as they should be. There have beensome complaints that it should restore the UTF-8 flag when the data is readagain with eval. However, you should really not look at the flag, andnothing indicates that Data::Dumper should break this rule.

Here's what happens: when Perl reads in a string literal, it sticks to 8 bitencoding as long as it can. (But perhaps originally it was internally encodedas UTF-8, when you dumped it.) When it has to give that up because othercharacters are added to the text string, it silently upgrades the string toUTF-8.

If you properly encode your strings for output, none of this is of yourconcern, and you can just eval dumped data as always.

How can I determine if a string is a text string or a binary string?

You can't. Some use the UTF-8 flag for this, but that's misuse, and makes wellbehaved modules like Data::Dumper look bad. The flag is useless for thispurpose, because it's off when an 8 bit encoding (by default ISO-8859-1) isused to store the string.

This is something you, the programmer, has to keep track of; sorry. You couldconsider adopting a kind of ``Hungarian notation'' to help with this.

How do I convert from encoding FOO to encoding BAR?

By first converting the FOO-encoded byte string to a text string, and then thetext string to a BAR-encoded byte string:

    my $text_string = decode('FOO', $foo_string);    my $bar_string  = encode('BAR', $text_string);

or by skipping the text string part, and going directly from one binaryencoding to the other:

    use Encode qw(from_to);    from_to($string, 'FOO', 'BAR');  # changes contents of $string

or by letting automatic decoding and encoding do all the work:

    open my $foofh, '<:encoding(FOO)', 'example.foo.txt';    open my $barfh, '>:encoding(BAR)', 'example.bar.txt';    print { $barfh } $_ while <$foofh>;

What about the `use bytes` pragma?

Don't use it. It makes no sense to deal with bytes in a text string, and itmakes no sense to deal with characters in a byte string. Do the properconversions (by decoding/encoding), and things will work out well: you getcharacter counts for decoded data, and byte counts for encoded data.

use bytes is usually a failed attempt to do something useful. Just forgetabout it.

What are `decode_utf8` and `encode_utf8`?

These are alternate syntaxes for decode('utf8', ...) and

encode('utf8',...)

What's the difference between `UTF-8` and `utf8`?

UTF-8 is the official standard. utf8 is Perl's way of being liberal inwhat it accepts. If you have to communicate with things that aren't so liberal,you may want to consider using UTF-8. If you have to communicate with thingsthat are too liberal, you may have to use utf8. The full explanation is inEncode.

UTF-8 is internally known as utf-8-strict. This tutorial uses UTF-8consistently, even where utf8 is actually used internally, because thedistinction can be hard to make, and is mostly irrelevant.

Okay, if you insist: the ``internal format'' is utf8, not UTF-8.

What character encodings does Perl support?

To find out which character encodings your Perl supports, run:

    perl -MEncode -le "print for Encode->encodings( q:all )";

Which version of perl should I use?

Well, if you can, upgrade to the most recent, but certainly 5.8.1 or newer.This tutorial is based on the status quo as of 5.8.7.

You should also check your modules, and upgrade them if necessary. For example,HTML::Entities requires version >= 1.32 to function correctly, even though thechangelog is silent about this.

SUMMARY

Decode everything you receive, encode everything you send out. (If it's textdata.)

ACKNOWLEDGEMENTS

Thanks to Johan Vromans from Squirrel Consultancy. His UTF-8 rants during theAmsterdam Perl Mongers meetings got me interested and determined to find outhow to use character encodings in Perl in ways that don't break easily.

Thanks to Gerard Goossen from TTY. His presentation ``UTF-8 in the wild'' (DutchPerl Workshop 2006) inspired me to publish my thoughts and write this tutorial.

Thanks to the people who asked about this kind of stuff in several Perl IRCchannels, and have constantly reminded me that a simpler explanation wasneeded.

Thanks to the people who reviewed this document for me, before it went public.They are: Benjamin Smith, Jan-Pieter Cornet, Johan Vromans, Lukas Mai, NathanGray.

AUTHOR

Juerd Waalboer <juerd@cpan.org>

A Simple Socket Server Using 'inetd' (dwildesnl)

Using inetd to serve a socket

It is often the case that one needs to test a system before the hardware is available or on-line. In my case, I'm developing an interface which will talk to a socket on a complex piece of Fab Metrology gear called an Applied Materials NanoSEM, using a complex protocol called SEMI SECS-II/GEM HSMS. I needed a quick and dirty handler to act as the NanoSEM while I get the protocol parser working.

UNIX-like systems such as FreeBSD and Linux have a nifty feature called inetd, which comes to our rescue. inetd runs a program you specify whenever somebody else tries to connect to the socket you've chosen. By making a few simple configuration improvements, we can send our input to the specified socket, and inetd invokes our program, passing our input to it as STDIN. Our handler then processes it and spits out its response as STDOUT back to our socket. Cool, huh? What's even more cool is that if another process (or system) also tries to connect to the same socket, inetd will invoke another copy of our handler without bothering the first one.

Interested? Okay, here's the code...

The server handler:

#!/usr/bin/perl -w -T# sinet.pl A simple inetd socket server.use strict;my $old_fh = select(STDOUT);$| = 1;select($old_fh);while( my $line =  ){    $line =~ s/\r?\n$//;    if ($line =~ /endit/)     {die "shutting down\n";    }# do your processing here!    print "  $line\n";}

This little program will process anything that comes in on the specified port, clearing carriage returns and line feeds, and (in this simple case) spitting it back with two spaces in front and a newline at the end. An input containing "endit" causes the handler to exit, and, thanks to the flush sequence at the top, output is immediate. Make your program executable:

# chmod +x /usr/local/bin/sinet.pl

The configuration:

Okay, now, here's the setup. In /etc (you need to be superuser), edit /etc/services to add your port number to the known services list, making up a unique name for the service. My port is 6100, its service is 'secshsms', and I've asked it to handle both stream (tcp) and datagram (udp) packets, although this example will only deal with tcp.

secshsms6100/tcp   # DSW Handler for SECS-II/GEM HSMS trafficsecshsms6100/udp   # DSW

Next, edit /etc/inetd.conf to attach your program to that service:

# DSW add-on for SECS-II over HSMSsecshsmsstreamtcpnowaitnobody/usr/local/bin/sinet.pl secshsms

Okay, find inetd and restart it.

# ps -ax | grep inetd  563  ??  Is      0:00.01 /usr/sbin/inetd -wW -C 60# kill -1 563

From now on, any process that attempts to talk to my machine's port 6100 gets its output routed to my handler sinet.pl.

With that in hand, here's a sample client, adapted from Perl Cookbook recipe 17.10. It can be installed on any machine within a routable network (i.e., no firewall) and it will talk to my handler.

A simple client:

#!/usr/bin/perl# ncliauto.pl a simple automated clientuse warnings;use strict;use IO::Socket;my ( $confstr, $host, $port, $kidpid, $handle, $line, @say );# the config file contains host name (or IP addr) and port number, with a space between# examples:  localhost 6100#            myserv.mynet.com 6100#            123.456.789.1 6100open( CONF, "<./hsms.conf") or die "conf file: $!\n";$confstr = ;close( CONF ) or die "closing conf file: $!\n";chomp $confstr;( $host, $port ) = split( /\s+/, $confstr );# This is our demo array of outputs sent to the handler@say = ( 'You are getting sleepy...', '... very sleepy.', 'Your eyes are getting very heavy!', "... it's so hard to hold them open.", "You're so very sleepy now.", 'You just want to go to sleep.', 'Sleep feels so good!', "You're asleep. Sleep!", "You've earned it, just relax and sleep!", "... Sleep!", "              Sleep!", "                        Sleep!", '', '... zzz... zzz... ...zzz ...', 'endit');# This creates our client socket$handle = IO::Socket::INET->new( Proto => "tcp", PeerAddr => $host, PeerPort => $port )    or die "can't connect to port '$port' on host '$host': $!\n";# make sure it turns around inputs immediately$handle->autoflush(1);# announce our connectionprint STDERR "[connected to $host:$port]\n";# fork a child to handle sending our data to the socketdie "can't fork: $!\n" unless defined($kidpid = fork());if ( $kidpid ){#   The parent handles data coming from the socket server to us    while ( defined( $line = <$handle> ) )    {print STDOUT $line;    }#   ... until the connection is broken    kill( "TERM" => $kidpid );}else{#   The child process receives data for us    foreach my $item ( @say )    {print $handle $item . "\r\n";sleep 1;    } }exit;

Working from this skeleton, a more elaborate language can be developed. The program on each end can be made to parse and respond to commands from the other.

UPDATE 1: changed server user to nobody, thank you [idsfa].

Don Wilde
"There's more than one level to any answer."

Gay (Anonymous Monk)

UR GAY U STUPID BIATCH

Module::Compile (or: what's this PMC thingy?) (Juerd)

This document is written in response to many questions triggered by [id://536101]. It's not useful as a tutorial, because Module::Compile is in its infancy and very likely to change further, but posted here because it provides information only.

History

Once upon a time, people thought that maybe Perl would be faster if compiled code could be re-used in a later session. (Actually, many people still do.) So they created support for compiled Perl Modules, and where Python libraries got their "c" after their "py", compiled Perl modules would get their "c" after their "pm", and the "pmc" extension was born.

It works somewhat like this: you have a module, say, Test.pm, and the following line gives you the compiled version:

perl -MO=Bytecode,-H -MTest -e1 > Test.pmc

Provided that Test.pmc is in the same directory that Test.pm is, perl will automatically load Test.pmc instead of Test.pm the next time someone uses "use Test" or "require Test". This is because in every directory of @INC, perl first sees if a .pmc exists, and if it does, it loads that, and if not, then it tries to load the .pm.

What's going on?

If you strace the process, you can easily see what was going on before:

stat64("/usr/local/lib/perl/5.8.7/Test.pmc", 0x7fe20a50) = -1 ENOENT (No such file or directory)open("/usr/local/lib/perl/5.8.7/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/local/share/perl/5.8.7/Test.pmc", 0x7fe20a50) = -1 ENOENT (No such file or directory)open("/usr/local/share/perl/5.8.7/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/lib/perl5/Test.pmc", 0x7fe20a50) = -1 ENOENT (No such file or directory)open("/usr/lib/perl5/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/share/perl5/Test.pmc", 0x7fe20a50) = -1 ENOENT (No such file or directory)open("/usr/share/perl5/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/lib/perl/5.8/Test.pmc", 0x7fe20a50) = -1 ENOENT (No such file or directory)open("/usr/lib/perl/5.8/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/share/perl/5.8/Test.pmc", 0x7fe20a50) = -1 ENOENT (No such file or directory)open("/usr/share/perl/5.8/Test.pm", O_RDONLY|O_LARGEFILE) = 4

Before perl finds Test.pm in /usr/share/perl/5.8, it first tries a lot of other directories, each time stat()ing Test.pmc first, and then trying to open Test.pm. Now, because I have created a Test.pm in /usr/share/perl/5.8, perl's done a little earlier:

stat64("/usr/local/lib/perl/5.8.7/Test.pmc", 0x7f95aa50) = -1 ENOENT (No such file or directory)open("/usr/local/lib/perl/5.8.7/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/local/share/perl/5.8.7/Test.pmc", 0x7f95aa50) = -1 ENOENT (No such file or directory)open("/usr/local/share/perl/5.8.7/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/lib/perl5/Test.pmc", 0x7f95aa50) = -1 ENOENT (No such file or directory)open("/usr/lib/perl5/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/share/perl5/Test.pmc", 0x7f95aa50) = -1 ENOENT (No such file or directory)open("/usr/share/perl5/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/lib/perl/5.8/Test.pmc", 0x7f95aa50) = -1 ENOENT (No such file or directory)open("/usr/lib/perl/5.8/Test.pm", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)stat64("/usr/share/perl/5.8/Test.pmc", {st_mode=S_IFREG|0644, st_size=720, ...}) = 0stat64("/usr/share/perl/5.8/Test.pm", {st_mode=S_IFREG|0644, st_size=28863, ...}) = 0open("/usr/share/perl/5.8/Test.pmc", O_RDONLY|O_LARGEFILE) = 4

Don't be fooled by the stat() on Test.pm; it's ignored. The actual open() is now on Test.pmc instead of Test.pm.

Sad ending

So, why did (and does) nobody really use this? Well, it turns out that bytecode loading is indeed faster in some (but not all) cases, but not very reliable: segfaults are quite common, and nobody so far has been able to fix it.

But there is another problem with Byteloader. The PMC file is actually just a normal Perl file: via a source filter, the bytecode is loaded. That's nasty, and makes using precompiled bytecode even less interesting.

Thus a sad story seemed to end, and the PMC feature was ignored, forgotten, and almost about to be deprecated... (Features aren't removed lightly in Perl - even if nobody uses it, a deprecation cycle is needed.)

Joyful rebirth of PMC and source filters

... if it weren't for the incredible geniuses who work on Perl 6 to find a very neat way to use the PMC feature to make Perl 6 acceptance and initial use less painful!

But actually, it's not even really Perl 6 related. It's just a very neat thing that you can also put to good use if you don't want to use Perl 6 yet. You see, we have source filters that can do very nice and spiffy (no pun intended) things for us, but are also known to have certain negative feelings attached to them. Sourcefilters have problems with mod_perl and other embedded perls, and they cannot be combined with other source filters. Besides that, source filters are always runtime overhead, and the result is usually not cached anywhere. You can't even debug the result easily, because the intermediate code is not available on disk.

The new invention exists in the form of [cpan://Module::Compile], formerly (for less than a day — that's how fast things go in Freenode #perl6) known as PMC::Filter.

Instead of using the normal source filters, Module::Compile writes the "compiled" code to a .pmc file, and that's loaded from that point forward. The nice trick is that the PMC file doesn't have to be bytecode. It's just a normal pure Perl file.

But we call them compilers now

A "compiler" (read: source filter) is built quite easily:

package Foo;use Module::Compile -base;sub pmc_compile {    my ($class, $source) = @_;    # Convert $source into (most like Perl 5) $compiled_output    return $compiled_output;}1;

and using that is also very straight forward:

# Unfiltered code herequux(bar);use Foo;# This code is filtered!# Ehh... I mean compiled!no Foo;# Unfiltered code here, againquux(bar);

A nice solution for everyone who has found a good use for source filters, but doesn't use them. Module::Compile supports using multiple compilers (source filters, for those who still don't get it) at the same time, the intermediate code is available for simpler debugging, and it works well even with embedded perls.

Perl 6 again

Remember that it was Perl 6 people that invented all this? It must have something to do with Perl 6, then, right? Well, but of course! The idea is to compile Perl 6 code into Perl 5 code, so that you can use it without Perl 6. You can do this to have a module that has parts in Perl 5 and parts in Perl 6, which is nice if you want to upgrade an existing module with some of the nice new features that Perl 6 has to offer, but don't want to rewrite everything just yet.

An even nicer thing, though, is that this allows you to write modules that are fully Perl 6, that will work both in Perl 5 and Perl 6.

Distribution

There are two problems with the PMC technique, though:

You need to have all the stuff installed that is needed for a succesful compilation
Users don't have write access in the system library directories

But there is one solution that solves both these problems: let Module::Compile generate your PMCs as you develop your software, and when you're done, distribute the compiled result along with the rest, so that people can use that. Also, if the PMC is installed with the rest, then someone with superuser privileges installs it.

Perl 6 example

Oh, you want example code, of course! Here it is, again copied straight from Module::Compile's documentation:

# User.pmuse v6-pugs;module User;...some p6 code here...no v6;...back to p5 land...

Oh well, I'll steal their explanation too:

On the first time this module is loaded, it will compile Perl 6 chunks into Perl 5 (as soon as the no v6 line is seen), and merge it with the Perl 5 chunks, saving the result into a User.pmc file.

The next time around, Perl 5 will automatically load User.pmc when someone says use Foo. On the other hand, Perl 6 can run User.pm as a Perl 6 module just fine, as "use v6-pugs" and "no v6" both works in a perl 6 setting also.

The pmc module will imbue v6.pm with the ability to check for Foo.pmc's updatedness also, and if it's up to date, then it'd touch its timestamp so the .pmc is loaded on the next time.

Final words

And that's why you shouldn't disable the PMC feature in Perl: although unused since its invention in 1999, there's now a very powerful use for it! Fortunately, so far the survey shows that only Mandrake/Mandriva users have it disabled. They can fix it soon, by upgrading.

Do note that Perl 6 is very far from production quality, and that Module::Compile is also still very young. You should probably not use them for anything serious yet.

Thank you, ingy++ and audreyt++, for bringing us this wonderful innovation!

Using Look-ahead and Look-behind (Roy Johnson)

If you are familiar with Perl's regular expressions, you are probably already familiar with zero-width assertions: the ^ indicating the beginning of string and the \b indicating a word boundary are examples. They do not match any characters, but "look around" to see what comes before and/or after the current position.

With the look-ahead and look-behind constructs documented in perlre.html#Extended-Patterns, you can "roll your own" zero-width assertions to fit your needs. You can look forward or backward in the string being processed, and you can require that a pattern match succeed (positive assertion) or fail (negative assertion) there.

Syntax

Every extended pattern is written as a parenthetical group with a question mark as the first character. The notation for the look-arounds is fairly mnemonic, but there are some other, experimental patterns that are similar, so it is important to get all the characters in the right order.

(?=pattern): is a positive look-ahead assertion
(?!pattern): is a negative look-ahead assertion
(?<=pattern): is a positive look-behind assertion
(?pattern): is a negative look-behind assertion

Notice that the = or ! is always last. The directional indicator is only present in the look-behind, and comes before the positive-negative indicator.Common tasks Finding the last occurrence There are actually a number of ways to get the last occurrence that don't involve look-around, but if you think of "the last foo" as "foo that isn't followed by a string containing foo", you can express that notion like this:/foo(?!.*foo)/ The regular expression engine will do its best to match .*foo, starting at the end of the string "foo". If it is able to match that, then the negative look-ahead will fail, which will force the engine to progress through the string to try the next foo.Substituting before, after, or between characters Many substitutions match a chunk of text and then replace part or all of it. You can often avoid that by using look-arounds. For example, if you want to put a comma after every foo:s/(?<=foo)/,/g; # Without lookbehind: s/foo/foo,/g or s/(foo)/$1,/g or to put the hyphen in look-ahead:s/(?<=look)(?=ahead)/-/g; This kind of thing is likely to be the bulk of what you use look-arounds for. It is important to remember that look-behind expressions cannot be of variable length. That means you cannot use quantifiers (., +, or {1,5}) or alternation of different-length items inside them.Matching a pattern that doesn't include another pattern You might want to capture everything between foo and bar that doesn't include baz. The technique is to have the regex engine look-ahead at every character to ensure that it isn't the beginning of the undesired pattern:/foo # Match starting at foo (?: # Complex expression: (?!baz) # make sure we're not at the beginning of baz . # accept any character )* # any number of times bar # and ending at bar/x; Nesting You can put look-arounds inside of other look-arounds. This has been known to induce a flight response in certain readers (me, for example, the first time I saw it), but it's really not such a hard concept. A look-around sub-expression inherits a starting position from the enclosing expression, and can walk all around relative to that position without affecting the position of the enclosing expression. They all have independent (though initially inherited) bookkeeping for where they are in the string.The concept is pretty simple, but the notation becomes hairy very quickly, so commented regular expressions are recommended. Let's look at the real example of [id://319742]. The poster wants to put a space after any comma (punctuation, actually, but for simplicity, let's say comma) that is not nestled between two digits. Building up the s/// expression: s/(?<=, # after a comma, (?! # but not matching (?<=\d,) # digit-comma before, AND (?=\d) # digit afterward ) )/ /gx; # substitute a space Note that multiple lookarounds can be used to enforce multiple conditions at the same place, like an AND condition that complements the alternation (vertical bar)'s OR. In fact, you can use Boolean algebra ( NOT (a AND b) === (NOT a OR NOT b) ) to convert the expression to use OR:s/(?<=, # after a comma, but either (?: (?CapturingIt is sometimes useful to use capturing parentheses within a look-around. You might think that you wouldn't be able to do that, since you're just browsing, but [478043|you can]. But remember: the capturing parentheses must be within the look-around expression; from the enclosing expression's point of view, no actual matching was done by the zero-width look-around.

Creating COM and DCOM objects with Perl (JamesNC) Ok, you have a written a really cool perl program and you would like to use if from MSExcel or MSWord or from a WSH or VB script. Perhaps it is an interface to DBI or some other really great perl module. How do you do it? This short tutorial for Win32 users explains how and give examples of how to share perl $scalars, @arrays and %hashes using a WSC - Windows Scripting Component to local and networked users. The documentation shows much more info. This tutorial is a just a quick and dirty how to get it working along with some stuff I have learned that is NOT in the documentation like how to do hashes( mimicked ) This tutorial also assumes that you know some VBA and how to open up the VB Editor in Excel. Helpful links: < a href="http://www.microsoft.com/downloads/details.aspx?FamilyId=408024ED-FAAD-4835-8E68-773CCC951A6B&displaylang=en " >WSC Wizard Technically optional, but I would get this free tool that generates a .wsc framework for you. < a href="http://www.microsoft.com/downloads/details.aspx?familyid=C717D943-7E4B-4622-86EB-95A22B832CAA&displaylang=en" >WSH Optional on W2K/XP WSC and WSH Documentation The process is fairly simple. Create a .WSC file ( recommend using the Wizard ) Add Perl and/or Perlscript code to the .WSC file Register the .WSC COM object with windows In your VB code, use CreateObject to create a instance of the COM object Now on to the examples! Copy and paste the following code into a file named "pcom.WSC" ( Note: do not alter the classid in this file! ) After you create the above file on your system. Then you just need to Register it with windows. In windows this is simple. Right click on the file Select -> Register Whew! That was tough. **You may also notice the "Generate Type Library" and wonder what it does. If it worked, it would help open up the api to your COM object and things like autocomplete in the VB editor would work for you. It kind of works in that if you were to create the typelib and then go to Excel and create a refrence to it, things would seem to work. But at run time when the COM object gets created, it is always the wrong type (Variant/Object) vs the Object that you created. So, don't even bother. Microsoft knows about this error and acknowledges it, but doesn't disable the "feature"... bizarreOk, we have Registered our COM object. Now, we need to use it! Here's how using Excel: Open a blank Excel sheet and add the following code Sub sortList_test()Set obj = CreateObject("pcom.WSC")Dim l() As Variantl = obj.sortList("fox", "dog", "moose", "cat", "fish") For Each li In l Debug.Print li Next liEndEnd SubSub getHash_test()Set obj = CreateObject("pcom.WSC")Dim hash As Scripting.DictionarySet hash = obj.getHash("dogHash")Debug.Print "Buddy is my " & hash.Item("buddy")End SubSub getScalar_test()Set obj = CreateObject("pcom.WSC")scalar = obj.getScalar(1)Debug.Print scalarscalar = obj.getScalar("a string! from VB")Debug.Print scalarEnd Sub Make sure that you have References to "Microsoft Scriptlet Library" and "Microsoft Scripting Runtime" selected. Call the subs and that's it for the fast track intro. I will elaborate more below on DCOM and a few more selected details. What about DCOM? Why use it? Your office mate on the same network doesn't have Perl installed on his box, but he wants to use your nifty perl object. DCOM comes to the rescue! Here are the steps needed to allow a user on another computer have access to the object. (Since this is documented in the above links I am only going to give an outline, search the docs for more details.) You need to modify the pcom.WSC file and add remotableattribute (be careful of the spelling! it is NOT remoteable) to the section like so: Now, you can call the object by using the the 2 argument form of CreateObject in your VB like so...Set hash = obj.getHash("dogHash", "127.0.0.1") If you tried this, it would fail on your friends computer because you have to first register your object on his machine AND you need to give him permission to use that object from your computer. How to register your COM object on his computer Open up regedit and search for pcom.WSC Right-click on the "{e91a2a76-18bc-4ab0-8b1c-06d6d0442287}" entry (pcom.WSC's classid ) and then select Export from the popup menu. Save this registry entry as pcom.reg Now, you just can use this file to add the needed information to his registry. Copy the file to your friends computer and Merge the file with his registry. ( You can do that with a Right-click and select Merge ) You are 1/2 way there. Now, you need to give him permission to access the object on your machine. You do that with "dcomcnfg.exe". This utility has a different interface for W2K and XP, so I will let you figure this part out. Basically, after you add the remotable entry, you will need to re-register the pcom.WSC file again, then open dcomcnfg.exe and browse the the pcom object and set the permissions for that object as appropriate. See the documentation for more details on how to run the object with different credentials. You can set security on the objects and more with the utility! What about debugging? The docs again. But my take on it is obviously debug your perl separately or in a .vb script where you can see the output more easily. Well, that's it. Hope it will open the world of amazing things perl can do with great ease and power to spread sheets and and other Windows applications for you. Other options I did not talk about include some solutions from ActiveState. They have some commercially available tools that can turn your scripts into stand alone controls and services, system tray utilities, apps and more. I don't work for them, but their PDK - Perl Dev Kit is worth the money IMHO if you want more robust features of doing these types of things. Cheers, JamesNC Test adding tutorial (wl69) I am doing a reseach project about the web community. I just test adding a tutorial without logging into the community. I am so sorry about messing up the tutorial section. If anyone has authority to delete the node, please go ahead! I appreciate that! How A Function Becomes Higher Order (Limbic~Region) All: [isbn://1558607013|Higher Order Perl], by [Dominus], has become a very popular book. It was written to teach programmers how to transform programs with programs. Many of us who do not have familiarity with Functional Programming are not aware of what [http://en.wikipedia.org/wiki/Higher-order_function|Higher Order] functions are. It is a function that does at least on of the two following things:Accepts a function as input Returns a function as output This tutorial is an illustration of how a simple every day function may become higher order increasing its usefulness in the process. Along the way we will pick up other tricks that can make our code more flexible and useful. Problem: We have a file containing a list of scores and we need to determine the highest score. Using the principal of code reuse and not reinventing the wheel, we turn to our trusty [cpan://List::Util]. use List::Util 'max';my @scores = ;my $high_score = max(@scores); Unfortunately, this requires all of the scores to be held in memory at one time and our file is really big. Just this once, we decide to break the rules and roll our own. my $high_score;while ( ) { chomp; $high_score = $_ if ! defined $high_score || $_ > $high_score;} As time goes by "just this once" has happened many times and we decide to make our version reuseable. sub gen_max { my $max; $max = $_[0] if defined $_[0]; return sub { for ( @_ ) { $max = $_ if ! defined $max || $_ > $max; } return $max; };}my $max = gen_max();while ( ) { chomp; $max->($_);}my $high_score = $max->(); This is our first step into Higher Order functions as we have returned a function as the output for the sake of reusability. We have also have many advantages over the original [cpan://List::Util] max function. Does not require all values to be present at once Ability to define a starting value Ability to process one or more values at a time Unfortunately, our function breaks the second we start comparing strings instead of numbers. We could make max() and maxstr() functions like [cpan://List::Util] but we want to use the concept of Higher Order functions to increase the versatility of our single function. sub gen_reduce { my $usage = 'Usage: gen_reduce("initial" => $val, "compare" => $code_ref)'; my $val; die $usage if @_ % 2; my %opt = @_; die $usage if ! defined $opt{compare} || ref $opt{compare} ne 'CODE'; my $compare = $opt{compare}; $val = $opt{initial} if defined $opt{initial}; return sub { for ( @_ ) { $val = $_ if ! defined $val || $compare->($_, $val); } return $val; };}my $maxstr = gen_reduce(compare => sub { length($_[0]) > length($_[1]) } );while ( ) { chomp; $maxstr->($_);}my $long_str = $maxstr->(); Now our function takes a function as input and returns a function as output. In addition to the previous functionality, we have added a few more features. Named parameters - allows flexibility in ordering and presence of arguments as well as ease in extensibility User defined comparator - our max function has now become a reduce function This does not have to be the end of the journey into Higher Order functions, though it is the end of the tutorial. Whenever you encounter a situation where two programs do nearly identical things but their differences are enough to make using a single function impossible - consider Higher Order functions to bridge the gap. Remember - it is important to always document your interface and assumptions well! I open the floor to comments both on the advantages and disadvantages of Higher Order functions. As they say, there is no such thing as a free lunch and there are always cases in which it makes sense to use distinct routines for distinct problems. Cheers,[Limbic~Region|L~R]Note: [cpan://List::Util] is a great module and the limitation of requiring all the values to be present at once is usually made up for by the fact that it also provides a reduce() function, has both C and Perl implementations, and syntactic sugar. The limitations were highlighted here for illustration purposes though I recommend using it when and where it does the job you need it to.