argra****@users*****
argra****@users*****
2009年 6月 14日 (日) 17:44:45 JST
Index: docs/perl/5.10.0/perlref.pod
diff -u /dev/null docs/perl/5.10.0/perlref.pod:1.1
--- /dev/null Sun Jun 14 17:44:45 2009
+++ docs/perl/5.10.0/perlref.pod Sun Jun 14 17:44:45 2009
@@ -0,0 +1,1553 @@
+
+=encoding euc-jp
+
+=head1 NAME
+X<reference> X<pointer> X<data structure> X<structure> X<struct>
+
+=begin original
+
+perlref - Perl references and nested data structures
+
+=end original
+
+perlref - Perlのリファレンスとネストしたデータ構造
+
+=head1 NOTE
+
+(注意)
+
+=begin original
+
+This is complete documentation about all aspects of references.
+For a shorter, tutorial introduction to just the essential features,
+see L<perlreftut>.
+
+=end original
+
+本ドキュメントはリファレンスに関するものです。
+チュートリアルに関しては L<perlreftut> を参照してください。
+
+=head1 DESCRIPTION
+
+=begin original
+
+Before release 5 of Perl it was difficult to represent complex data
+structures, because all references had to be symbolic--and even then
+it was difficult to refer to a variable instead of a symbol table entry.
+Perl now not only makes it easier to use symbolic references to variables,
+but also lets you have "hard" references to any piece of data or code.
+Any scalar may hold a hard reference. Because arrays and hashes contain
+scalars, you can now easily build arrays of arrays, arrays of hashes,
+hashes of arrays, arrays of hashes of functions, and so on.
+
+=end original
+
+リリース 5 以前の Perl ではすべてのリファレンスはシンボリックでなければ
+ならなかったために、複雑なデータ構造を表現することが困難でした。
+そしてシンボルテーブルのエントリーではなく変数を参照したいと望んだときも
+困難であったのです。
+Perl はシンボリックリファレンスを変数として使うことを簡単にしただけでなく、
+任意のデータについて「ハード」リファレンスを持つことを可能としたのです。
+任意のスカラはハードリファレンスを保持することができます。
+配列とハッシュはスカラから構成されているので、あなたはいまや配列の配列、
+ハッシュの配列、配列のハッシュ、関数のハッシュの配列等々を簡単に
+組み立てることができるのです。
+
+=begin original
+
+Hard references are smart--they keep track of reference counts for you,
+automatically freeing the thing referred to when its reference count goes
+to zero. (Reference counts for values in self-referential or
+cyclic data structures may not go to zero without a little help; see
+L<perlobj/"Two-Phased Garbage Collection"> for a detailed explanation.)
+If that thing happens to be an object, the object is destructed. See
+L<perlobj> for more about objects. (In a sense, everything in Perl is an
+object, but we usually reserve the word for references to objects that
+have been officially "blessed" into a class package.)
+
+=end original
+
+ハードリファレンスは賢く実際に参照されている数を管理していて、その数が
+0 になれば自動的に解放を行ないます。
+(自己参照や循環データ(cyclic data)にある値に対する参照カウントは、
+ちょっとした手助けなしにはゼロにはなりません。
+詳しくは L<perlobj/"Two-Phased Garbage Collection"> を参照してください。)
+そのものがオブジェクトであるときには、デストラクタが動作します。
+オブジェクトについてより詳しくは、L<perlobj> を参照してください。
+(ある意味では、Perl のすべてがオブジェクトですが、通常、
+クラスパッケージ内で公に "bless" されているものへのリファレンスに対して、
+この用語を用います。)
+
+=begin original
+
+Symbolic references are names of variables or other objects, just as a
+symbolic link in a Unix filesystem contains merely the name of a file.
+The C<*glob> notation is something of a symbolic reference. (Symbolic
+references are sometimes called "soft references", but please don't call
+them that; references are confusing enough without useless synonyms.)
+X<reference, symbolic> X<reference, soft>
+X<symbolic reference> X<soft reference>
+
+=end original
+
+UNIX ファイルシステム上でのシンボリックリンクが単にファイルの名前を
+持っているだけであるのと同様に、シンボリックリファレンスは変数の
+名前を保持します。
+C<*glob> の記法は、シンボリックリファレンスの一種です
+(シンボリックリファレンスは時折“ソフトリファレンス”と
+呼ばれますが、そういう呼びかたをしないでください。
+リファレンスは同義語を使わないでいてさえ混乱を招くのですから)。
+X<reference, symbolic> X<reference, soft>
+X<symbolic reference> X<soft reference>
+
+=begin original
+
+In contrast, hard references are more like hard links in a Unix file
+system: They are used to access an underlying object without concern for
+what its (other) name is. When the word "reference" is used without an
+adjective, as in the following paragraph, it is usually talking about a
+hard reference.
+X<reference, hard> X<hard reference>
+
+=end original
+
+対照的に、 ハードリファレンスはUNIXのファイルシステム上のハードリンクに
+似ています。
+ハードリンクはそれがなんの名前であるのかを気にせずに
+基礎をなすオブジェクトにアクセスするために使われます。
+以下の節にあるように“リファレンス”と言う言葉を形容なしに使った
+場合、通常はハードリファレンスのことを指します。
+X<reference, hard> X<hard reference>
+
+=begin original
+
+References are easy to use in Perl. There is just one overriding
+principle: Perl does no implicit referencing or dereferencing. When a
+scalar is holding a reference, it always behaves as a simple scalar. It
+doesn't magically start being an array or hash or subroutine; you have to
+tell it explicitly to do so, by dereferencing it.
+
+=end original
+
+Perlでリファレンスを使うのは非常に簡単です。
+原則のオーバーライドが一つあるだけです。
+Perl はリファレンス(referencing)やデリファレンス(defreferencing)を
+暗黙に行うことはありません。
+スカラがリファレンスを保持しているとき、それは常に単純なスカラとして
+振る舞います。
+勝手に配列や、ハッシュ、サブルーチンとして振る舞うようなことはありません。
+デリファレンスをすることによって、自分で明示的に Perl に
+教える必要があります。
+
+=head2 Making References
+X<reference, creation> X<referencing>
+
+(リファレンスを作る)
+
+=begin original
+
+References can be created in several ways.
+
+=end original
+
+リファレンスは幾つかのやり方で構築することができます。
+
+=over 4
+
+=item 1.
+X<\> X<backslash>
+
+=begin original
+
+By using the backslash operator on a variable, subroutine, or value.
+(This works much like the & (address-of) operator in C.)
+This typically creates I<another> reference to a variable, because
+there's already a reference to the variable in the symbol table. But
+the symbol table reference might go away, and you'll still have the
+reference that the backslash returned. Here are some examples:
+
+=end original
+
+変数、サブルーチン、値にバックスラッシュ演算子を使うことによる
+(これは C での & (アドレス) 演算子に似た働きをします)。
+既にシンボルテーブルには変数へのリファレンスが存在していますから、
+この方法は I<別の> リファレンスを作るものです。
+しかし、シンボルテーブルのリファレンスがなくなったとしても、
+バックスラッシュが返したリファレンスが存在することになります。
+例をいくつかあげます:
+
+ $scalarref = \$foo;
+ $arrayref = \@ARGV;
+ $hashref = \%ENV;
+ $coderef = \&handler;
+ $globref = \*foo;
+
+=begin original
+
+It isn't possible to create a true reference to an IO handle (filehandle
+or dirhandle) using the backslash operator. The most you can get is a
+reference to a typeglob, which is actually a complete symbol table entry.
+But see the explanation of the C<*foo{THING}> syntax below. However,
+you can still use type globs and globrefs as though they were IO handles.
+
+=end original
+
+バックスラッシュ演算子を使って IO ハンドル(ファイルハンドルまたは
+ディレクトリハンドル)へのリファレンスを生成することはできません。
+もっとも良く扱うリファレンスは型グロブに対するリファレンス(実際には
+シンボルテーブルのエントリである)でしょう。
+後述する *foo{THING} 構文の説明を参照してください。
+しかしながら、IO ハンドルであったものとして型グロブや型グロブの
+リファレンス(grobref)を使うこともできます。
+
+=item 2.
+X<array, anonymous> X<[> X<[]> X<square bracket>
+X<bracket, square> X<arrayref> X<array reference> X<reference, array>
+
+=begin original
+
+A reference to an anonymous array can be created using square
+brackets:
+
+=end original
+
+名前の無い配列へのリファレンスは、大かっこを使って作ることができます:
+
+ $arrayref = [1, 2, ['a', 'b', 'c']];
+
+=begin original
+
+Here we've created a reference to an anonymous array of three elements
+whose final element is itself a reference to another anonymous array of three
+elements. (The multidimensional syntax described later can be used to
+access this. For example, after the above, C<< $arrayref->[2][1] >> would have
+the value "b".)
+
+=end original
+
+ここでは、『「名前の無い 3 個の要素を持つ配列」を最後の要素として持つ
+3 個要素の名前の無い配列』へのリファレンスを作っています。
+(あとで述べる多次元構文を使って、これをアクセスすることができます。
+たとえば、上記のようにした後では、
+C<< $arrayref->[2][1] >> が "b" となります。)
+
+=begin original
+
+Taking a reference to an enumerated list is not the same
+as using square brackets--instead it's the same as creating
+a list of references!
+
+=end original
+
+列挙リストに対するリファレンスを取るということは、大かっこを使うことと
+同じではありません。
+これはリファレンスのリストを生成することと同じなのです!
+
+ @list = (\$a, \@b, \%c);
+ @list = \($a, @b, %c); # same thing!
+
+=begin original
+
+As a special case, C<\(@foo)> returns a list of references to the contents
+of C<@foo>, not a reference to C<@foo> itself. Likewise for C<%foo>,
+except that the key references are to copies (since the keys are just
+strings rather than full-fledged scalars).
+
+=end original
+
+特殊な場合として、C<\(@foo)> は C<@foo> 自身へのリファレンスではなく、
+C<@foo> の内容のそれぞれへのリファレンスのリストを返します。
+C<%foo> も同様ですが、キーのコピーに対するリファレンスである点が
+異なります(これはキーが完全なスカラではなく単なる文字列であるためです)。
+
+=item 3.
+X<hash, anonymous> X<{> X<{}> X<curly bracket>
+X<bracket, curly> X<brace> X<hashref> X<hash reference> X<reference, hash>
+
+=begin original
+
+A reference to an anonymous hash can be created using curly
+brackets:
+
+=end original
+
+名前の無いハッシュへのリファレンスは、中かっこを使って作ることができます:
+
+ $hashref = {
+ 'Adam' => 'Eve',
+ 'Clyde' => 'Bonnie',
+ };
+
+=begin original
+
+Anonymous hash and array composers like these can be intermixed freely to
+produce as complicated a structure as you want. The multidimensional
+syntax described below works for these too. The values above are
+literals, but variables and expressions would work just as well, because
+assignment operators in Perl (even within local() or my()) are executable
+statements, not compile-time declarations.
+
+=end original
+
+無名ハッシュと配列のコンストラクタは、複雑な構造を作るために自由に
+組み合わせることができます。
+後述する多次元構文は、そのようなものに対しても使うことができます。
+上記の値はリテラルですが、変数や式であってもかまいません。
+Perl での代入演算は、(たとえ、local() や my() の中でも) コンパイル時の
+宣言文ではなく、実行文だからです。
+
+=begin original
+
+Because curly brackets (braces) are used for several other things
+including BLOCKs, you may occasionally have to disambiguate braces at the
+beginning of a statement by putting a C<+> or a C<return> in front so
+that Perl realizes the opening brace isn't starting a BLOCK. The economy and
+mnemonic value of using curlies is deemed worth this occasional extra
+hassle.
+
+=end original
+
+中かっこは、BLOCK を始めとして他のことにも使われますから、
+開きの中かっこが BLOCK の開始でないことを Perl に教える
+ために文の最初の中かっこの前に C<+> や C<return> をつけて、
+曖昧さをなくすようにする必要がある場合があります。
+このちょっとした余分な作業は、中かっこの使用に関連して
+実際に使ってみる価値や覚えておくだけの価値があるでしょう。
+
+=begin original
+
+For example, if you wanted a function to make a new hash and return a
+reference to it, you have these options:
+
+=end original
+
+たとえば、新しいハッシュを作って、それへのリファレンスを返す関数が欲しければ、
+以下のような選択肢があります:
+
+ sub hashem { { @_ } } # silently wrong
+ sub hashem { +{ @_ } } # ok
+ sub hashem { return { @_ } } # ok
+
+=begin original
+
+On the other hand, if you want the other meaning, you can do this:
+
+=end original
+
+その一方で、以下のようにすることもできます:
+
+ sub showem { { @_ } } # ambiguous (currently ok, but may change)
+ sub showem { {; @_ } } # ok
+ sub showem { { return @_ } } # ok
+
+=begin original
+
+The leading C<+{> and C<{;> always serve to disambiguate
+the expression to mean either the HASH reference, or the BLOCK.
+
+=end original
+
+先頭にある C<+{> や C<{;> が、その式が実際には
+ハッシュのリファレンスなのかブロックなのかの
+曖昧さを除去するためにあります。
+
+=item 4.
+X<subroutine, anonymous> X<subroutine, reference> X<reference, subroutine>
+X<scope, lexical> X<closure> X<lexical> X<lexical scope>
+
+=begin original
+
+A reference to an anonymous subroutine can be created by using
+C<sub> without a subname:
+
+=end original
+
+無名サブルーチンのへのリファレンスは、サブルーチン名の無い C<sub> を使って
+作ることができます:
+
+ $coderef = sub { print "Boink!\n" };
+
+=begin original
+
+Note the semicolon. Except for the code
+inside not being immediately executed, a C<sub {}> is not so much a
+declaration as it is an operator, like C<do{}> or C<eval{}>. (However, no
+matter how many times you execute that particular line (unless you're in an
+C<eval("...")>), $coderef will still have a reference to the I<same>
+anonymous subroutine.)
+
+=end original
+
+セミコロンに注意してください。
+内部のコードが即座に実行されるのではないということを除けば、C<sub{}> は、
+宣言というよりもむしろ、C<do{}> や C<eval{}> のような演算子です(しかし、
+C<eval("...")> の中でなければ、何回その行を実行しようとも
+$coderef は、I<同一の> 無名サブルーチンをリファレンスすることになります)。
+
+=begin original
+
+Anonymous subroutines act as closures with respect to my() variables,
+that is, variables lexically visible within the current scope. Closure
+is a notion out of the Lisp world that says if you define an anonymous
+function in a particular lexical context, it pretends to run in that
+context even when it's called outside the context.
+
+=end original
+
+無名サブルーチンは my() 変数に関連するクロージャのように振る舞います。
+つまり、変数はカレントのスコープの中においてレキシカルに見えます。
+クロージャは、無名関数をある特定のレキシカルコンテキストで
+定義した場合にたとえそのコンテキストの外側で呼び出されたとしても
+定義されたときのコンテキストで実行されることを要求するという
+Lisp の世界の概念です。
+
+=begin original
+
+In human terms, it's a funny way of passing arguments to a subroutine when
+you define it as well as when you call it. It's useful for setting up
+little bits of code to run later, such as callbacks. You can even
+do object-oriented stuff with it, though Perl already provides a different
+mechanism to do that--see L<perlobj>.
+
+=end original
+
+わかりやすく言えば、あなたがサブルーチンを呼び出すときと同じように、
+サブルーチンを定義するときに引数を渡すという奇妙なやり方ということです。
+あなたはこれでオブジェクト指向的性質を実現することも
+できます。
+が、Perl はすでにこれとは異なる仕組みを提供しています --
+L<perlobj> を参照してください。
+
+=begin original
+
+You might also think of closure as a way to write a subroutine
+template without using eval(). Here's a small example of how
+closures work:
+
+=end original
+
+クロージャは eval なしにサブルーチンのテンプレートを記述する方法だという
+考え方もできます。
+以下に示すのは、クロージャがどのように動作するのかの例です。
+
+ sub newprint {
+ my $x = shift;
+ return sub { my $y = shift; print "$x, $y!\n"; };
+ }
+ $h = newprint("Howdy");
+ $g = newprint("Greetings");
+
+ # Time passes...
+
+ &$h("world");
+ &$g("earthlings");
+
+=begin original
+
+This prints
+
+=end original
+
+出力はこうなります。
+
+ Howdy, world!
+ Greetings, earthlings!
+
+=begin original
+
+Note particularly that $x continues to refer to the value passed
+into newprint() I<despite> "my $x" having gone out of scope by the
+time the anonymous subroutine runs. That's what a closure is all
+about.
+
+=end original
+
+ここで特に、無名サブルーチンの実行時には“my $x”がスコープの外にあるにも
+B<かかわらず>、$x が newprint() に渡された値を参照しつづけていることに
+注意してください。
+これがクロージャがクロージャたる由縁です。
+
+=begin original
+
+This applies only to lexical variables, by the way. Dynamic variables
+continue to work as they have always worked. Closure is not something
+that most Perl programmers need trouble themselves about to begin with.
+
+=end original
+
+これはレキシカル変数にのみ適用されます。
+動的変数はこれまでと同じように動作します。
+クロージャは、大部分の Perl プログラマーがそれを使いはじめるために
+トラブルをしょいこんでしまうような代物ではありません。
+
+=item 5.
+X<constructor> X<new>
+
+=begin original
+
+References are often returned by special subroutines called constructors. Perl
+objects are just references to a special type of object that happens to know
+which package it's associated with. Constructors are just special subroutines
+that know how to create that association. They do so by starting with an
+ordinary reference, and it remains an ordinary reference even while it's also
+being an object. Constructors are often named C<new()>. You I<can> call them
+indirectly:
+
+=end original
+
+リファレンスはコンストラクタと呼ばれる特別なサブルーチンが返すようにして
+いることが多くなっています。
+Perlのオブジェクトは、自分がどのパッケージと関係を持っているかを
+知っているものへのリファレンスでしかありません。
+コンストラクタは、その関係付けをどのように行なうかを知っているという意味で、
+特別なサブルーチンにすぎません。
+単なるリファレンスとしてスタートし、オブジェクトといわれている間でも
+通常のリファレンスであることに変わりはありません。
+コンストラクタは、慣習的に C<new()> と名前を付けられます。
+間接的に呼び出すことも I<可能です>:
+
+ $objref = new Doggie( Tail => 'short', Ears => 'long' );
+
+=begin original
+
+But that can produce ambiguous syntax in certain cases, so it's often
+better to use the direct method invocation approach:
+
+=end original
+
+しかし、これは場合によってはあいまいな文法となる場合があるので、
+たいていは直接メソッド起動手法を使う方がよいです:
+
+ $objref = Doggie->new(Tail => 'short', Ears => 'long');
+
+ use Term::Cap;
+ $terminal = Term::Cap->Tgetent( { OSPEED => 9600 });
+
+ use Tk;
+ $main = MainWindow->new();
+ $menubar = $main->Frame(-relief => "raised",
+ -borderwidth => 2)
+
+=item 6.
+X<autovivification>
+
+=begin original
+
+References of the appropriate type can spring into existence if you
+dereference them in a context that assumes they exist. Because we haven't
+talked about dereferencing yet, we can't show you any examples yet.
+
+=end original
+
+適切な型のリファレンスは、そういったリファレンスが存在するかのような文脈で
+デリファレンスを行うと、実際に存在するようになります。
+デリファレンスについてはまだ話していないので、まだ例を示すことができません。
+
+=item 7.
+X<*foo{THING}> X<*>
+
+=begin original
+
+A reference can be created by using a special syntax, lovingly known as
+the *foo{THING} syntax. *foo{THING} returns a reference to the THING
+slot in *foo (which is the symbol table entry which holds everything
+known as foo).
+
+=end original
+
+リファレンスは、*foo{THING} 構文として知られている
+特殊な構文を使って生成することができます。
+*foo{THING} はリファレンスを *foo の THING スロット(これは
+foo として知られる全てのものを保持するシンボルテーブルのエントリです)に
+返します。
+
+ $scalarref = *foo{SCALAR};
+ $arrayref = *ARGV{ARRAY};
+ $hashref = *ENV{HASH};
+ $coderef = *handler{CODE};
+ $ioref = *STDIN{IO};
+ $globref = *foo{GLOB};
+ $formatref = *foo{FORMAT};
+
+=begin original
+
+All of these are self-explanatory except for C<*foo{IO}>. It returns
+the IO handle, used for file handles (L<perlfunc/open>), sockets
+(L<perlfunc/socket> and L<perlfunc/socketpair>), and directory
+handles (L<perlfunc/opendir>). For compatibility with previous
+versions of Perl, C<*foo{FILEHANDLE}> is a synonym for C<*foo{IO}>, though it
+is deprecated as of 5.8.0. If deprecation warnings are in effect, it will warn
+of its use.
+
+=end original
+
+これら全ては、C<*foo{IO}> を除いて自己説明的です。
+ファイルハンドル(L<perlfunc/open>)、ソケット(L<perlfunc/socket> と
+L<perlfunc/socketpair>)、ディレクトリハンドル(L<perlfunc/opendir>)
+として使われる IO ハンドルを返します。
+過去のバージョンの Perl に対する互換性のために、
+C<*foo{FILEHANDLE}> は C<*foo{IO}> の同義語ですが、5.8.0 からは
+非推奨です。
+非推奨警告が有効になっていれば、使用すると警告が出ます。
+
+=begin original
+
+C<*foo{THING}> returns undef if that particular THING hasn't been used yet,
+except in the case of scalars. C<*foo{SCALAR}> returns a reference to an
+anonymous scalar if $foo hasn't been used yet. This might change in a
+future release.
+
+=end original
+
+C<*foo{THING}> は、スカラの場合を除いた特定の THING がまだ
+使われていない場合には undef を返します。
+C<*foo{SCALAR}> は、$foo がまだ使われていなかった場合には
+無名スカラへのリファレンスを返します。
+これは将来のリリースでは変わる可能性があります。
+
+=begin original
+
+C<*foo{IO}> is an alternative to the C<*HANDLE> mechanism given in
+L<perldata/"Typeglobs and Filehandles"> for passing filehandles
+into or out of subroutines, or storing into larger data structures.
+Its disadvantage is that it won't create a new filehandle for you.
+Its advantage is that you have less risk of clobbering more than
+you want to with a typeglob assignment. (It still conflates file
+and directory handles, though.) However, if you assign the incoming
+value to a scalar instead of a typeglob as we do in the examples
+below, there's no risk of that happening.
+
+=end original
+
+C<*foo{IO}> は、L<perldata/"Typeglobs and Filehandles"> にある
+ファイルハンドルをサブルーチンに渡したり、あるいは逆に
+サブルーチンから返すために、あるいは大きなデータ構造を格納する
+ために用いられる C<*HANDLE> 機構の代替です。
+その不利な点は新しいハンドルをあなたのために作り出すことはしないと
+いうことです。
+有利な点は、型グロブの代入を使うよりも気をつかう必要があまりないということです。
+(しかし、これはまだファイルハンドルとディレクトリハンドルを融合します。)
+しかし、もし以下の例で行っているように、値を型グロブではなくスカラに
+代入すると、起きることに対するリスクはありません。
+
+ splutter(*STDOUT); # pass the whole glob
+ splutter(*STDOUT{IO}); # pass both file and dir handles
+
+ sub splutter {
+ my $fh = shift;
+ print $fh "her um well a hmmm\n";
+ }
+
+ $rec = get_rec(*STDIN); # pass the whole glob
+ $rec = get_rec(*STDIN{IO}); # pass both file and dir handles
+
+ sub get_rec {
+ my $fh = shift;
+ return scalar <$fh>;
+ }
+
+=back
+
+=head2 Using References
+X<reference, use> X<dereferencing> X<dereference>
+
+(リファレンスを使う)
+
+=begin original
+
+That's it for creating references. By now you're probably dying to
+know how to use references to get back to your long-lost data. There
+are several basic methods.
+
+=end original
+
+リファレンスの作り方はこれだけです。
+ここまでくると、どこか参照のかなたへ行ってしまったデータを取り戻すために、
+どうやってリファレンスを使うかを知りたいことでしょう。
+基本的な方法がいくつかあります。
+
+=over 4
+
+=item 1.
+
+=begin original
+
+Anywhere you'd put an identifier (or chain of identifiers) as part
+of a variable or subroutine name, you can replace the identifier with
+a simple scalar variable containing a reference of the correct type:
+
+=end original
+
+変数名やサブルーチン名の一部として識別子を置くところでは、適切な
+型のリファレンスを持った単純スカラ変数でその識別子を
+置き換えることができます:
+
+ $bar = $$scalarref;
+ push(@$arrayref, $filename);
+ $$arrayref[0] = "January";
+ $$hashref{"KEY"} = "VALUE";
+ &$coderef(1,2,3);
+ print $globref "output\n";
+
+=begin original
+
+It's important to understand that we are specifically I<not> dereferencing
+C<$arrayref[0]> or C<$hashref{"KEY"}> there. The dereference of the
+scalar variable happens I<before> it does any key lookups. Anything more
+complicated than a simple scalar variable must use methods 2 or 3 below.
+However, a "simple scalar" includes an identifier that itself uses method
+1 recursively. Therefore, the following prints "howdy".
+
+=end original
+
+$arrayref[0] や $hashref{"KEY"} という形でしているの I<ではない> ことが
+大切です。
+スカラ変数のデリファレンスは、いかなる key の検索よりも I<前に> 行なわれます。
+単純スカラ変数より込み入ったものはすべて、
+以下の 2 番か 3 番の方法が採られます。
+しかしながら、「単純スカラ」には、この 1 番目の方法を再帰的に使っている
+識別子も含まれます。
+したがって、以下はは、"howdy" と出力します。
+
+ $refrefref = \\\"howdy";
+ print $$$$refrefref;
+
+=item 2.
+
+=begin original
+
+Anywhere you'd put an identifier (or chain of identifiers) as part of a
+variable or subroutine name, you can replace the identifier with a
+BLOCK returning a reference of the correct type. In other words, the
+previous examples could be written like this:
+
+=end original
+
+変数名やサブルーチン名の一部として識別子を置くところでは、適切な型の
+リファレンスを返す BLOCK を伴う識別子で置き換えることができます。
+言い換えると、先の例は以下のように書くことができます:
+
+ $bar = ${$scalarref};
+ push(@{$arrayref}, $filename);
+ ${$arrayref}[0] = "January";
+ ${$hashref}{"KEY"} = "VALUE";
+ &{$coderef}(1,2,3);
+ $globref->print("output\n"); # iff IO::Handle is loaded
+
+=begin original
+
+Admittedly, it's a little silly to use the curlies in this case, but
+the BLOCK can contain any arbitrary expression, in particular,
+subscripted expressions:
+
+=end original
+
+確かにこの場合には中かっこを付けるのはばかげたことかもしれませんが、
+BLOCK には任意の式、特に添字を付けた式を入れることができます:
+
+ &{ $dispatch{$index} }(1,2,3); # call correct routine
+
+=begin original
+
+Because of being able to omit the curlies for the simple case of C<$$x>,
+people often make the mistake of viewing the dereferencing symbols as
+proper operators, and wonder about their precedence. If they were,
+though, you could use parentheses instead of braces. That's not the case.
+Consider the difference below; case 0 is a short-hand version of case 1,
+I<not> case 2:
+
+=end original
+
+単純な <$$x> の場合には中かっこが省略できるので、シンボルの
+デリファレンスを適当な演算子のように受け取って、その優先順位はどのくらいかと
+悩む人があります。
+しかし、もし演算子であれば、中かっこの代わりに、
+普通の括弧が使えることでしょう。
+そうではありません。
+以下の違いを考えてみてください。
+CASE 0 は、CASE 1 を短くしたものであり、CASE 2 を
+短くしたものでは B<ありません>:
+
+ $$hashref{"KEY"} = "VALUE"; # CASE 0
+ ${$hashref}{"KEY"} = "VALUE"; # CASE 1
+ ${$hashref{"KEY"}} = "VALUE"; # CASE 2
+ ${$hashref->{"KEY"}} = "VALUE"; # CASE 3
+
+=begin original
+
+Case 2 is also deceptive in that you're accessing a variable
+called %hashref, not dereferencing through $hashref to the hash
+it's presumably referencing. That would be case 3.
+
+=end original
+
+CASE 2 もまた間違えやすいもので、%hashref という変数をアクセスするものです。
+$hashref を仲介して、それが指すことになっているハッシュを
+デリファレンスしているものではありません。
+それは、CASE 3 です。
+
+=item 3.
+
+=begin original
+
+Subroutine calls and lookups of individual array elements arise often
+enough that it gets cumbersome to use method 2. As a form of
+syntactic sugar, the examples for method 2 may be written:
+
+=end original
+
+配列の個々の要素を使う場合が増えると、2 番の方法を使うのが
+煩わしくなってきます。
+構文上の打開策として上記の 2 行は、以下のように書けます:
+
+ $arrayref->[0] = "January"; # Array element
+ $hashref->{"KEY"} = "VALUE"; # Hash element
+ $coderef->(1,2,3); # Subroutine call
+
+=begin original
+
+The left side of the arrow can be any expression returning a reference,
+including a previous dereference. Note that C<$array[$x]> is I<not> the
+same thing as C<< $array->[$x] >> here:
+
+=end original
+
+矢印の左側には先行するデリファレンスを含めて、リファレンスを返す任意の式が
+書けます(C<$array[$x]> は、C<< $array->[$x] >> と同じでは I<ありません>)。
+
+ $array[$x]->{"foo"}->[0] = "January";
+
+=begin original
+
+This is one of the cases we mentioned earlier in which references could
+spring into existence when in an lvalue context. Before this
+statement, C<$array[$x]> may have been undefined. If so, it's
+automatically defined with a hash reference so that we can look up
+C<{"foo"}> in it. Likewise C<< $array[$x]->{"foo"} >> will automatically get
+defined with an array reference so that we can look up C<[0]> in it.
+This process is called I<autovivification>.
+
+=end original
+
+これが、先の左辺値コンテキストで用いるとリファレンスが
+存在するようになるというケースの一つです。
+この文以前には、C<$array[$x]> は未定義かもしれません。
+その場合自動的にハッシュリファレンスと定義されて、C<{"foo"}> が
+検索できるようになります。
+同じように C<< $array[$x]->{"foo"} >> が配列リファレンスで定義されるので、
+C<[0]> をそこで探すことができます。
+このプロセスは I<自動有効化> (autovivification) と呼ばれます。
+
+=begin original
+
+One more thing here. The arrow is optional I<between> brackets
+subscripts, so you can shrink the above down to
+
+=end original
+
+もう一つ。
+矢印は、括弧付きの添字の I<間> では、省略することができるので、
+上の例は、以下のように書けます:
+
+ $array[$x]{"foo"}[0] = "January";
+
+=begin original
+
+Which, in the degenerate case of using only ordinary arrays, gives you
+multidimensional arrays just like C's:
+
+=end original
+
+通常の配列だけを使うように限定すれば、ちょうど C の多次元配列のように
+使うことができます:
+
+ $score[$x][$y][$z] += 42;
+
+=begin original
+
+Well, okay, not entirely like C's arrays, actually. C doesn't know how
+to grow its arrays on demand. Perl does.
+
+=end original
+
+ああ、そうだ、実際には全く C の配列と同じという訳ではありません。
+C では、必要に応じて配列を大きくするなどということはできません。
+Perl では、それができます。
+
+=item 4.
+
+=begin original
+
+If a reference happens to be a reference to an object, then there are
+probably methods to access the things referred to, and you should probably
+stick to those methods unless you're in the class package that defines the
+object's methods. In other words, be nice, and don't violate the object's
+encapsulation without a very good reason. Perl does not enforce
+encapsulation. We are not totalitarians here. We do expect some basic
+civility though.
+
+=end original
+
+リファレンスが、オブジェクトに対するものである場合には、参照されるものを
+アクセスするためのメソッドがあるはずで、オブジェクトのメソッドを
+定義するクラスパッケージ内でなければ、そのメソッドを使うように
+した方が良いでしょう。
+言い換えると、良識をもって、特別正当な理由がない限り、
+オブジェクトのカプセル化を反古にしてはいけないということです。
+Perl は、カプセル化を強要したりはしません。
+私達は、全体主義者ではありません。
+ただ、なにがしかの基本的な節度を期待しています。
+
+=back
+
+=begin original
+
+Using a string or number as a reference produces a symbolic reference,
+as explained above. Using a reference as a number produces an
+integer representing its storage location in memory. The only
+useful thing to be done with this is to compare two references
+numerically to see whether they refer to the same location.
+X<reference, numeric context>
+
+=end original
+
+文字列や数値をリファレンスとして使うと、上述したようにシンボリック
+リファレンスを生成します。
+リファレンスを数値として使うと、メモリ内のストレージの位置の
+整数表現を生成します。
+これを利用して便利な唯一の状況は、二つのリファレンスを数値として
+比較することで、同じ場所を参照しているかどうかを調べる場合です。
+X<reference, numeric context>
+
+ if ($ref1 == $ref2) { # cheap numeric compare of references
+ print "refs 1 and 2 refer to the same thing\n";
+ }
+
+=begin original
+
+Using a reference as a string produces both its referent's type,
+including any package blessing as described in L<perlobj>, as well
+as the numeric address expressed in hex. The ref() operator returns
+just the type of thing the reference is pointing to, without the
+address. See L<perlfunc/ref> for details and examples of its use.
+X<reference, string context>
+
+=end original
+
+リファレンスを文字列として使うと、参照しているものの型
+(L<perlobj> で記述しているように、bless しているパッケージを含みます)と、
+16 進数で表現された数値アドレスの両方を生成します。
+ref() 演算子は、アドレス抜きで、リファレンスが示しているものの型だけを
+返します。
+この使い方の詳細と例については L<perlfunc/ref> を参照してください。
+X<reference, string context>
+
+=begin original
+
+The bless() operator may be used to associate the object a reference
+points to with a package functioning as an object class. See L<perlobj>.
+
+=end original
+
+bless() 演算子は、オブジェクトをオブジェクトクラスとして機能する
+パッケージと結び付けるために使うことができます。
+L<perlobj> を参照してください。
+
+=begin original
+
+A typeglob may be dereferenced the same way a reference can, because
+the dereference syntax always indicates the type of reference desired.
+So C<${*foo}> and C<${\$foo}> both indicate the same scalar variable.
+
+=end original
+
+デリファレンスの構文では常に目的とするリファレンスの型を
+示すことができるので、型グロブをリファレンスと同じように
+デリファレンスすることができます。
+つまり、C<${*foo}> と C<${\$foo}> は、どちらも同じスカラ変数を
+示すことになります。
+
+=begin original
+
+Here's a trick for interpolating a subroutine call into a string:
+
+=end original
+
+次の例に示すのは、文字列にサブルーチン呼び出しを埋め込む仕掛けです:
+
+ print "My sub returned @{[mysub(1,2,3)]} that time.\n";
+
+=begin original
+
+The way it works is that when the C<@{...}> is seen in the double-quoted
+string, it's evaluated as a block. The block creates a reference to an
+anonymous array containing the results of the call to C<mysub(1,2,3)>. So
+the whole block returns a reference to an array, which is then
+dereferenced by C<@{...}> and stuck into the double-quoted string. This
+chicanery is also useful for arbitrary expressions:
+
+=end original
+
+ダブルクォートで囲まれた文字列中に C<@{...}> が見つかると、その
+文字列はブロックとして評価されます。
+ブロックでは、C<mysub(1,2,3)> の呼び出しを実行し、その結果に対する
+無名配列へのリファレンスが作られます。
+つまり、ブロック全体では、配列へのリファレンスを返すこととなり、
+C<@{...}> でデリファレンスされた後、ダブルクォートで囲まれた文字列の中に、
+埋め込まれることになります。
+このごまかしは任意の式にも有用です:
+
+ print "That yields @{[$n + 5]} widgets\n";
+
+=begin original
+
+Similarly, an expression that returns a reference to a scalar can be
+dereferenced via C<${...}>. Thus, the above expression may be written
+as:
+
+=end original
+
+同様に、スカラへのリファレンスを返す式は C<${...}> で
+デリファレンスできます。
+従って、上述の式は以下のように書けます:
+
+ print "That yields ${\($n + 5)} widgets\n";
+
+=head2 Symbolic references
+X<reference, symbolic> X<reference, soft>
+X<symbolic reference> X<soft reference>
+
+(シンボリックリファレンス)
+
+=begin original
+
+We said that references spring into existence as necessary if they are
+undefined, but we didn't say what happens if a value used as a
+reference is already defined, but I<isn't> a hard reference. If you
+use it as a reference, it'll be treated as a symbolic
+reference. That is, the value of the scalar is taken to be the I<name>
+of a variable, rather than a direct link to a (possibly) anonymous
+value.
+
+=end original
+
+リファレンスはもし未定義であれば必要に応じて存在するようになると言いましたが、
+もしリファレンスとして使われた値が既に定義されていたときにはどのように
+なるのか示していませんでした。
+これはハードリファレンスでは I<ありません>。
+リファレンスとして使ったならそれはシンボリックリファレンスとして扱われます。
+つまり、スカラの値は(おそらく)無名の値への直接のリンクではなく、
+変数の I<名前> として扱われます。
+
+=begin original
+
+People frequently expect it to work like this. So it does.
+
+=end original
+
+そのように働くと思われていることが多いものです。
+ですからそう動作するのです。
+
+ $name = "foo";
+ $$name = 1; # Sets $foo
+ ${$name} = 2; # Sets $foo
+ ${$name x 2} = 3; # Sets $foofoo
+ $name->[0] = 4; # Sets $foo[0]
+ @$name = (); # Clears @foo
+ &$name(); # Calls &foo() (as in Perl 4)
+ $pack = "THAT";
+ ${"${pack}::$name"} = 5; # Sets $THAT::foo without eval
+
+=begin original
+
+This is powerful, and slightly dangerous, in that it's possible
+to intend (with the utmost sincerity) to use a hard reference, and
+accidentally use a symbolic reference instead. To protect against
+that, you can say
+
+=end original
+
+これは強力で、かつ多少危険でもあります。
+(最大限の注意をはらって) ハードリファレンスを使おうとした場合にも、
+誤ってシンボリックリファレンスを使ってしまうような場合があるからです。
+これを防止するには、以下のように書いて
+
+ use strict 'refs';
+
+=begin original
+
+and then only hard references will be allowed for the rest of the enclosing
+block. An inner block may countermand that with
+
+=end original
+
+囲っているブロック内の残りの部分ではハードリファレンスのみが
+許されるようにすることができます。
+内側のブロックでは、以下のように書いて打ち消すこともできます:
+
+ no strict 'refs';
+
+=begin original
+
+Only package variables (globals, even if localized) are visible to
+symbolic references. Lexical variables (declared with my()) aren't in
+a symbol table, and thus are invisible to this mechanism. For example:
+
+=end original
+
+シンボリックリファレンスでは、パッケージ変数(ローカル化されていたとしても
+グローバル)だけを見ることができます。
+(my() で宣言した) レキシカル変数は、シンボルテーブルに
+存在しないのでシンボリックリファレンスでは参照することができません。
+たとえば:
+
+ local $value = 10;
+ $ref = "value";
+ {
+ my $value = 20;
+ print $$ref;
+ }
+
+=begin original
+
+This will still print 10, not 20. Remember that local() affects package
+variables, which are all "global" to the package.
+
+=end original
+
+これは、20 ではなく、10 と出力します。
+local() は、パッケージで「グローバルな」、パッケージ変数に
+影響するものです。
+
+=head2 Not-so-symbolic references
+
+(あまりシンボリックではないリファレンス)
+
+=begin original
+
+A new feature contributing to readability in perl version 5.001 is that the
+brackets around a symbolic reference behave more like quotes, just as they
+always have within a string. That is,
+
+=end original
+
+perl のバージョン 5.001 で、中かっこに囲まれたシンボリックリファレンスが
+よりクォートのように、ちょうどそれが文字列の中にあるかのように
+振る舞うという新たな機能が読みやすさのために追加されました。
+これは、
+
+ $push = "pop on ";
+ print "${push}over";
+
+=begin original
+
+has always meant to print "pop on over", even though push is
+a reserved word. This has been generalized to work the same outside
+of quotes, so that
+
+=end original
+
+とすると push が予約語であるにも関らず常に“pop on over”となります。
+これはクォートの外であっても同様です。
+ですから、
+
+ print ${push} . "over";
+
+=begin original
+
+and even
+
+=end original
+
+や
+
+ print ${ push } . "over";
+
+=begin original
+
+will have the same effect. (This would have been a syntax error in
+Perl 5.000, though Perl 4 allowed it in the spaceless form.) This
+construct is I<not> considered to be a symbolic reference when you're
+using strict refs:
+
+=end original
+
+でさえも同じ効果となります。
+(これは Perl 4 が 空白無しの形式を許しているにも関らず、
+Perl 5.000 では構文エラーとなります)。
+この構造はあなたが strict refs を使っているときに、
+シンボリックリファレンスであることを考慮 I<していません>。
+
+ use strict 'refs';
+ ${ bareword }; # Okay, means $bareword.
+ ${ "bareword" }; # Error, symbolic reference.
+
+=begin original
+
+Similarly, because of all the subscripting that is done using single
+words, we've applied the same rule to any bareword that is used for
+subscripting a hash. So now, instead of writing
+
+=end original
+
+同様に、添え字付けのすべてが単一の語で行われているので、
+同じルールをハッシュに対する添え字付けに使われる
+任意の裸の単語に適用します。
+ですから、
+
+ $array{ "aaa" }{ "bbb" }{ "ccc" }
+
+=begin original
+
+you can write just
+
+=end original
+
+の代わりに以下のように書けて:
+
+ $array{ aaa }{ bbb }{ ccc }
+
+=begin original
+
+and not worry about whether the subscripts are reserved words. In the
+rare event that you do wish to do something like
+
+=end original
+
+そして添え字が予約語であるかどうかを心配することはありません。
+以下のようなことがしたいという珍しい場合には:
+
+ $array{ shift }
+
+=begin original
+
+you can force interpretation as a reserved word by adding anything that
+makes it more than a bareword:
+
+=end original
+
+裸の単語でないようにさせる何かを追加することで、予約語であるように
+強制的に解釈させることができます:
+
+ $array{ shift() }
+ $array{ +shift }
+ $array{ shift @_ }
+
+=begin original
+
+The C<use warnings> pragma or the B<-w> switch will warn you if it
+interprets a reserved word as a string.
+But it will no longer warn you about using lowercase words, because the
+string is effectively quoted.
+
+=end original
+
+C<use warnings> プラグマや B<-w> スイッチは文字列が予約語として
+解釈されたときには警告を発します。
+しかし、あなたが小文字だけからなる単語を使った場合にはもはや警告されません。
+なぜなら文字列は事実上クォートされているからです。
+
+=head2 Pseudo-hashes: Using an array as a hash
+X<pseudo-hash> X<pseudo hash> X<pseudohash>
+
+(擬似ハッシュ: 配列をハッシュとして使う)
+
+=begin original
+
+Pseudo-hashes have been removed from Perl. The 'fields' pragma
+remains available.
+
+=end original
+
+疑似ハッシュは Perl から削除されました。
+'fields' プラグマはまだ利用可能です。
+
+=head2 Function Templates
+X<scope, lexical> X<closure> X<lexical> X<lexical scope>
+X<subroutine, nested> X<sub, nested> X<subroutine, local> X<sub, local>
+
+(関数テンプレート)
+
+=begin original
+
+As explained above, an anonymous function with access to the lexical
+variables visible when that function was compiled, creates a closure. It
+retains access to those variables even though it doesn't get run until
+later, such as in a signal handler or a Tk callback.
+
+=end original
+
+先に説明したように、関数がコンパイルされたときに可視なレキシカル変数に
+アクセスする無名関数はクロージャを作ります。
+そういった変数に対するアクセスは、シグナルハンドラや Tk の
+コールバックのように、あとで実行されるときまで保持されてきた値を
+取り出します。
+
+=begin original
+
+Using a closure as a function template allows us to generate many functions
+that act similarly. Suppose you wanted functions named after the colors
+that generated HTML font changes for the various colors:
+
+=end original
+
+関数テンプレートとしてクロージャを使うことによって、同じような関数を
+たくさん作ることが可能になります。
+ここで、あなたが様々な色のためにフォントを変更する HTML を生成するような
+色の名前のついた関数を必要としているとしましょう:
+
+ print "Be ", red("careful"), "with that ", green("light");
+
+=begin original
+
+The red() and green() functions would be similar. To create these,
+we'll assign a closure to a typeglob of the name of the function we're
+trying to build.
+
+=end original
+
+red() と green() といった関数は似通ったものになります。
+これらを作り出すために、作ろうとしている関数の名前の型グロブに
+クロージャを代入します。
+
+ @colors = qw(red blue green yellow orange purple violet);
+ for my $name (@colors) {
+ no strict 'refs'; # allow symbol table manipulation
+ *$name = *{uc $name} = sub { "<FONT COLOR='$name'>@_</FONT>" };
+ }
+
+=begin original
+
+Now all those different functions appear to exist independently. You can
+call red(), RED(), blue(), BLUE(), green(), etc. This technique saves on
+both compile time and memory use, and is less error-prone as well, since
+syntax checks happen at compile time. It's critical that any variables in
+the anonymous subroutine be lexicals in order to create a proper closure.
+That's the reasons for the C<my> on the loop iteration variable.
+
+=end original
+
+これで、それぞれの関数が別個に作成されます。
+red(), RED(), blue(), BLUE(), green() のように呼び出すことが可能です。
+このテクニックはコンパイル時間とメモリーの使用量を抑え、
+またエラーを少なくします;
+なぜなら、構文チェックはコンパイル時に行われるからです。
+適切なクロージャを作成するために、無名サブルーチンにある変数はすべて
+レキシカルであることが重要です。
+これはループの繰り返し変数に対する C<my> の理由と同じです。
+
+=begin original
+
+This is one of the only places where giving a prototype to a closure makes
+much sense. If you wanted to impose scalar context on the arguments of
+these functions (probably not a wise idea for this particular example),
+you could have written it this way instead:
+
+=end original
+
+これはクロージャにプロトタイプを与えるための場所の一つでもあります。
+生成する関数の引数にスカラコンテキストを与えようとするなら
+(おそらくはこの例に関してはあまり賢いやり方ではないでしょう)、
+代わりに以下のように記述できます:
+
+ *$name = sub ($) { "<FONT COLOR='$name'>$_[0]</FONT>" };
+
+=begin original
+
+However, since prototype checking happens at compile time, the assignment
+above happens too late to be of much use. You could address this by
+putting the whole loop of assignments within a BEGIN block, forcing it
+to occur during compilation.
+
+=end original
+
+しかしながら、プロトタイプの検査はコンパイル時に行われるので、
+この代入文はプロトタイプを使うには遅すぎるのです。
+代入文のループ全体を BEGIN ブロックに置いてすべてを
+コンパイル時に行うようにすることでこれに対処することができます。
+
+=begin original
+
+Access to lexicals that change over time--like those in the C<for> loop
+above, basically aliases to elements from the surrounding lexical scopes--
+only works with anonymous subs, not with named subroutines. Generally
+said, named subroutines do not nest properly and should only be declared
+in the main package scope.
+
+=end original
+
+時間によって変わるようなレキシカル変数に対するアクセス -- 例えば先の例の
+C<for> ループのように、基本的に取り囲むレキシカルスコープからの
+要素への別名 -- は無名サブルーチンにおいてのみ動作し、
+名前付きサブルーチンでは動作しません。
+一般的に言うと、名前付きサブルーチンは適切にネストすることはなく、
+main パッケージスコープ内でのみ宣言されるべきです。
+
+=begin original
+
+This is because named subroutines are created at compile time so their
+lexical variables get assigned to the parent lexicals from the first
+execution of the parent block. If a parent scope is entered a second
+time, its lexicals are created again, while the nested subs still
+reference the old ones.
+
+=end original
+
+これは、名前つきのサブルーチンはコンパイル時に一度だけ作成されるので、
+そのレキシカル変数は、親ブロックの最初の実行時から親レキシカルに
+代入されるからです。
+親スコープに 2 回目に入ると、レキシカルは再作成される一方、
+ネストしたサブルーチンは古いものを参照したままです。
+
+
+=begin original
+
+Anonymous subroutines get to capture each time you execute the C<sub>
+operator, as they are created on the fly. If you are accustomed to using
+nested subroutines in other programming languages with their own private
+variables, you'll have to work at it a bit in Perl. The intuitive coding
+of this type of thing incurs mysterious warnings about "will not stay
+shared" due to the reasons explained above.
+For example, this won't work:
+
+=end original
+
+無名サブルーチンは、'sub' 演算子が実行され、その場で作成される毎に
+捕捉されます。
+他のプログラミング言語にあるような、固有のプライベート変数を持った
+ネストしたサブルーチンを使いたいのであれば、Perl ではちょっと
+手間がかかります。
+直感的にこうだと思うようなコーディングは、上述の理由により不可思議な警告
+"will not stay shared" となるでしょう。
+例を挙げると、以下の例はうまく動作しません:
+
+ sub outer {
+ my $x = $_[0] + 35;
+ sub inner { return $x * 19 } # WRONG
+ return $x + inner();
+ }
+
+=begin original
+
+A work-around is the following:
+
+=end original
+
+以下のようにするとうまくいきます:
+
+ sub outer {
+ my $x = $_[0] + 35;
+ local *inner = sub { return $x * 19 };
+ return $x + inner();
+ }
+
+=begin original
+
+Now inner() can only be called from within outer(), because of the
+temporary assignments of the anonymous subroutine. But when it does,
+it has normal access to the lexical variable $x from the scope of
+outer() at the time outer is invoked.
+
+=end original
+
+これで、inner() は outer() の中からのみ呼び出せるようになります。
+なぜなら、無名サブルーチンの一時変数に対する代入があるからです。
+しかしこれを行ったとき、outer() が起動するときの outer() のスコープから
+レキシカル変数 $x のアクセスは通常通りです。
+
+=begin original
+
+This has the interesting effect of creating a function local to another
+function, something not normally supported in Perl.
+
+=end original
+
+これは、通常 Perl ではサポートされていないような、
+ある関数にローカルな関数を生成するときの興味深い効果です。
+
+=head1 WARNING
+X<reference, string context> X<reference, use as hash key>
+
+(警告)
+
+=begin original
+
+You may not (usefully) use a reference as the key to a hash. It will be
+converted into a string:
+
+=end original
+
+リファレンスをハッシュに対するキーとして使うことは(普通は)できません。
+それは文字列へ変換されてしまいます:
+
+ $x{ \$a } = $a;
+
+=begin original
+
+If you try to dereference the key, it won't do a hard dereference, and
+you won't accomplish what you're attempting. You might want to do something
+more like
+
+=end original
+
+キーをデリファレンスしようとするのであれば、それは
+ハードリファレンスには働かｒず、
+そして、あなたがしようとしたことはできないでしょう。
+次のような書き方をしたいと思うかもしれません
+
+ $r = \@a;
+ $x{ $r } = $r;
+
+=begin original
+
+And then at least you can use the values(), which will be
+real refs, instead of the keys(), which won't.
+
+=end original
+
+動作しない keys() の代わりに、少なくとも本当のリファレンスとなる
+values() を使うことができます。
+
+=begin original
+
+The standard Tie::RefHash module provides a convenient workaround to this.
+
+=end original
+
+標準モジュール Tie::RefHash はこれを扱いやすくするための
+手段を提供しています。
+
+=head1 SEE ALSO
+
+=begin original
+
+Besides the obvious documents, source code can be instructive.
+Some pathological examples of the use of references can be found
+in the F<t/op/ref.t> regression test in the Perl source directory.
+
+=end original
+
+ドキュメントの他に、ソースコードもためになります。
+幾つかのリファレンスを使っている病理学的なサンプルは Perl の
+ソースディレクトリにある F<t/op/ref.t> という退行テストにあります。
+
+=begin original
+
+See also L<perldsc> and L<perllol> for how to use references to create
+complex data structures, and L<perltoot>, L<perlobj>, and L<perlbot>
+for how to use them to create objects.
+
+=end original
+
+複雑なデータ構造を生成するためのリファレンスの使い方は
+L<perldsc> と L<perllol> を参照してください。
+オブジェクトを生成するためのリファレンスの使い方は
+L<perltoot>、L<perlobj>、L<perlbot> を参照してください。
+
+=begin meta
+
+Created: KIMURA Koichi (5.005)
+Updated: Kentaro Shirakata <argra****@ub32*****> (5.8.8-)
+
+=end meta
+