Free conways software for linux

Class::DispatchToAll Perl module can dispatch a method call to all inherited methods.

SYNOPSIS

package My::Class;
our @ISA=qw(SomeClass SomeOtherClass More::Classes);
use Class::DispatchToAll qw(dispatch_to_all);

my $self=bless {},My::Class # not a proper constructor, I know..

# this calls some_method in all Classes My::Class inherits from
# and all classes those classes inherit from, and all ... you get
# the point.
$self->dispatch_to_all(some_method);

# saves all return values from all calls in an array
my @returns=$self->dispatch_to_all(some_method);

See the Docs of Damian Conways Module Class::Delegation for a good introduction about Dispatching vs. Inheritance.

Class::DispatchToAll enables you to call all instantances of a method in your inheritance tree (or labyrinth..).

The standard Perl behaviour is to call only the lefternmost instance it can fing doing a depth first traversial.

Imagine the following class structure:
C
/
A B C::C
/ /
A::A D
/
My::Class

Perl will try to find a method in this mess in this order:

My::Class -> A::A -> A -> B -> D -> B -> C::C -> C
(Note that it will look twice in B because B is a parent of both A::A and D))

As soon as Perl finds the method somewhere, it will short-circuit out of its search and invoke the method.

And that is exactly the behaviour Class::DispatchToAll changes.

If you use dispatch_to_all (provided by Class::DispatchToAll) to call your method, Perl will look in all of the aforementioned packages and run all the methods it can find. It will even collect all the return values and return them to you as an array, if you want it too.

Class::Declare::Attributes is a Perl module with Class::Declare method types using Perl attributes.

SYNOPSIS

package My::Class;

use 5.006;
use strict;
use warnings;

use base qw( Class::Declare::Attributes );

# declare the class/instance attributes
__PACKAGE__->declare( ... );

#
# declare class/static/restricted/etc methods of this package
#

sub my_abstract : abstract { ... }
sub my_class : class { ... }
sub my_static : static { ... }
sub my_restricted : restricted { ... }
sub my_public : public { ... }
sub my_private : private { ... }
sub my_protected : protected { ... }

Class::Declare::Attributes extends Class::Declare by adding support for Perl attributes for specifying class method types. This extension was inspired by Damian Conways Attribute::Handlers module, and Tatsuhiko Miyagawas Attribute::Protected module. The original implementation used Attribute::Handlers, but now simply refers to attributes.

The addition of Perl attribute support (not to be confused with object attributes, which are entirely different, and also supported by Class::Declare) greatly simplifies the specification of Class::Declare-derived class and instance methods. This should aid in the porting of existing code (Perl, Java and C++) to a Class::Declare framework, as well as simplify the development of new modules.

With the addition of Perl attributes, Class::Declare methods can now be written as

sub method : public
{
my $self = shift;
...
}
instead of
sub method
{
my $self = __PACKAGE__->public( shift );
...
}

wmlife is a program launcher dockapp.

Wmlife is a dock app running Conways Game of Life (and program launcher). Life is played on a grid of square cells where a cell can be either live or dead. In the rules, you count the number of live neighbours for each cell to determine whether a cell lives or dies;

Birth A dead cell with exactly three live neighbours becomes a live cell.

Survival A live cell with two or three live neighbours stays alive.
Overcrowding / Loneliness In all other cases, a cell dies or remains dead.
Normally Life is implemented on an infinite board but due to size restraints wmlife implements the grid as a torus. In a torus, the grid wraps at the edges from top to bottom and left to right.

NOTE: It isnt really a game and bears no resemblance to the popular board game of the same name.

Life plays out on a grid of squares where each cell is born, lives and dies according to the number of neighbors it has. A cells "neighbors" are the eight squares immediately adjacent to it. If a dead cell is surrounded by exactly three living neighbors, it is "born" and is considered "living" at the start of the next turn. If a living cell has two or three living neighbors, it remains "alive" at the start of the next turn. If a living cell has any other number of living neighbors, it "dies" and is considered "dead" at the start of the next turn.

Some implementations extend this idea by giving the cells ages, so they will not die immediately if abandoned or overcrowded. This implementation does not do this -- cells are bits; alive or dead. Living cells are gray, dead cells are white.

In this implementation, clicking a cell at any time will reverse its state (living cells become dead and vice-versa). The action can be started by clicking "Start" and will run until the number of remaining iterations reaches 0. An "iteration" calculates a number of rounds and updates the display to show the results. The most interactive way to run the simulation is to perform one round per iteration (the default) so the screen will update constantly. Because updating the screen is slow, more rounds can be performed between updates by increasing the number of rounds per iteration.

There are several counters shown on the screen to display some performance data if youre interested in how fast your browser runs Javascript.

Note that if your screen does not update after every iteration, try setting the delay to a number greater than 0. The grid size can be increased by editing the top of the source file.

HTML::Tree::Scanning contains an article: "Scanning HTML".

SYNOPSIS

# This an article, not a module.

The following article by Sean M. Burke first appeared in The Perl Journal #19 and is copyright 2000 The Perl Journal. It appears courtesy of Jon Orwant and The Perl Journal. This document may be distributed under the same terms as Perl itself.

Scanning HTML

-- Sean M. Burke

In The Perl Journal issue 17, Ken MacFarlanes article "Parsing HTML with HTML::Parser" describes how the HTML::Parser module scans HTML source as a stream of start-tags, end-tags, text, comments, etc. In TPJ #18, my "Trees" article kicked around the idea of tree-shaped data structures. Now Ill try to tie it together, in a discussion of HTML trees.

The CPAN module HTML::TreeBuilder takes the tags that HTML::Parser picks out, and builds a parse tree -- a tree-shaped network of objects...

Footnote: And if you need a quick explanation of objects, see my TPJ17 article "A Users View of Object-Oriented Modules"; or go whole hog and get Damian Conways excellent book Object-Oriented Perl, from Manning Publications.

...representing the structured content of the HTML document. And once the document is parsed as a tree, youll find the common tasks of extracting data from that HTML document/tree to be quite straightforward.

Template::Plugin::Lingua::EN::Inflect is a Perl interface to Lingua::EN::Inflect module.

SYNOPSIS

[% USE infl = Lingua.EN.Inflect; -%]
[% FILTER inflect(number => 42); -%]
There PL_V(was) NO(error).
PL_ADJ(This) PL_N(error) PL_V(was) fatal.
[% END; -%]

[% "... and "; infl.ORD(9); "ly..." %]

# Output:
# There were 42 errors.
# These errors were fatal.
# ... and 9thly...

The Lingua::EN::Inflect is an interface to Damian Conways Linua::EN::Inflect Perl module, which provides plural inflections, "a"/"an" selection for English words, and manipulation of numbers as words.

The plugin provides an inflect filter, which can be used to interpolate inflections in a string. The NUM() function set a persistent default value to be used whenever an optional number argument is omitted. The number to be used for a particular invocation of inflect can also be specified with a number option.