*work in Progress*

Unlike Perl6, objects in Perl5 are a matter of terminology, rather than an implicit construct of the language.citation needed

~ Belief in Objects is a practised meditation here at the monastery.

At this stage you have a general understanding of programmatic concepts of perl. Including, but not limited to:add links to examples of concepts

A subroutine takes a list as an argument. This translates into flattened interpolation of array variables. The remedy to which is to pass array variables in by reference.

# example of pass by reference

Another way to do this instead of passing the ref as an argument, is to call the subroutine on the ref. As code tricks go, this can get fairly dangerous fairly quickly. So as an intention any ref you would like to be able to have this ability will need to be anointed.

To anoint a variable reference it is blessed.anoint vs bless meanings look up required

# bless $var;

Now we have another way to call the subroutine. We start by dereferencing the reference, but instead of making an element access, we replace the index identifier with the subroutine to be called.

$arrvar->[0]; # deref array element access $arrvar->{'anoint'}; # deref hash element access $arrvar->subroutine; # deref subroutine call

TODO: separate out the element access and subroutine call, and explain why

not actually dereferencing, just uses the same symbol in a similar way, to act in a different way. A Symbolic Synonymcitation needed of sorts

$arrvar->subroutine; # deref subroutine call

theres a couple of notes to make here. the dereference is not accessing an element, and considering you are calling a subroutine on an array, you might expect that the array is magically passed into the argument list. well. it is not. hmmph

However, what is passed in, as the first argument, is the reference. Instant Data! Yippee! All you need do now is treat the ref as you would any normal ref argument.

The responsibility now lays in the subroutine. The subroutine will need to be house-trained. If you start feeding it all sorts of garbage, your carpets will look all sorts of messy. That is, the subroutine should be expecting the data it is receiving - of which it is the recipient.

