Philip Newton > Lingua-Zompist-Cuezi-0.01 > Lingua::Zompist::Cuezi

Download:
Lingua-Zompist-Cuezi-0.01.tar.gz

Dependencies

Annotate this POD

View/Report Bugs
Module Version: 0.01   Source  

NAME ^

Lingua::Zompist::Cuezi - Inflect Cuezi nouns, verbs, and adjectives

VERSION ^

This document refers to version 0.01 of Lingua::Zompist::Cuezi.

SYNOPSIS ^

  # no imports; using fully qualified function names
  use Lingua::Zompist::Cuezi;
  $i_am = Lingua::Zompist::Cuezi::demeric('ESAN')->[0];

  # import specific functions into the current namespace
  use Lingua::Zompist::Cuezi qw( demeric crifel );
  $you_know = demeric('SCRIFEC')->[1];
  $they_had = crifel('TENEC')->[5];

  # import all functions into the current namespace
  use Lingua::Zompist::Cuezi ':all';
  $i_am = demeric('ESAN')->[0];

  $table = noun('CUONOS');  # nouns
  $table = noun('SEO');     # pronouns
  $table = noun('KETTOS');  # pronouns
  $table = adj('KHALTES');  # adjectives

  # verbs -- separate functions
  $table = demeric('SCRIFEC');     # (static definite) present
  $table = scrifel('SCRIFEC');     # (static definite) past
  $table = izhcrifel('SCRIFEC');   # (static definite) past anterior
  $table = budemeric('SCRIFEC');   # (static) remote present
  $table = buscrifel('SCRIFEC');   # (static) remote past
  $table = bubefel('SCRIFEC');     # (static remote) imperative

  # dynamic definite present
  $table = dynamic('SCRIFEC', 'prilise', 'demeric');
  $table = dynamic('SCRIFEC', 'definite', 'present');
  # dynamic remote past
  $table = dynamic('SCRIFEC', 'buprilise', 'scrifel');
  $table = dynamic('SCRIFEC', 'remote', 'past');

  ($present, $past, $gerund) = part('SCRIFEC'); # participles

  # verbs -- via the %verb hash -- in English
  $table = $verb{static}{definite}{present}->('SCRIFEC');
  $table = $verb{dynamic}{remote}{past}->('SCRIFEC');

  # verbs -- via the %verb hash -- in Verdurian/Cuezi
  $table = $verb{static}{prilise}{demeric}->('SCRIFEC');
  $table = $verb{dynamic}{buprilise}{scrifel}->('SCRIFEC');

DESCRIPTION ^

Overview

Lingua::Zompist::Cuezi is a module which allows you to inflect Cuêzi words. You can conjugate verbs and decline nouns, pronouns, adjectives, and the definite article.

There is one function to inflect nouns and pronouns. There are also functions for inflect adjectives and to form comparative and superlative forms as well as adverbs from them. Finally, there are several functions to inflect verbs, depending on the aspect, mood, and tense, and a function to form the participles of a verb.

There is also a hash which you can ask to import which may make the maze of verb-inflecting functions a little easier to use.

Exports

Lingua::Zompist::Cuezi exports no functions by default, in order to avoid namespace pollution. This enables, for example, Lingua::Zompist::Cuezi and Lingua::Zompist::Verdurian to be used in the same program, since otherwise some of the function names would clash. However, all functions listed here can be imported explicitly by naming them, or they can be imported all together by using the tag ':all'.

You can also ask to import the hash %verb. This hash is not imported by default, even if you ask for ':all'; you have to ask for it by name. For example:

  use Lingua::Zompist::Cuezi qw(:all %verb);
  # or
  use Lingua::Zompist::Cadhionr '%verb';

Capitalisation and character set

This module expects all input to be in upper case and will return all output in upper case. You should use the standard Latin transcription method for Cuêzi (with "TH" for ten, "DH" for edh, and "KH" for kodh).

In the future, this module may expect and produce the charset used by the Maraille font. At that point, the module Lingua::Zompist::Convert is expected to be available, which should be able to convert between that charset and standard charsets such as iso-8859-1 and utf-8.

noun

This function allows you to inflect nouns and pronouns (including personal pronouns such as SEO and LET and relative and interrogative pronouns such as KEDIE, PSIAT, and KETTOS).

It takes one argument, the noun or pronoun to inflect, and returns an arrayref on success, or undef or the empty list on failure (for example, because it could not determine which conjugation a noun belonged to).

In general, the arrayref will have ten elements, in the following order: nominative singular, genitive singular, accusative singular, dative singular, ablative singular, nominative plural, genitive plural, accusative plural, dative plural, ablative plural. In some cases, some of those elements may be undef (especially in the plural of non-personal pronouns such as KETTOS or THIKEDIE -- but not KAE).

