Free list software for linux

Dir::List is a Perl module, that provides you with various information about a specified directory. For example, it can obtain the user and group of files, the sizes of sub-directories, the filetype, and accessibility. Caching functionality is available.
Enhancements:
- The unmaintained Changes has been removed.
- Some missing requirements have been added.
- This release deletes $self->{list} at the beginning of dirinfo, in order to not return old results (this is especially a problem in mod_perl where you only instantiate one Dir::List).

List::MRU is a Perl module that implements a simple fixed-size MRU-ordered list.

SYNOPSIS

use List::MRU;

# Constructor
$lm = List::MRU->new(max => 20);

# Constructor with explicit eq subroutine for obj equality tests
$lm = List::MRU->new(max => 20, eq => sub {
$_[0]->stringify eq $_[1]->stringify
});

# Constructor using explicit UUIDs
$lm - List::MRU->new(max => 5, uuid => 1);

# Add item, moving to head of list if already exists
$lm->add($item);
# Add item, moving to head of list if $uuid matches or object already exists
$lm->add($item, $uuid);

# Iterate in most-recently-added order
for $item ($lm->list) {
print "$itemn";
}
# each-style iteration
while (($item, $uuid) = $lm->each) {
print "$item, $uuidn";
}

# Item deletion
$lm->delete($item);
$lm->delete(uuid => $uuid);

# Accessors
$max = $lm->max; # max items in list
$count = $lm->count; # current items in list

Perl module implementing a simple fixed-size most-recently-used- (MRU)-ordered list of values/objects. Well, really its a most- recently-added list - items added to the list are just promoted to the front of the list if they already exist, otherwise they are added there.

Works fine with with non-scalar items, but you will need to supply an explicit eq subroutine to the constructor to handle testing for the same object (or alternatively have overloaded the eq operator for your object).

List::MRU also supports having explicit UUIDs attached to items, allowing List::MRU items to be modified, instead of a change just creating a new entry.

List::Util Perl module contains a selection of general-utility list subroutines.

SYNOPSIS

use List::Util qw(first max maxstr min minstr reduce shuffle sum);

List::Util contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful.

By default List::Util does not export any subroutines. The subroutines defined are

first BLOCK LIST

Similar to grep in that it evaluates BLOCK setting $_ to each element of LIST in turn. first returns the first element where the result from BLOCK is a true value. If BLOCK never returns true or LIST was empty then undef is returned.

$foo = first { defined($_) } @list # first defined value in @list
$foo = first { $_ > $value } @list # first value in @list which
# is greater than $value

This function could be implemented using reduce like this

$foo = reduce { defined($a) ? $a : wanted($b) ? $b : undef } undef, @list

for example wanted() could be defined() which would return the first defined value in @list

max LIST

Returns the entry in the list with the highest numerical value. If the list is empty then undef is returned.

$foo = max 1..10 # 10
$foo = max 3,9,12 # 12
$foo = max @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a > $b ? $a : $b } 1..10

maxstr LIST

Similar to max, but treats all the entries in the list as strings and returns the highest string as defined by the gt operator. If the list is empty then undef is returned.

$foo = maxstr A..Z # Z
$foo = maxstr "hello","world" # "world"
$foo = maxstr @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a gt $b ? $a : $b } A..Z

min LIST

Similar to max but returns the entry in the list with the lowest numerical value. If the list is empty then undef is returned.

$foo = min 1..10 # 1
$foo = min 3,9,12 # 3
$foo = min @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a < $b ? $a : $b } 1..10

minstr LIST

Similar to min, but treats all the entries in the list as strings and returns the lowest string as defined by the lt operator. If the list is empty then undef is returned.

$foo = minstr A..Z # A
$foo = minstr "hello","world" # "hello"
$foo = minstr @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a lt $b ? $a : $b } A..Z

reduce BLOCK LIST

Reduces LIST by calling BLOCK, in a scalar context, multiple times, setting $a and $b each time. The first call will be with $a and $b set to the first two elements of the list, subsequent calls will be done by setting $a to the result of the previous call and $b to the next element in the list.

Returns the result of the last call to BLOCK. If LIST is empty then undef is returned. If LIST only contains one element then that element is returned and BLOCK is not executed.

$foo = reduce { $a < $b ? $a : $b } 1..10 # min
$foo = reduce { $a lt $b ? $a : $b } aa..zz # minstr
$foo = reduce { $a + $b } 1 .. 10 # sum
$foo = reduce { $a . $b } @bar # concat
shuffle LIST

