++ed by:

1 non-PAUSE user(s).

Michael G Schwern

NAME

Lingua::tlhInganHol::yIghun - "The Klingon Language: hey you, program in it!"

SYNOPSIS

        use Lingua::tlhInganHol::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 (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:

'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 new

Comparisons

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 -laHwI' (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 yIQij:

        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: vItvaD 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 pIHbe!

What is that command doing on the left of that conjunction?! You dimwit!

%s %sDaq: 'rIn pIHbe!

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!

AUTHOR

Damian Conway <damian@conway.org> is the original author.

Michael G Schwern <schwern@pobox.com> assisted in its escape.

REPOSITORY

The source code of this module can be taken from http://github.com/schwern/lingua-tlhinganhol-yighun/tree/master

BUGS

In this module??? I should kill you where you stand! You speak the lies of a tah-keck! If a p'tahk such as you dares insult our honor with your bug report, you will send it to http://rt.cpan.org/NoAuth/Bugs.html?Dist=Lingua-tlhInganHol-yIghun!

SEE ALSO

The Klingon Language Institute <http://www.kli.org/>

The Varaq programming language <http://www.geocities.com/connorbd/varaq/>

COPYRIGHT

       Copyright (c) 2001-2009, 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?"



Hosting generously
sponsored by Bytemark