The function should determine the gender and declension of the noun or pronoun automatically. Nouns ending in -IS are taken to be feminine unless they are on an internal list of neuter nouns in -IS. If you find a neuter noun in -IS which is not recognised correctly, please send me email.

Note

The personal pronouns TAS, MUKH, and CAI, as well as the forms ZAHIE, ZAHAM, ZAHAN, ZAHATH are not recognised by this function; rather, they are returned as part of SEO, LET, TU, and ZE respectively. So to find out the genitive of we, look for the genitive plural of I. The pseudo-nominative corresponding to the accusative ZETH is ZE (borrowed from Verdurian).

adj

This function inflects adjectives (including AELU and ILLU). It expects one argument (the adjective to decline) and returns an arrayref on success, or undef or the empty list on failure.

The arrayref will itself contain three arrayrefs, each with ten elements. The first arrayref will contain the masculine forms, the second arrayref will contain the neuter forms, and the third arrayref will contain the feminine forms. The forms are in the same order as in the arrayref returned by the noun function. Briefly, this order is nominative - genitive - accusative - dative - ablative in singular and plural.

This function should determine the declension of an adjective automatically.

There is currently no function which returns the declension of an adjective (partly because the matter is so simple -- first declension adjectives end in -<cons>/-O/-A, second declension in -ES/-E/-IES, and third declension in -IS/-IS/-IS; however, if there is popular demand for such a function it could be quickly added.

comp

Blah blah blah.

inf

Blah blah blah.

root

Blah blah blah.

comb

Blah blah blah.

part

This function returns the three participles of a verb. It takes the verb as an argument and returns an arrayref (in scalar context) or a list (in list context) of three elements: the present (nominative) participle, the past (accusative) participle, and the gerund (participle of need; "to be <verb>ed"). On failure, it returns undef or the empty list.

Specifically, the form returned for each participle is the masculine nominative singular form of the participle (which can be considered the citation form). Since participles decline like regular adjectives, the other forms of the participles may be obtained by calling the adj function, if desired.

%verb

To ease the confusion caused by the different verbal functions (remembering to use a 'bu-' function for the remote tense, or the different interface in the dynamic aspect), it is also possible to inflect verbs by importing the hash %verb into the current namespace.

This hash contains references to subroutines which only need to be passed the name of the verb to be inflected.

To fully qualify a tense, use the aspect, mood, and tense in that order, for example:

  $table = $verb{static}{remote}{present}->('SCRIFEC');

This will place an arrayref with the forms of the static remote present of the verb "SCRIFEL" in $table. It is also possible to use the Verdurian/Cuêzi names of the moods and tenses:

  $table = $verb{static}{buprilise}{demeric}->('SCRIFEC');

For convenience, it is also possible to use an abbreviated notation. Since I suppose that the most common aspect is the static aspect, and the most common mood the definite mood, you can leave off those aspects and moods if you wish. So the following should all yield the same result:

  $table = $verb{static}{definite}{past}->('SCRIFEC');
  $table = $verb{definite}{past}->('SCRIFEC');
  $table = $verb{static}{past}->('SCRIFEC');
  $table = $verb{past}->('SCRIFEC');
  $table = $verb{static}{prilise}{scrifel}->('SCRIFEC');
  $table = $verb{prilise}{scrifel}->('SCRIFEC');
  $table = $verb{static}{scrifel}->('SCRIFEC');
  $table = $verb{scrifel}->('SCRIFEC');

As a special nod to laziness, if you use {imperative} or {befel} without specifying a mood, remote rather than the definite mood is chosen, since there is no definite imperative in Cuêzi. So $verb{befel}->('CREGEN')->[1] and $verb{static}{imperative}->('CREGEN')->[1] give you the equivalent of $verb{static}{remote}{imperative}->('CREGEN')->[1] rather than the equivalent of $verb{static}{definite}{imperative}->('CREGEN')->[1].

On the other hand, you may find this interface to be more confusing than calling the different functions directly. Take your pick and use whichever you prefer :-).

BUGS ^

This module should handle irregular words correctly. However, if there is a word that is inflected incorrectly, please send me email and notify me.

However, please make sure that you have checked against a current version of http://www.zompist.com/native.htm or PreCadh.doc, or that you asked Mark Rosenfelder himself; the grammar occasionally changes as small errors are found or words change.

SEE ALSO ^

Lingua::Zompist::Kebreni, Lingua::Zompist::Verdurian, Lingua::Zompist::Cadhinor, PreCadh.doc (available from http://www.zompist.com/embassy.htm#learning )

AUTHOR ^

Philip Newton, <pne@cpan.org>

COPYRIGHT AND LICENSE ^

Copyright (C) 2001 by Philip Newton. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

syntax highlighting: