Ethiopic Character Classes

From Regexp::Ethiopic

Why Ethiopic Character Classes?

Because they're not there! Why character classes at all? The whole point of RE languages is to make pattern matching simpler than writing your own matching algorithms. Standardized RE languages are also easier to read, write, maintain and share than the alternatives. Syntax for character classes exist to exploit in simple notation the shared properties of a group of characters.

So what properties do Ethiopic characters have that RE languages do not detect? Ethiopic letters each contain two properties that should be matched independently. Each letter is a syllable, a "CV" pattern, a means to detect either the "C" part or the "V" part is highly desirable. There are 7 basic "V" forms shared by 37 "C" bases. This gives us 7 classes each containing 37 members and the inversion of 37 "C" classes each of 7 members. The number of elements per class is indeed larger than a number existing already defined character classes.

Equivalence of Family (row) and Equivalence of Form (column)

Character Class Aliases

From Regexp::Ethiopic::Amharic

Notes on Functional Use

The overloading of Perl's regular expressions mechanism is the preferred usage for the Regexp::Ethiopic package. However, the overloading mechanism only applies to the constant part of the RE. The following would not be handled by the Regexp::Ethipic package as expected:

use Regexp::Ethiopic 'overload';

my $x = "ከ";
    :
    :
	if ( /[#$x#]/ ) {
	      :
	      :
	}

The package never gets to see the variable $x to then perform the RE expansion. The work around is to use the package as per:

use Regexp::Ethiopic 'overload';

my $x = "ከ";
    :
    :
	my $re = Regexp::Ethiopic::getRe ( "[#$x#]" );

	if ( /$re/ ) {
	      :
	      :
	}

This works as expected at the cost of one extra step. The overloading and functional modes of the Regexp::Ethiopic package may be used together without conflict.

Notes on Notation

The initial philosophy applied to syllabic character class development was to stick with existing POSIX definitions and notation ([=x=], [:x:], etc) and simply apply them in the context of a syllabary. Shoe-horning syllabic classes into POSIX norms has proven at times to be both awkward and confusing. As this package is experimental, a clean break is made at this time from previously proposed notations and class symbols are used that appear to be intuitive and easy to type.

In large part, a complication for working with Ethiopic character classes easily has been the difference between the greater number of Ethiopic classes and available (while somewhat applicable) POSIX abstractions. There are four types of character equivalence that are of interest in Ethiopic regular expressions:

• [#xe#]: a member of the "xe" family.
• [#\d#]: in the syllabic form of \d.
• [=y=]: homophonically equivalent in writing to other syllables in phoneme char "y".
• [=#ze#=]: a member of a family that is homophonically equivalent in writing to other families (family equivalence "ze").

The choice of # has been made at this time for no other reason than that symbol itself looks like the grid that the syllables are invariably presented in. The interpretation of the character between #s is made by the character's context as either a letter or numeral. This may prove to be a good neumanic device.

Notation is of course subject to change. Putting theory into practice (and code!) and experimentation is the only real way to shake out the wilburries. Once settled GUS notation will be updated accordingly and I'll get back to IPA based pattern matching with GUS (aka "folding script"). Honest, for real this time... ;-)

References

• The Grand Unified Syllabary Project
• An Introduction to Syllabaries and Syllabic Pattern Matching
• Ethiopic Character Classes (exert, 2001)
• Developing Amharic Regular Expressions in Perl (2/99)
• Thoughts on Regular Expressions for Ethiopic (9/97)