KlingonPerlProgramming
NAME
Lingua::thInganHol::yIghun - "The Klingon Language: hey you, program in it!"
SYNOPSIS
use Lingua::thInganHol::yIghun;
<<'u' nuqneH!\n>> tIghItlh!
{
wa' yIQong!
Dotlh 'oH yIHoH yInob
qoj <mIw Sambe'> 'oH yIHegh jay'!
<Qapla'!\n> yIghItlh!
} jaghmey tIqel!DESCRIPTION
The Lingua::tlhInganHol::yIghun module allows you to write Perl in the original Klingon.
Introduction
The Klingon language was first explained to Terrans in 1984 by Earth-born linguist Dr Marc Okrand. Those who dare can learn more about it at the Klingon Language Institute (http://www.kli.org/).
The word order in Klingon sentences is I-O-V-S: indirect object, (direct) object, verb, subject. For example:
luSpetna'vaD vay' vIghItlh jIH to-STDERR something write I
Naturally, commands given in the imperative form are far more common in Klingon. In imperative statements, such as those used for programming instructions, word order becomes I-O-V: indirect object, (direct) object, (imperative) verb:
luSpetna'vaD vay' yIghItlh! to-STDERR something (I order you to) write!
Thus, for programming, Klingon is inherently a Reverse Polish notation.
Variables
Klingon uses inflection to denote number. So the command:
luSpetna'vaD vay' yIghItlh!
is:
to-STDERR something write!
whereas:
to STDERR some things write!
is:
luSpetna'vaD vay'mey yIghItlh!
So in Klingon scalars and arrays can have the same root name (just as in regular Perl):
vay' ---> $something vay'mey ---> @something
The -mey suffix only refers to things incapable of speech. If the somethings had been articulate, the inflection would be:
luSpetna'vaD vay'pu' yIghItlh!
From a certain point-of-view, this parallels the difference between an array and a hash: arrays are subscripted mutely, with dumb integers; whereas hashes are subscripted eloquently, with quoted strings. Since hashes are thus in some sense "articulate", they are inflected with the -pu' suffix:
vay' ---> $something vay'mey ---> @something vay'pu' ---> %something
Standard variables
Some variables have special names. Specifically:
Name Variable Translation 'oH $_ it biH @_ them chevwI' $/ that which separates natlhwI $! that which drains
Subscripting arrays and hashes
Numerical subscripts are just ordinals. The command:
"kill $starships[5][3];"
means:
from starships, from the 5th of them, the 3rd of them, kill it!
which, in the Warrior's Tongue, is:
'ejDo'meyvo' vagh DIchvo' wej Dich yIHoH!
The [DIch] tag marks an ordinal number, whilst the ablative -vo' suffix marks something being subscripted (i.e. something that an element is taken from).
Note that the -mey suffix on the original 'ejDo'mey (@starships) array didn't change. This implies that the literal back-translation is:
"kill @starships[5][3];"
Thus Klingon shows its superiority, in that it already honours the new Perl 6 sigil conventions.
Hash indices have a different tag (Suq). So:
"kill $enemies{"ancient"}{'human'};"
which means:
from enemies, from the "ancient" ones, the 'human' one, kill him!
is coded as:
jaghpu'vo' <<ancient>> Suqvo' <human> Suq yIHoH!
Once again the -pu'"I'm-a-hash" suffix is retained when subscripting, so the literal back-translation is the Perl6ish:
"kill %enemies{"ancient"}{'human'};"Element access through references
With references, the [DIch] or Suq tag still indicates what kind of thing is being subscripted. So there is no need for an explicit dereferencer. So:
jepaHDIlIwI'vo' <<stupid>> Suqvo' wa' DIch yIHoH!
can be translated:
"kill $jeopardyPoster{"stupid"}[1]; # Perl 6 syntax"
but also means:
"kill $jeopardyPoster->{"stupid"}[1]; # Perl 5 syntax"Distinguishing lvalues
All the variables shown above were written in the (uninflected) accusative case. This is because they were used as direct objects (i.e. as data).
When variables are assigned to, they become indirect objects of the assignment (give the weapon to me). This means that targets of assignment (or any other form of modification) must be specified in the dative case, using the -vaD suffix:
'ejDo'meyvaD wa' 'uy' chen tInob!
"@starships = (1..1000000);"
jaghpu'vaD (<<QIp>> wa' <<jIv>> cha') tInob!
"%enemies = (stupidity=>1, ignorance=>2);"
jepaHDIlIwI'vo' wa' Dichvo' <<stupid>> SuqvaD ghur!
"++$jeopardyPoster->[1]{"stupid"};"Variable declarations
Variable declarations also use suffixes for lexicals:
scalarwIj! ---> my $scalar; arraymeywIj! ---> my @array; hashpu'wI'! ---> my %hash;
for package variables:
scalarmaj! ---> our $scalar; arraymeymaj! ---> our @array; hashpu'ma'! ---> our %hash;
and for temporaries:
scalarvam! ---> local $scalar; arraymeyvam! ---> local @array; hashpu'vam! ---> local %hash;
Operators and other punctuation
In general, programming Perl in the original Klingon requires far less punctuation than in the Terran corruption.
The only punctuation components of the language are:
< and >
These are pach poS (left claw) and pach niH (right claw). They delimit an uninterpolated character string. For example:
<petaQ> yiHegh! ---> "die 'scum';"
<< and >>
These are pachmey poS (left claws) and pachmey niH (right claws). They delimit an interpolated character string. For example:
<<petaQ\n>> yiHegh! ---> "die "scum\n";"
( and )
These are 'etlh [HivtaH] and 'etlh [HubtaH] (attaching sword and defending sword). They are used as grouping expressions. For example:
xvaD wa' (cha maH yIfunc) yIlogh yInob! ---> "$x = 1*func(2,10)"
For standard operators and functions with fixed parameter lists, this kind of grouping is not needed due to the RPN ordering of Klingon:
xvaD wa' cha maH yIchel yIlogh yInob! ---> "$x = 1*(2+10)"
{ and }
These are betleH [HivtaH] and betleH [HubtaH] (attacking batleth and defending batleth). They are used to group complete statements. For example:
x joq { 'oH yIghItlh! 'oHvaD yIghur! } yIvang! ---> $x && do{ print $_; $_++ }#
This is the tajmey gho (circle of daggers), which is used to indicate the beginning of a comment (which then runs to the end of the line). Its use is widely reviled as a sign of weakness.
Operators
The Klingon binding of Perl does not use sniveling Terran symbols for important operations. It uses proper words. For example:
= yInob "give!" + tIchel "add!" - tIchelHa' "un-add!" ++... yIghur "increase!" ...++ yIghurQav "increase afterwards!" .. tIchen "form up!" eq rap'a' "the same?!" == mI'rap'a' "the same number?!"
For a complete list, see Appendix 2.
Note that they all appear at the end of their argument lists:
Qapla' vum toDuj yIchel buDghach yichelHa' yInob!
|_| |___| |____|
|______________| |______| |_______|
|____| |_________________________________| |____|
Most of the above examples begin with yI- or tI-. These prefixes indicate an imperative verb referring to one or many objects (respectively).
Hence, assignment is yInob (give it to...), whilst addition is tIchel (add them).
Of course, in the heat of coding there is often not time for these syntactic niceties, so Lingua::tlhIngan::yIghun allows you do just drop them (i.e. use "clipped Klingon") if you wish.
Numeric literals
Klingon uses a decimal numbering system. The digits are:
0 pagh 1 wa' 2 cha' 3 wej 4 loS 5 vagh 6 jav 7 Soch 8 chorgh 9 Hut
Powers of 10 are:
10 maH 100 vatlh 1000 SaD or SanID 10000 netlh 100000 bIp 1000000 'uy'
Numbers are formed by concatenating the appropriate digit and power of ten in a descending sequence. For example:
yearvaD wa'[SaD] Hutvatlh chorghmaH loS yInob! ---> "$year = 1984;"
Decimals are created by specifying the decimal mark ([DoD]) then enumerating post-decimal digits individually. For example:
pivaD wej DoD wa' loS wa' vagh yInob! ---> "$pi = 3.1415;"
References
References are created by prepending the query nuqDaq (where is...) to a referent. For example:
refvaD nuqDaq var yInob! ---> "$ref = \$var;"
To dereference, the appropriate -vetlh, -meyvetlh, or -pu'vetlh suffix (that..., those..., those ...) is used, depending on the type of the referent. For example:
refvetlh yIghItlh! ---> "print ${$ref};"
refmeyvetlh tIghItlh! ---> "print @{$ref};"
refpu'vetlh tIghItlh! ---> "print %{$ref};"Conjunctives and disjunctives
Just as Terran Perl's conjunctive and disjunctive operators come in two precedences, so too do those of The Warrior's Perl.
When joining expressions, the high precedence operators (joq and je) are used:
x yImI'Suq joq yIghItlh! ---> "print($x || get_num();)" zvaD x yIy je yInob! ---> "$z = ($x && y());"
Unlike all other operators in Klingon, low-precedence conjunctives and disjunctives (i.e. those between complete commands) are infix, not postfix. The low precedence operators are qoj and 'ej:
x yIghItlh qoj yImI'Suq! ---> "print($x) or get_num();" zvaD x yInob 'ej yIy! ---> "($z = $x) or y();"
Note that (as the above exampe illustrate) changing precedence often necessitates a radical change in word order.
Object-oriented features
Klingon Perl does not pander to feeble Terran object-oriented sensibilities by treating objects and methods specially.
A method is a subroutine, so in Klingon Perl it is called exactly like a subroutine.
The first argument of a method is special, so in Klingon Perl it is explicitly marked it as being special.
For example, the procedural command:
Hich DoSmey yIbaH!
translates as:
"fire($weapon,@targets);"
To call the same subroutine as a method, with $weapons as its invocant object, it is necessary to mark the referent using the topicalizer 'e':
Hich'e' DoSmey yIbaH!
This then translates as:
"$weapon->fire(@targets);"
Likewise class methods are invoked by topicalizing the class name:
<<Jagh>>'e' yItogh yIghItlh>
which is:
"print "Enemy"->count();"
To create an object, the [DoQ] (claim ownership of) command is used:
{
buvwIj bIH yInIH! # my $class = shift @_;
De'pu'wI' bIH yInob! # %data = @_;
nuqDaq De' buv yIDoQ yItatlh! # return bless \%data, $class;
} chu' nab! # sub newComparisons
The equality comparison operators ("==", "!=", "eq", "ne") are implemented as questions in Klingon:
x y rap'a' ---> "$x eq $y" ("x y are they the same?")
x y mI'rap'a' ---> "$x == $y" ("x y are they the same number?")
x y pIm'a' ---> "$x ne $y" ("x y are they different?")
x y mI'pIm'a' ---> "$x != $y" ("x y are they different numbers?")
Inequalities are expressed with a different grammatical structure in Klingon. There is only one inequality operator, whose syntax is:
expr1 comparator law' expr2 comparator puS
Literally this means:
comparator(expr1) is many; comparator(expr2) is few
or, in other words:
comparator(expr1) > comparator(expr2)
The comparators tlhInganHol::yIghun supports are:
">" : tIn "<" : mach ">=" : machbe' "<" : tInbe' "gt" : tlha' "lt" : nung "ge" : nungbe' "le" : tlha'be'
For example:
{ <<qapla>> yIghItlh } mebmey mach law' maH mach puS je Soj nungbe'
law' <qagh> nungbe' puS teHchugh!
"print "qapla!" if @guests < 10 && $food ge 'qagh';"Flow control
The flow control directives are:
teHchugh "if" if is true teHchughbe' "unless" if is not true teHtaHvIS "while" while being true teHtaHvISbe' "until" while not being true tIqel "for(each)" consider them yIjaH "goto" go! yInargh "last" escape! yItaH "next" go on yInIDqa' "redo" try again
Builtin functions
Perl builtins are represented as imperative verbs in tlhInganHol::yIghun. Appendix 1 has the complete list.
As with operators, they may take yI- or tI- prefixes and are themselves postfix (the verb after it's arguments).
Note that there are a suitably large number of variations on the "kill" command.
User-defined subroutines
A user-defined subroutine is specified in a betleH delimited block, and given a name using the nab (procedure) specifier. For example:
{
<<Qapla'!\n>> ghItlh!
} doit nab!
means:
sub doit {
print "Qapla'!\n";
}
Such subroutines are then called using the (non-optional) yI- or tI- prefix:
yIdoit!
Anonymous subroutines are created by omitting the name:
refwIj {
<<Qapla'!\n>> ghItlh!
} nab nob!
which is:
my $ref = sub {
print "Qapla'!\n";
}
Subroutine references can also be created by suffixing a subroutine name with -la HwI' (one who can...):
refwIj doitlaHwI' nob!
Either way, the subroutine is called through a reference by appending the -vetlh suffix (that...") and prepending the imperative yI- or tI-:
yIrefvetlh!
Pattern matching
Patterns (or nejwI') are specified using the same line-noise syntax as in Terran Perl.
To match against a pattern, the ghov verb (recognize) is used:
'oH <\d+> yIghov 'ej <<vItu'>> yIghItlh!
which means:
$_ =~ m/\d+/ and print "found it";
Note that the value being matched against must be explicitly specified, even if it is 'oH.
To substitute against a pattern, use tam (substitute):
De'vaD <\d+> <\n> yItam!
which means:
$data =~ s/\d+/\n/;
The container whose value is being substituted must be explicitly specified (again, even if it is 'oH). It is also the target of the action and thus takes the -vaD suffix.
Invective operator
Klingon is a language of great emotional depth. By comparison, programming in Terran languages is an insipid, bloodless experience.
Of particular note is the special programming construct: jay'. In Klingon it may be appended to a sentence to enhance it's emotional intensity. Thus:
qaSpu' nuq 'e' yIja'! Tell me what happened!
becomes:
qaSpu' nuq 'e' yIja' jay'! Tell me what the *#@& happened!
This useful and satisfying internal documentation technique can be used anywhere in a tlhInganHol::yIghun program. For example:
{ <<De' sambe'>> yIghItlh jay'! } tu' yItlhoch teHchugh!
"if (!$found) { *#@&-ing print "Missing data!" }"Module control options
If the module is imported with the argument y[IQij]:
use Lingua::tlhInganHol::yIghun "yIQij";
it runs in debugging mode.
If the module is imported with the argument yImugh:
use Lingua::tlhInganHol::yIghun "yImugh";
it demeans itself to merely translating your glorious Klingon Perl code into a pale Terran Perl imitation.
If the module is imported with the argument tera'nganHol (or tera::nganHol:
use Lingua::tlhInganHol::yIghun "tera'nganHol";
it debases itself to output numeric values in Terran, rather than in the original Klingon.
DIAGNOSTICS
- "[= <
- <Suq>> yIlo'Qo' <<[DIch]>> yIlo' jay' ]" ; Array indices take the ordinal suffix [DIch]! You fool!
- "[= <
- <[DIch]>> yIlo'Qo' <<Suq>> yIlo' jay' ]" ; Hash keys are indicated by Suq, not an ordinal! You imbecile!
- "%s: pong Sambe'!"
- You forgot the name of a subroutine, package, or module! You cretin!
- "%s: pong ngoqghom joq Sambe'!"
- You forgot to specify the name of a subroutine or a raw block! You moron!
- "%s: ngoqghom Sambe'!"
- You forgot to specify a raw block! You idiot!
- "%s: nejwI' Sambe'!"
- You forgot to specify a pattern! You dolt!
- "%s: tamwI' Sambe'!"
- You forgot to specify a value to be substituted! You simpleton!
- "%s: De' Sambe'!"
- You forgot to specify an argument! You half-wit!
- "%s: De' wa'[DIch] Sambe'!"
- You forgot to specify the first argument! You clod!
- "%s: De' cha'[DIch] Sambe'!"
- You forgot to specify the second argument! You knucklehead!
- "%s: [DoS] ghap Hal Sambe'!"
- You forgot to specify a filehandle! You oaf!
- "%s: Hal Sambe'!"
- You forgot to specify an input filehandle! You jerk!
- "%s: wuqwI' Sambe'!"
- You forgot to specify a boolean expression for a ternary operator! You dumbbell!
- "%s: v[ItvaD] Sambe'!"
- You forgot to specify an "if true" value for a ternary operator! You buffoon!
- "%s: nepvaD Sambe'!"
- You forgot to specify an "if false" value for a ternary operator! You dope!
- "%s: tob Sambe'!"
- You forgot to specify a test for a control statement! You dummy!
- "%s: Doch Sambe'!"
- You forgot to specify an object! You dunce!
- "%s %sDaq: ra' [PoS] p[IHbe]!"
- What is that command doing on the left of that conjunction?! You dimwit!
- "%s %sDaq: 'rIn p[IHbe]!"
- Where is the rest of the command?! You nincompoop!
- "betleH [HivtaH] Sampa' veQ: %s"
- What is that garbage before the opening brace?! You dunderhead!
- 'etlh [HivtaH] Sambe'
- Where is the opening parenthesis? You numbskull!
- "%s puS: [DIp] %sbe' Sambe'"
- Where is the variable you're comparing?! You goose!
- "[= %s puS: <
- <%s law>> nung Sambe' ]" ; Where is the comparator law' for this comparison? You blockhead!
- "%s: [DIp] poS Sambe'"
- Where is the left operand?! You chump!
- "%sDaq ngoq Sovlahbe'"
- This code is meaningless! You nimrod!
- "ngoq tlhol: %s"
- What is this extra code doing here?! You human!
ACKNOWLEDGEMENTS
AUTHOR
Damian Conway (damian@conway.org)
BUGS
In this module??? I should kill you where you stand!
Send your challenge to me. If you dare!
SEE ALSO
The Klingon Language Institute <http://www.kli.org/>;
The Varaq programming language <http://www.geocities.com/connorbd/varaq/>;
COPYRIGHT
Copyright (c) 2001, Damian Conway. All Rights Reserved. This module is free software. It may be used, redistributed and/or modified under the same Terms as Perl itself.
Appendix 1: thlIngan-Terran dictionary
thlIngan Terran
======== ======
'ar abs
'ej and
'ov cmp
'uy' -000000
-DoS <suffix indicates use as an output handle>
-Hal <suffix indicates use as an input handle>
-laHwI' \& (subroutine reference)
-vo' suffix indicating something indexed
bach kill
bagh tie
bagh'a' tied
baghHa' untie
bIp -00000
bogh fork
boS pack
boSHa' unpack
bot flock
buv ref
cha' 2
chaqpoDmoH chomp
chel + (addition)
chelHa' - (subtraction)
chen ..
chen ..
chevwI' $/
chImmoH undef
choH map
chorgh 8
chot kill
chov eval
chuv %
De'Daqvo' DATA
Del stat
DIch ...[...]
DIchvaD ...[...] (when it's an lvalue)
DIchvo' ...[...] (when it's to be further indexed)
DIS kill
Dochmeyvam @_
Dochvam $_
DoQ bless
DuQ splice
ghItlh print
ghochna' STDOUT (used as name -- i.e. in an open)
ghochna'DoS STDOUT (used as handle -- i.e. in a print)
ghomchoH chdir
ghomneH wantarray
ghomtagh mkdir
ghomteq rmdir
ghov m
ghuHmoH warn
ghum alarm
HaD study
Hegh die
Hiv kill
HoH kill
Hut 9
ja' tell
jaH goto
jav 6
jegh unshift
jey kill
joqtaH sin
joqtaHHa' cos
juH main
juv length
laD readline
mungna'vo' STDIN (used as name -- i.e. in an open)
mungna'vo'Hal STDIN (used as handle -- i.e. in a readline)
lagh substr
lI'a' exists
lo' use
lo'laH values
lo'Qo' no
lo'Sar sqrt
logh x
loS 4
loS wait
ma' our
mach lc
mach law' lt
machbe' law' ge
maH -0
maHghurtaH log
maj our
mej exit
mI'pIm'a' !=
mI'rap'a' ==
mIS rand
mIScher srand
mISHa' sort
mob scalar
mol dump
mugh tr
muH kill
muv join
nab sub
nargh quotemeta
natlhwI' $|
naw'choH chmod
nej seek
neq rename
netlh -0000
nIH shift
nob =
noD reverse
nup truncate
pa'ghuHmoH carp
pa'Hegh croak
pagh 0
pIm'a' ne
pIn'a'choH chown
poD int
poDmoH chop
pong keys
pongwI' caller
poQ require
poS open
luSpetna' STDERR (used as name -- i.e. in an open)
luSpetna'DoS STDERR (used as handle -- i.e. in a print)
Qaw' delete
qoj or
qojHa' atan2
Qong sleep
ra' system
rap'a' eq
rar link
rIn continue
rIn continue
rIn'a' eof
Sach glob
SaD -000
Sam index
SanID -000
Say'moH reset
sIj split
So' crypt
Soch 7
SoQmoH close
Such each
Suq ...{...}
SuqvaD ...{...} (when it's an lvalue)
Suqvo' ...{...} (when it's to be further indexed)
tagh exec
tam s
tatlh return
teHchugh if
teHchughbe' unless
teHtaHvIS while
teHtaHvISbe' until
teq unlink
tI- imperative prefix (2 or more arguments)
tIn uc
tIn law' gt
tInbe' law' le
tIqel for
tlhoch not
toq'a' defined
vagh 5
vam local
vang do
vatlh -00
wa' 1
wa'Dichmach lcfirst
wa'DichtIn ucfirst
wej 3
wI' my
wIj my
wIv grep
woD pop
wuq ...?...:...
yI- imperative prefix (0 or 1 argument)
yInargh last
yInHa' kill
yInIDqa' redo
yItaH next
yoS package
yuv push
Appendix 2: [Terran-thlIngan] dictionary
Terran thlIngan Literal translation
====== ======== ===================
= nob "give"
.. chen "build up"
{...} {...} "attacking batleth...defending batleth"
(betleH HivtaH...betleH HubtaH")
(...) (...) "attacking sword...defending sword"
('etlh HivtaH...'etlh HubtaH")
...[...] DIch ordinal suffix
...{...} Suq "get"
...?...:... wuq "decide"
x logh "repeated"
% chuv "be left over"
+ chel "add"
- chelHa' "un-add"
/ wav "divide"
== mI'rap'a' "number same?"
!= mI'pIm'a' "number different?"
\& <sub ref> -laHwI' "one who is able to do..."
abs 'ar "how much"
alarm ghum "alarm"
and 'ej "and"
atan2 qojHa' "anti cliff"
bless DoQ "claim ownership of"
caller pongwI' "one who calls"
carp pa'ghuHmoH "warn over there"
chdir ghomchoH "change grouping"
chmod naw'choH "change access"
chomp chaqpoDmoH "maybe clip"
chop poDmoH "clip"
chown pIn'a'choH "change master"
close SoQmoH "close"
cmp 'ov "compete"
continue rIn "be complete"
cos joqtaHHa' "counter waving"
croak pa'Hegh "die over there"
crypt So' "hide"
DATA De'Daqvo' "place from which data comes"
defined toq'a' "is inhabited"
delete Qaw' "destroy"
die Hegh "die"
do vang "take action"
dump mol "bury"
each Such "visit"
eof rIn'a' "is finished"
eq rap'a' "same?"
eval chov "evaluate"
exec tagh "begin a process"
exists lI'a' "is useful"
exit mej "depart"
flock bot "prohibit"
for tIqel "consider them"
fork bogh "be born"
ge machbe' law' "be not smaller"
glob Sach "expand"
goto jaH "go"
grep wIv "choose"
gt tIn law' "be larger"
if teHchugh "if true"
index Sam "locate"
int poD "clip"
join muv "join"
keys pong "name"
kill HoH "kill"
kill muH "execute"
kill chot "murder"
kill bach "shoot"
kill Hiv "attack"
kill DIS "stop"
kill jey "defeat"
last yInargh "escape"
lc mach "be small"
lcfirst wa'Dichmach "the first be small"
le tInbe' law' "be not larger"
length juv "measure"
link rar "connect"
local vam "this"
log maHghurtaH "ten log"
lt mach law' "be smaller"
m ghov "recognize"
main juH "home"
map choH "alter"
mkdir ghomtagh "initiate grouping"
my wI' "my sapient"
my wIj "my"
ne pIm'a' "different?"
next yItaH "go on"
no lo'Qo' "don't use"
not tlhoch "contradict"
open poS "open"
or qoj "inclusive or"
our ma' "our sapient"
our maj "our"
pack boS "collect"
package yoS "district"
pop woD "throw away"
print ghItlh "write"
push yuv "push"
quotemeta nargh "escape"
rand mIS "confuse"
readline laD "read"
redo yInIDqa' "try again"
ref buv "classify"
rename neq "move"
require poQ "demand"
reset Say'moH "cause to be clean"
return tatlh "return something"
reverse noD "retaliate"
rmdir ghomteq "remove grouping"
s tam "substitute"
scalar mob "be alone"
seek nej "seek"
shift nIH "steal"
sin joqtaH "waving"
sleep Qong "sleep"
sort mISHa' "be not mixed up"
splice DuQ "stab"
split sIj "slit"
sqrt lo'Sar "fourth how much"
srand mIScher "establish confusion"
stat Del "describe"
STDIN <name> mungna'vo' "from the origin"
STDIN <handle> mungna'vo'Hal "from the origin (source)"
STDOUT <name> ghochna' "the destination"
STDOUT <handle> ghochna'DoS "the destination (target)"
STDERR <name> luSpetna' "the black hole"
STDERR <handle> luSpetna'DoS "the black hole (target)"
study HaD "study"
sub nab "procedure"
substr lagh "take apart"
system ra' "command"
tell ja' "report"
tie bagh "tie"
tied bagh'a' "is tied"
tr mugh "translate"
truncate nup "decrease"
uc tIn "be big"
ucfirst wa'DichtIn "the first be big"
undef chImmoH "cause to be uninhabited"
unless teHchughbe' "if not true"
unlink teq "remove"
unpack boSHa' "un collect"
unshift jegh "surrender"
untie baghHa' "untie"
until teHtaHvISbe' "while not true"
use lo' "use"
values lo'laH "be valuable"
wait loS "wait for"
wantarray ghomneH "want group"
warn ghuHmoH "warn"
while teHtaHvIS "while true"
pIm'a' ne "are they different?"
rap'a' eq "are they the same?"
0 pagh 0
1 wa' 1
2 cha' 2
3 wej 3
4 loS 4
5 vagh 5
6 jav 6
7 Soch 7
8 chorgh 8
9 Hut 9
-0 maH -0
-00 vatlh -00
-000 SaD -000
-000 SanID -000
-0000 netlh -0000
-00000 bIp -00000
-000000 'uy' -000000
$_ 'oH "it"
@_ bIH "them"
$/ chevwI' "that which separates"
$| natlhwI' "drain?"
Release of version 0.01 of Lingua::tlhInganHol::yIghun
DESCRIPTION
CHANGES IN VERSION 0.01
(No changes have been documented for this version)
AVAILABILITY
Lingua::tlhInganHol::yIghun has been uploaded to the CPAN and is also available from:
Damien Conway
CHANGES
Revision history for Perl extension Lingua::tlhInganHol::yIghun.
0.01 Wed Apr 11 11:43:21 2001
- original version; created by h2xs 1.20
with options -A -P -X -f -n Lingua::tlhInganHol::yIghunMANIFEST
Changes MANIFEST Makefile.PL test.pl yIghun.pm demo_conj.pl demo_eratosthenes.pl demo_misc.pl demo_sub.pl demo_unary.pl
Makefile.PL
use ExtUtils::MakeMaker; WriteMakefile( NAME => 'Lingua::tlhInganHol::yIghun', VERSION => '0.01', );
demo_conj.pl
use Lingua::tlhInganHol::yIghun
"yImugh",
# "yIQIj",
# "tera'nganHol",
;
avaD wa' nob!
bvaD cha' nob!
a b je joqtaH << (1)\n>> yIghItlh!
a b joq joqtaH << (2)\n>> yIghItlh!
a (b joqtaH) je << (3)\n>> yIghItlh!
a (b joqtaH) joq << (4)\n>> yIghItlh!
a 'ej b joqtaH << (5)\n>> yIghItlh!
a qoj b joqtaH << (6)\n>> yIghItlh!
a tlhoch qoj b joqtaH << (7)\n>> yIghItlh!
b a je tlhoch b joq << (8)\n>> yIghItlh!demo_eratosthenes.pl
use Lingua::tlhInganHol::yIghun
# "yImugh",
# "yIQIj",
# "tera'nganHol",
;
###### mI'wa'DIchvaD 'eratoSHeneS HeghqaD #####
<mI' tIn law': > yIghItlh!
mI'tInwIj laDDaqvo'Hal yIlaD nob!
mI'wa'DIchmeywIj cha' mI'tIn chen nob!
{
mI'wa'DIchmeyvaD { 'oH gheD chuv! } mI'wa'DIchmey tIwIv yInob!
gheD <<\n>> ghItlh!
} gheDvaD mI'wa'DIchmeyvaD yInIH yInob teHtaHvIS!demo_misc.pl
use Lingua::tlhInganHol::yIghun
# "yImugh",
"yIQIj",
# "tera'nganHol",
;
# <Hol> 'e' yIBatman!
# togh 'e' qa'mey cha' yI'ang!
wa' yIghItlh!
tochmeyvo' wa' DIchvo' toch Suq <<HIja'\n>> <<ghobe'\n>> wuq yIghItlh!
<<nuqneH, Hoch!\n>> yIghItlh!
toghwIj!
toghpu'wI'!
toghvaD nuqDaq toghpu' yInob!
{ 'oH <<\n>> ghItlh! } wa' wa'maH tIchen noD tIqel!
togh <<\n>> yIghItlh!
<<x\n>> cha' logh yIghItlh!
( <<x\n>> ) cha' logh yIghItlh!
toghmeyvaD ( <<x\n>> ) cha' logh nob!
toghmey mob <<\n>> yIghItlh!
{
{ ghItlhDaqvaDDoS 'oH yIghItlh! } 'oH mach law' wa'maH mach puS teHchugh!
} 'oHvaD laDDaqvo'Hal yIlaD nob teHtaHvIS!demo_sub.pl
use Lingua::tlhInganHol::yIghun
# "yImugh",
# "yIQIj",
# "tera'nganHol",
;
{
<<Qapla!\n>> ghItlh!
} doit nab!
yIdoit!
refwIj doitlaHwI' nob!
yIrefvetlh!demo_unary.pl
use Lingua::tlhInganHol::yIghun
"yImugh",
"yIQIj",
# "tera'nganHol",
;
'oHvaD yIghurQav!test.pl
# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl test.pl'
######################### We start with some black magic to print on failure.
# Change 1..1 below to 1..last_test_to_print .
# (It may become useful if the test is moved to ./t subdirectory.)
BEGIN { $| = 1; print "1..1\n"; }
END {print "not ok 1\n" unless $loaded;}
use Lingua::tlhInganHol::yIghun;
$loaded = 1;
print "ok 1\n";
######################### End of black magic.
# Insert your test code below (better if it prints "ok 13"
# (correspondingly "not ok 13") depending on the success of chunk 13
# of the test code):
|
|