Free list of urls software for linux

List::MoreUtils is a Perl module that can provide the stuff missing in List::Util.

SYNOPSIS

use List::MoreUtils qw(any all none notall true false firstidx first_index
lastidx last_index insert_after insert_after_string
apply after after_incl before before_incl indexes
firstval first_value lastval last_value each_array
each_arrayref pairwise natatime mesh zip uniq minmax);

List::MoreUtils provides some trivial but commonly needed functionality on lists which is not going to go into List::Util.

All of the below functions are implementable in only a couple of lines of Perl code. Using the functions from this module however should give slightly better performance as everything is implemented in C. The pure-Perl implementation of these functions only serves as a fallback in case the C portions of this module couldnt be compiled on this machine.

any BLOCK LIST

Returns a true value if any item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "At least one value undefined"
if any { !defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

all BLOCK LIST

Returns a true value if all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "All items defined"
if all { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

none BLOCK LIST

Logically the negation of any. Returns a true value if no item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "No value defined"
if none { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

notall BLOCK LIST

Logically the negation of all. Returns a true value if not all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "Not all values defined"
if notall { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

true BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

printf "%i item(s) are defined", true { defined($_) } @list;

false BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is false. Sets $_ for each item in LIST in turn:

printf "%i item(s) are not defined", false { defined($_) } @list;

firstidx BLOCK LIST

first_index BLOCK LIST

Returns the index of the first element in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

my @list = (1, 4, 3, 2, 4, 6);
printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
__END__
item with index 1 in list is 4

Returns -1 if no such item could be found.

first_index is an alias for firstidx.

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

DNS List is a BIND zone file -to- HTML script written in PHP which enables drilling down on particular hosts to view CNAME records (if any).

In order to display an easily readable list of entries hosted on my DNS servers, I wrote this PHP script to parse A and CNAME records out of my BIND zone files, and generate an expandable/collapsable table containing the information.

This script expects to find the zonefile in a zonefile subdirectory of the directory in which the script currently resides. Again this is easy to change, but it was written for my purposes and Im providing it here should it be useful to others. There is a lot of hard-coding within the script for "kw.zone" and "test.zone" - so modify this to suit your needs. The script can parse fairly simple zone files easily, but hasnt been tested with more complex zones. Your milage will vary.

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?

Notes List is a simple and easy way to take Notes.

- Change SIZE (width and height)
- tun on/off the background image
- Auto save notes

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::Part is a Perl module that allows you to partition one array into several.

SYNOPSIS

use List::Part;
($good, $bad)=part { !/substring/ } @array; #store arrayrefs into $good and $bad
(*good, *bad)=part { !/substring/ } @array; #store into @good and @bad

ABSTRACT

List::Part implements the part function, allowing one array to be "partitioned" into several based on the results of a code reference.

There are many applications in which the items of a list need to be categorized. For example, lets say you want to categorize lines in a log file:

my($success, $failure)=part { /^ERR/ } ;

Or, suppose you have a list of employees, and you need to determine their fate:

my($lay_off, $give_raise, $keep)=part {
$_->is_talented ? 0
: $_->is_executive ? 1
: 2
} @employees;

Actually, the second one is better suited to parts alternate form, parta:

my($lay_off, $give_raise, $keep)=parta
[ sub { $_->talented }, sub { $_->is_executive }, qr// ] =>
@employees;

Or maybe you just want yet another way to write the traditional Perl signoff:

perl -MList::Part -e"print map{@$_}part{$i++%5}split,JAercunrlkso ettPHr hea,"

List::Part can help you do those sorts of things.