sub iexpectanarraycontainingdataaboutaccuracy{ my $arrayref = shift; ## todo: not ideal example ## also align 0/9 with degugging levels print {STDOUT} $arrayref->[0]," is quite accurate\n" print {STDOUT} $arrayref->[9]," is deeply inaccurate\n" return 1; }

wheres the second note?

should you pass an hash reference by error, firstly, you did not bless an hash reference yet so that is unlikely, secondly, messy carpets.

This is a good time to think about writing a separate script to run tests against your script. Necessary ?

ah here it is!

Is that inheritance tax seems decidedly simple

Another consequence of invoking a subroutine on a blessed reference, is that the reference can only call subroutines that exist within the same package. At least in this case, as only the reference has been blessed in the one-argument form of bless. Suffice to say, this prevents the problem of that newly blessed reference being able to call random subroutines from other loaded packages.

But to stress again, it may call any routines in the same namespace, so you should also be aware to write the other subroutines to fail correctly should they be called erroneously

#!perl use 5.10.1; use strict; use warnings; use Carp; my @array_var = qw/Double, double toil and trouble;/; say join "\n","\nfirst:", @array_var; add_an_item( \ @array_var, $_ ) foreach qw/1234 abyzABYZ 4the5scottish6play 1when 2shall 3we 4three +!/; say join "\n","\nsecond: ",@array_var; my $array_ref = \ @array_var; bless $array_ref; $array_ref->add_an_item( $_ ) foreach qw/1234 Fire burn, and cauldron bubble./; say join "\n","\nthird: ", @array_var, "\nfourth: ", @$array_ref; sub add_an_item{ say "\nsub args: ", join ' ', @_; my $avref = shift; my $item_to_add = shift; # <STDIN> # use input module or this $item_to_add =~ tr/a-zA-Z//cd; $item_to_add || carp( "Skipping item.\nItems added to this array shou +ld contain letters." ) && return; $avref->[ @$avref ] = $item_to_add; } exit (0);

a note on inheritance

so in theory...

unless(eval{ $arrayref->can(maxstr) }){ carp $@ }else{ $arrayref->maxstr() } # carps


#!perl use 5.10.1; use strict; use warnings; use Carp; use parent qw'List::Util'; ... unless( $arrayref->can('maxstr') ){ carp $@ }else{ $arrayref->maxstr() } exit; #(?) :D

Hello wa5nti and welcome to the monastery.

Where to start? There could be many reasons for this occurence, so I can only make suggestions.

I was struck by the fact that your installation was attempting to install the perldoc program. In my experience Strawberry auto installs this. I find the documentation an inextricable part of the language and its distributions.

Non-installation of perldoc in Strawberry occurs when a certain config variable is defined at install time.

=item C<versiononly>

From F<versiononly.U>:

If set, this symbol indicates that only the version-specific
components of a perl installation should be installed.
This may be useful for making a test installation of a new
version without disturbing the existing installation.
Setting versiononly is equivalent to setting installperl's -v option.

In particular, the non-versioned scripts and programs such as
a2p, c2ph, h2xs, pod2*, and perldoc are not installed
(see C<INSTALL> for a more complete list). Nor are the man
pages installed.
Usually, this is undef.

Heres a one liner to see if this variable was defined at installation.

windos% perl -Mv5.20 -Mstrict -MConfig -w -e "say $Config{versiononly} +"

Should you find this variable is defined in some way, the simplest method would most likely be to re-install taking care not to install a version dependant version.

Other than that there are a huge number of variables, that do not show up in the perl -V invocation. Given the difficulty of being able to run perldoc, you may find a look at some of the path variables in the list lead you somewhere useful.

#!perl use 5.20; use strict; use warnings; use Config qw/config_sh/; open my $fh, '>', '.\configlist.txt' or die $!; print {$fh} config_sh(); close $fh;

This will provide a list something along the form of what can be seen here Example Config Variable Listing (note: Example is defined as relating to use in this forum reply, not the code itself).

Maybe check libpath variables in this list, and also permissions on the directories the paths indicate. For TMP paths, I usually see a shortname as upper case suffixed with tilde V:\STRAWB~\lib\path\

Pod is included with modules, you can check the scripts directly, and Pod is accessible through online sources CPAN Perl5

Perl is Perl, if none of this helps, maybe consider re-installing Active-State, as it was working for you previously, until you are more familiar with the language.

I hope this helps. Local access to all the really useful beginners documentation is essential for a good learning experience.

Why are you re-inventing the wheel? So I can test it goes round!

post 3 How do I write a program that calculates the sum of all numbers to a number, n? silly response given

This response is not intended to be taken literally. :p

The sum of ALL numbers being 1/12, would the sum of all numbers up to N not be some type of a function? In the manner of

sum( N,N-1,N-2..N=1 ) = N / ( 1/12 )

Oh yes, I see now n(n+1)/2, overthinking it again.

Although that might be N * 1/12 (but is probably neither). For another undefined definition, maybe just bitmasking the sum of all numbers to length N. This could work well if soan is truly irrational.

sub donotrun_this_is_an_example{ use constant Soan = (1/12); my $bitmask = ~ -256**($n/8); return Soan & $bitmask; }

similar idea would be to return the of multiplying Soan by 10 to power of N: int( Soan*10**$n )

Alert! vague conjecture recollection syndrome and Random thought process combination.

post 2

To replace the occurence string in perl

Off the top of my head (untested), I would suggest starting with a one liner such as:

perl -pi.bak -e " use features qw/state/; state $nameshash = { 'Poole' => 1 }; s/(<.*?CIT-)(\w+)(-\w\d+.*?>)/"$1$2".$nameshash->{$2}++."$3"/ge; " bibliofile

post 1

CRC-16 algorithm


print "CRC16 in hex:\n  ", unpack('H*', pack('S', $crc16)), "\n";

citation needed check pack pod.
This could be a problem caused by the use of unpack() on pack() - recalling some usage where internal representation does not necessarily behave to standards of other specifications.

post 0

my %combinations = ( co1 => [ [ qw(one two three four five) ], [ qw(one one two three five) ] ], co2 => [ [ qw(one two three five seven) ], [ qw(one one two three five) ] ], co3 => [ [ qw(one two three five seven) ], [ qw(one two three four five) ] ], co4 => [ [ qw(one two three five seven) ], [ qw(one two three four five) ], [ qw(one one two three five) ] ], ); reorg($_,\%combinations) foreach(keys %combinations); sub reorg{ my($k,$h) = @_; foreach my $combiset(@{$h->{$k}}){ my @uniquesets = grep $_ =~ /\Aus/ keys %combinations; my $num = scalar(@us); foreach my $set ( @$combiset ){ $combinations{'us'.++$num } = $set unless grep @$set {<~~>} @$_, @combinations{@us}; # where {<~~>} is 'these arrays match' # or the front N indices do or ... } }

To end up with something like:

%combinations = ( co1 => [ [ qw(one two three four five) ], [ qw(one one two three five) ] ], co2 => [ [ qw(one two three five seven) ], [ qw(one one two three five) ] ], co3 => [ [ qw(one two three five seven) ], [ qw(one two three four five) ] ], co4 => [ [ qw(one two three five seven) ], [ qw(one two three four five) ], [ qw(one one two three five) ] ], us1 => [ qw(one two three four five) ], us2 => [ qw(one two three five seven) ], us3 => [ qw(one one two three five) ], );

While writing this example, I felt as though most of writing code is iterator definition. Within this example, I require several uses of iterator to define growing numbers of keys, these themselves need to be used to clarify the keys the initial map operation continues to apply the reorganising routine on the hash to. While also not then applying the new keys which have been added.

A kind of There's More Than One Way To Do What I Mean? I mean the iterator to know the keys I started with, and only iterate through them as the hash grows. I mean another iterator to build a set of unique values keyed in the original hash, and built out of the original keys values. I mean the newly built unique values to be used straight away in validation checks on the remaining keys.

If as here, I approach designing the code without considering what the internal behaviour of the iterator is, other than the existing definition that it should not be relied upon. The internal iteration behaviour may change between versions, and the code is easily maintained throughout minor transitions.

What I need from the iterator is that, a defined behaviour. If it is not of any impact as to the precise implementation, as the code is not well designed if it relies on that, then would it not be reasonable to approach implementation as a matter of cost and efficiency. What is the fastest, most cost effective implementation? Can that implementation be reasonably identified as being compatible for the next 15+ years. Can I access it and incant wizardry in the way I might with symbol tables. Such as by having a user defined operator.

Perhaps something more robust, like a Global Iterator Variable / Symbol, along the lines of ${*} or *INC,*ARGV, the match array $-[0..-1]. I don't want to be setting variables and flags in most cases. I want to have a simple concept of, don't rely on this behaviour, but this is how you can manipulate it if you want to. And consider maintainer is a must, will the code self-document?