Returns the elements of LIST in a random order

@cards = shuffle 0..51 # 0..51 in a random order

sum LIST

Returns the sum of all the elements in LIST. If LIST is empty then undef is returned.

$foo = sum 1..10 # 55
$foo = sum 3,9,12 # 24
$foo = sum @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a + $b } 1..10

Tudu Lists is a Web application for managing todo lists. With Tudu Lists, todo lists can be easily accessed, edited, and shared on the Web.
Tudu Lists project is a simple but effective project management tool.
If you want your very own install of Tudu Lists, or if you are a programmer and want to see how Tudu Lists is developped, this website is the place to be.
If you want to install Tudu Lists :
- All you need is JDK 5.0, Tomcat 5.5 and MySQL.
If you are a developer, you will be interested to know that :
- Tudu Lists is heavily based on the Spring Framework.
- Tudu Lists is an AJAX application, using the great DWR Framework.

List::Maker is a Perl module that can generate more sophisticated lists than just $a..$b.

SYNOPSIS

use List::Maker;

@list = < 1..10 >; # (1,2,3,4,5,6,7,8,9,10)

@list = < 10..1 >; # (10,9,8,7,6,5,4,3,2,1)

@list = < 1,3,..10 > # (1,3,5,7,9)
@list = < 1..10 x 2 > # (1,3,5,7,9)

@list = < 0..10 : prime N >; # (2,3,5,7)
@list = < 1,3,..30 : /7/ > # (7,17,27)

@words = < a list of words >; # (a, list, of, words)
@words = < a list "of words" >; # (a list, of words)

The List::Maker module hijacks Perls built-in file globbing syntax (< *.pl > and glob *.pl) and retargets it at list creation.

The rationale is simple: most people rarely if ever glob a set of files, but they have to create lists in almost every program they write. So the list construction syntax should be easier than the filename expansion syntax.

List::Compare is a Perl module to compare elements of two or more lists.

SYNOPSIS

The bare essentials:

@Llist = qw(abel abel baker camera delta edward fargo golfer);
@Rlist = qw(baker camera delta delta edward fargo golfer hilton);

$lc = List::Compare->new(@Llist, @Rlist);

@intersection = $lc->get_intersection;
@union = $lc->get_union;

General Comments

List::Compare is an object-oriented implementation of very common Perl code (see "History, References and Development" below) used to determine interesting relationships between two or more lists at a time. A List::Compare object is created and automatically computes the values needed to supply List::Compare methods with appropriate results. In the current implementation List::Compare methods will return new lists containing the items found in any designated list alone (unique), any list other than a designated list (complement), the intersection and union of all lists and so forth. List::Compare also has (a) methods to return Boolean values indicating whether one list is a subset of another and whether any two lists are equivalent to each other (b) methods to pretty-print very simple charts displaying the subset and equivalence relationships among lists.

Except for List::Compares get_bag() method, multiple instances of an element in a given list count only once with respect to computing the intersection, union, etc. of the two lists. In particular, List::Compare considers two lists as equivalent if each element of the first list can be found in the second list and vice versa. Equivalence in this usage takes no note of the frequency with which elements occur in either list or their order within the lists. List::Compare asks the question: Did I see this item in this list at all? Only when you use List::Compare::get_bag() to compute a bag holding the two lists do you ask the question: How many times did this item occur in this list?

Prima::Lists is a Perl module for user-selectable item list widgets.

The module provides classes for several abstraction layers of item representation. The hierarchy of classes is as follows:

AbstractListViewer
AbstractListBox
ListViewer
ProtectedListBox
ListBox

The root class, Prima::AbstractListViewer, provides common interface, while by itself it is not directly usable. The main differences between classes are centered around the way the item list is stored. The simplest organization of a text-only item list, provided by Prima::ListBox, stores an array of text scalars in a widget.

More elaborated storage and representation types are not realized, and the programmer is urged to use the more abstract classes to derive own mechanisms. For example, for a list of items that contain text strings and icons see "Prima::DirectoryListBox" in Prima::FileDialog.

To organize an item storage, different from Prima::ListBox, it is usually enough to overload either the Stringify, MeasureItem, and DrawItem events, or their method counterparts: get_item_text, get_item_width, and draw_items.