The App::Cache module lets an application cache data locally. There are a
few times an application would need to cache data: when it is retrieving
information from the network or when it has to complete a large
calculation.
For example, the Parse::BACKPAN::Packages module downloads a file off the
net and parses it, creating a data structure. Only then can it actually
provide any useful information for the programmer.
Parse::BACKPAN::Packages uses App::Cache to cache both the file download
and data structures, providing much faster use when the data is cached.
This module stores data in the home directory of the user, in a dot
directory. For example, the Parse::BACKPAN::Packages cache is actually
stored underneath "~/.parse_backpan_packages/cache/". This is so that
permissions are not a problem - it is a per-user, per-application cache.
This module allow the user to dump variables in a Data::Dumper format.
Unlike the default behavior of Data::Dumper, the variables are named
(instead of $VAR1, $VAR2, etc.) Data::Dumper provides an extended
interface that allows the programmer to name the variables, but this
interface requires a lot of typing and is prone to tyops (sic). This
module fixes that.
Data::Dumper::Simple is actually a source filter that replaces all
instances of Dumper($some, @args) in your code with a call to
Data::Dumper->Dump(). You can use the one function provided to make
dumping variables for debugging a trivial task.
Note that this is primarily a debugging tool. Data::Dumper offers a
bit more than that, so don't expect this module to be more than it is.
The Digest::TransformPath module implements the TransformPath concept.
A TransformPath is a complex higher-order key that is designed for use
with chains of functions that sequentially transform a piece of data.
The concept starts with a sizable chunk of data, for example an image,
for which we can determine a unique identifier, and for which we can
cheaply determine if and when the source material has changed. A series
of resource-intensive transforms might be applied to this original data
to produce another piece of data. In the image example, we might auto-level,
crop, scale, rotate, colour-balance and then thumbnail the image. This
transformed data would be put into a cache. If at some future point
we wish to obtain the same image, but would preferably like to use the
cached version, we would have to take the original image, reapply the
transforms, and then compare to the result the first time around.
Further documentation is found within the module.
Time::Format provides a very easy way to format dates and times. The
formatting functions are tied to hash variables, so they can be used
inside strings as well as in ordinary expressions. The formatting
codes used are meant to be easy to remember, use, and read. They
follow a simple, consistent pattern. If I've done my job right, once
you learn the codes, you should never have to refer to the
documentation again.
A quick-reference page is included, just in case. ;-)
Time::Format can also format DateTime objects, and strings created
with Date::Manip.
Also provided is a tied-hash interface to POSIX::strftime and
Date::Manip::UnixDate.
If the I18N::Langinfo module is available, Time::Format provides
weekday and month names in a language appropriate for your locale.
A companion module, Time::Format_XS, is also available; if it is
installed, Time::Format will detect and use it, which will result in a
significant speed improvement.
This module implements a memory-efficient node type (for trees, skip lists
and similar data structures) for Perl.
You may ask "Why bother implementing an ordered structure such as a tree
when Perl has hashes built-in?" Since Perl is optimized for speed over
memory usage, hashes (and lists) use a lot of memory.
So the purpose of this package is to provide a simple low-level Node class
which can be used as a base class to implement various kinds of tree
structures. Each node has a key/value pair and a variable number of
"children" pointers.
How nodes are organized or the algorithm used to organize them is for you
to implement.
There is no Pure-perl version because this package was written to overcome
limitations of Perl.
A lightweight LLVM python binding for writing JIT compilers
The old llvmpy binding exposes a lot of LLVM APIs but the mapping
of C++-style memory management to Python is error prone. Numba and
many JIT compilers do not need a full LLVM API. Only the IR builder,
optimizer, and JIT compiler APIs are necessary.
llvmlite is a project originally tailored for Numba's needs, using
the following approach:
- A small C wrapper around the parts of the LLVM C++ API we need
that are not already exposed by the LLVM C API.
- A ctypes Python wrapper around the C API.
- A pure Python implementation of the subset of the LLVM IR builder
that we need for Numba.
PyBison is a Python binding to the Bison (yacc) and Flex (lex)
parser-generator utilities.
It allows parsers to be quickly and easily developed as Python class
declarations, and for these parsers to take advantage of the fast and
powerful C-based Bison/Flex.
Users write a subclass of a basic Parser object, containing a set of methods
and attributes specifying the grammar and lexical analysis rules, and taking
callbacks for providing parser input, and receiving parser target events.
Features
* Runs at near the speed of C-based parsers, due to direct hooks into
bison-generated C code
* Full LALR(1) grammar support
* Includes a utility to convert your legacy grammar (.y) and scanner (.l)
scripts into python modules compatible with PyBison
* Easy to understand - the walkthrough and the examples will have you
writing your own parsers in minutes
* Comfortable and intuitive callback mechanisms
* Can export parse tree to XML with a simple method call
* Can reconstitute a parse tree from XML
A "public suffix" is a domain name under which Internet users can directly
register own names.
Browsers and other web clients can use it to
- avoid privacy-leaking "supercookies"
- avoid privacy-leaking "super domain" certificates [1]
- domain highlighting parts of the domain in a user interface
- sorting domain lists by site
Libpsl...
- has built-in PSL data for fast access
- allows to load PSL data from files
- checks if a given domain is a "public suffix"
- provides immediate cookie domain verification
- finds the longest public part of a given domain
- finds the shortest private part of a given domain
- works with international domains (UTF-8 and IDNA2008 Punycode)
- is thread-safe
- handles IDNA2008 UTS#46 (libicu is used by psl2c if installed)
[1] http://lists.gnu.org/archive/html/bug-wget/2014-03/msg00093.html
Mozilla::PublicSuffix provides a single function that returns the public suffix
of a domain name by referencing a parsed copy of Mozilla's Public Suffix List.
From the official website at http://publicsuffix.org:
A "public suffix" is one under which Internet users can directly register names.
Some examples of public suffixes are .com, .co.uk and pvt.k12.wy.us. The Public
Suffix List is a list of all known public suffixes.
A copy of the official list is bundled with the distribution. As the official
list continues to be updated, the bundled copy will inevitably fall out of date.
Therefore, if the bundled copy of found to be over thirty days old, this
distribution's installer provides the option to check for a new version of the
list and download/use it if one is found.
bluemoon - Blue Moon card solitaire
This 52-card solitaire starts with the entire deck shuffled and
dealt out in four rows. The aces are then moved to the left end of
the layout, making 4 initial free spaces. You may move to a space
only the card that matches the left neighbor in suit, and is one
greater in rank. Kings are high, so no cards may be placed to their
right (they create dead spaces).
When no moves can be made, cards still out of sequence are reshuffled
and dealt face up after the ends of the partial sequences, leaving
a card space after each sequence, so that each row looks like a
partial sequence followed by a space, followed by enough cards to
make a row of 14. A moment's reflection will show that this game
cannot take more than 13 deals. A good score is 1-3 deals, 4-7 is
average, 8 or more is poor.