Chapter 8, Sections 1+2 translated

Section 1: Literals
Section 2: Methods
This is a first draft of a translation which still needs editing

Author: skra

chapter08.textile

@@ -135,15 +135,13 @@ and takes everything until the ending `"`. Here documents start
 at the line after a `<<EOS` and end at the line before the ending `EOS`.
 
 <pre class="emlist">
-&quot;<span class="ami">All characters between starting and end character are in the string</span>&quot;
 
 <<EOS
-<span class="ami">All lines between the starting and
+All lines between the starting and
 the ending line are in this 
-here document</span>
+here document
 EOS
 </pre>
-The half toned part is a here document.
 Here we used `EOS` as identifier but any word is fine.
 Precisely speaking all the character matching `[a-zA-Z_0-9]` can be used.
 
@@ -206,7 +204,7 @@ backslash notation can be used in a normal here document.
 There does not seem to be a difference anymore to a double quote enclosed
 here document.)
 
-h3. characters
+h3. Characters
 
 Ruby strings are byte strings, there are no character objects.
 Instead there are the following expressions which return the 
@@ -222,7 +220,7 @@ integers which correspond a certain character in ASCII code.
 (Translator's note: Strings in Ruby 1.9 are not byte strings anymore,
 they have an attached encoding. `?a` returns the string `"a"` in Ruby1.9)
 
-h3. Regular expressions
+h3. Regular Expressions
 
 <pre class="emlist">
 /regexp/
@@ -361,11 +359,8 @@ arbitrary objects. The following expressions generate a table.
 </pre>
 
 We explained hashes in detail in the third chapter "Names and 
-Nametables". 
-
-ハッシュについては第3章『名前と名前表』で詳しく説明した。ハッシュ値によっ
-て記憶スロットを分散させる高速な検索テーブルである。Ruby言語の構文と
-してはキー・値ともに任意の式を使えるのが特徴だ。
+Nametables". They are fast lookup tables which allocate memory slots depending 
+on the hash value(?). In Ruby grammar the key value can be an arbitrary expression.
 
 Furthermore inside a method call the braces can be omitted.
 
@@ -381,8 +376,8 @@ button.set_geometry('x' => 80, 'y' => '240')
 </pre>
 
 Of course in this case `set_geometry` must accept a hash as input.
-本物のキーワード引数なら言語がパラメータ変数に変換し
-てくれるものだが、こちらはあくまで「もどき」なのでそうはいかない。
+Real keyword arguments will be transformed into parameter variables, though.
+With a passed hash it is not quite the real thing.
 
 h3. Ranges
 
@@ -599,36 +594,34 @@ list = [1, 2, 3]
 delegate(*list)   # identical to delegate(1, 2, 3)
 </pre>
 
-
-このように配列を引数として分配することができる。
-この機能を「`*`引数」と呼んでおくことにしよう。
-ここではわかりやすいようにローカル変数経由で示したが、もちろん
-そんな制限はない。リテラルやメソッド呼び出しなども直接置ける。
+In this way we can distribute an array into arguments.
+We call this device a `*`argument. Here we used a local variable
+for demonstration, but of course there is no limitation.
+We can also directly put a literal or a method call instead.
 
 <pre class="emlist">
-m(*[1,2,3])    # これは最初から展開して書けばいいのだが……
+m(*[1,2,3])    # We could have written the expanded form in the first place...
 m(*mcall())
 </pre>
 
-`*`引数を普通の引数と混ぜることもできるが、
-必ず普通の引数より後に書かないといけない。
-パラメータ変数との対応が一意に定まらなくなるからだ。
+The @*@ argument can be used together with ordinary arguments,
+but the @*@ argument must come last.
 
-定義のときはその逆に、不定個の引数を配列としてまとめて受けることが
-できる。パラメータ変数の前に`*`をつければいい。
+In the definition on the other hand we can handle the arguments in 
+bulk when we put a `*` in front of the parameter variable.
 
 <pre class="emlist">
 def some_method( *args )
   p args
 end
 
-some_method()          # []と表示される
-some_method(0)         # [0]と表示される
-some_method(0, 1)      # [0,1]と表示される
+some_method()          # prints []
+some_method(0)         # prints [0]
+some_method(0, 1)      # prints [0,1]
 </pre>
 
-このように、余った引数を配列にまとめてくれる。`*`パラメータは一つしか宣
-言できず、またデフォルト付き引数よりも後に置かなければならない。
+The surplus arguments are gathered in an array. Only one `*`parameter
+can be declared. It must also come after the default arguments.
 
 <pre class="emlist">
 def some_method0( arg, *rest )
@@ -637,9 +630,9 @@ def some_method1( arg, darg = nil, *rest )
 end
 </pre>
 
-リストの展開とまとめ受けの機能を併用すれば、メソッドの引数を別のメソッ
-ドにそっくりそのまま引き渡すこともできる。`*`パラメータの一番便利な使
-いかたかもしれない。
+If we combine list expansion and bulk reception together, the arguments
+of one method can be passed as a whole to another method. This might
+be the most practical use of the `*`parameter.
 
 <pre class="emlist">
 # a method which passes its arguments to other_method
@@ -657,11 +650,12 @@ delegate(10, 20, 30)   # same as other_method(10, 20, 30)
 
 h3. Various Method Call Expressions
 
-機能が「メソッド呼び出し」というただ一つだけだからといって、その表現も
-一つでなければいけないという必然性はない。巷で言う
-シンタックスシュガー(syntax sugar)である。
-Rubyはそのシンタックスシュガーがてんこもりで、
-パーサフェチにはたまらない。例えば次の例は全てメソッド呼び出しである。
+There is only one mechanism for 'method call', but there still
+can be several representations of the same mechanism. This is 
+colloquially called syntactic sugar.
+
+In Ruby there is a ton of it, the parser fetch becomes unbearable (?).
+For instance the examples below are all method calls.
 
 <pre class="emlist">
 1 + 2                   # 1.+(2)
@@ -673,9 +667,9 @@ obj[k] = v              # obj.[]=(k,v)
 `cvs diff abstract.rd`  # Kernel.`('cvs diff abstract.rd')
 </pre>
 
-慣れるまでは信じ難いと思うが、「`attr=`」「`[]=`」「```」などが(本当
-に)メソッド名なのである。メソッド定義の名前欄にも書けるし、シンボルと
-して使うこともできる。
+It's hard to believe until you get used to it, but `attr=`, `[]=`, `\``
+are all names of methods. They can appear as names in a method definition
+and can also be used as symbols.
 
 <pre class="emlist">
 class C
@@ -689,35 +683,38 @@ p(:[]=)
 p(:`)
 </pre>
 
-しかし甘いものなんて大嫌いだという人がよくいるのと同じで、シンタックス
-シュガーが嫌いな人も多いようだ。たぶん、本質的な意味が一つであるものを
-見ためで胡麻化すのは卑怯な感じがするからだろう(みんな生真面目だね)。
+There are people who don't like sweets and there are people who
+hate syntactic sugar. Maybe because one cannot tell by the looks
+that it's really the same thing. It feels like a deception.
+(Why's everyone so serious?)
 
-以下、もう少し詳しく見ていく。
+Let's see some more details.
 
-h4. 記号付き
+h4. Symbol Appendices
 
 <pre class="emlist">
 obj.name?
 obj.name!
 </pre>
 
-最初はギャップの小さいものから。これは単に名前の最後に`?`や`!`が付けられる
-だけ。呼ぶときと定義するときの見ために違いがないのであまり苦労しない。
-それぞれ「これこれこういうメソッドを定義するときに使おう」という約束事
-はあるが、それはあくまで人間レベルの約束事であって言語規約ではない。
-このへんは手続き名に多彩な文字が使えるLisp系言語の影響だろう。
+First a small thing. It's just appending a `?` or a `!`. Call and Definition
+do not differ, so it's not too painful. There are convention for what
+to use these method names, but there is no enforcement on language level.
+It's just a convention.
+These method names are probably an influence from Lisp which has a great variety
+of function names.
 
-h4. Dyadic Operators
+h4. Binary Operators
 
 <pre class="emlist">
 1 + 2    # 1.+(2)
 </pre>
 
-二項演算子型。左辺のオブジェクトに対するメソッド呼び出しに変換される。
-この例ならば`1`のメソッド`+`が呼ばれる。種類は以下に示すようにかなり多
-い。`+`や`-`のような一般的な演算子から「等価」の`==`、Perl風の`<=>`な
-んてものまで、盛り沢山だ。優先順位の高い順に並べる。
+Binary Operators will be converted to a method call to the object on the
+left hand side. Here the method `+` from the object `1` is called.
+As listed below there are many of them. There are the general operators
+`+` and `-`, also the equivalence operator `==` and the spaceship operator
+`<=>' as in Perl, all sorts. They are listed in order of their precedence.
 
 <pre class="emlist">
 **
@@ -730,8 +727,8 @@ h4. Dyadic Operators
 <=> == === =~
 </pre>
 
-記号一つの`&`、`|`はメソッドだが二つになった`&&`と`||`は組み込み
-演算子である。Cでの使われかたを思いだすといい。
+The symbols `&` and `|` are methods, but the double symbols `&&` and `||`
+are built-in operators. Remember how it is in C.
 
 h4. Unary Operators
 
@@ -757,27 +754,25 @@ obj.attr = val   # attr=(val)
 </pre>
 
 This is an attribute assignment statement. The above will be translated
-into the method call `attr=`
-属性代入型。上記の呼び出しは`attr=`という名前のメソッド呼び出しに変換さ
-れる。括弧を省略したメソッド呼び出しと併用すれば、以下のように
-いかにも属性アクセスのようなふりをしたコードを書くこともできる。
+into the method call `attr=`. When using this together with method calls whose
+parantheses are omitted, we can write code which looks like attribute access.
 
 <pre class="emlist">
 class C
-  def i() @i end          # 実は定義は一行に書けたりする
+  def i() @i end          # We can write the definition in one line
   def i=(n) @i = n end
 end
 
 c = C.new
 c.i = 99
-p c.i    # 99と表示される
+p c.i    # prints 99
 </pre>
 
-しかし実はどちらもメソッド呼び出しというわけだ。
-Delphiのget/set propertyやCLOSのスロットアクセサの仕組みと似ている。
+However both are method calls.
+They are similar to get/set property in Delphi or slot accessors in CLOS.
 
-ちなみに、`obj.attr(arg)=`のように引数を取りつつ代入形式、という
-メソッドは定義できない。
+Besides, we cannot define a attribute assignment which takes an argument like 
+`obj.attr(arg)=`.
 
 h4. Index Notation
 
@@ -796,10 +791,11 @@ When assigning to an index the `[]=` method is used.
 
 h3. `super`
 
-メソッドを単に置き換えるのではなく、既存のメソッドの動作に少し他の
-ことを追加したい、ということはそれなりによくあるわけだ。そこでオーバー
-ライドしつつもスーパークラスのメソッドを呼び出す仕組みが必要になる。
-Rubyでは`super`がソレだ。
+Often we don't want to replace a method, but we want to add a little
+bit to the behaviour of an already existing method. Here it becomes
+necessary to not just overwrite the method in the superclass but 
+to also call the method in the superclass.
+That's what Ruby's `super` is for.
 
 <pre class="emlist">
 class A
@@ -809,17 +805,18 @@ class A
 end
 class B < A
   def test
-    super   # A#testを起動する
+    super   # launches A#test
   end
 end
 </pre>
 
-Rubyの`super`はC++やJavaとは違い、これ一語で「スーパークラスの同名のメソッ
-ドを呼ぶ」という意味である。ちなみに`super`は予約語だ。
+Ruby's `super differs from the one in C++ or Java. This one here
+calls the method with the same name in the superclass.
+In other words `super` is a reserved word.
 
-また`super`を扱うときは「引数ゼロの`super`」と「引数を省略した`super`」の違
-いに注意してほしい。引数を省略した`super`はメソッドのパラメータ変数を
-そのまま渡すようになる。
+When using super be careful about the difference between the difference
+of the zero arguments `super` and the omitted arguments `super.
+The super with omitted arguments passes all the parameter variables.
 
 <pre class="emlist">
 class A
@@ -830,11 +827,11 @@ end
 
 class B < A
   def test( a, b, c )
-    # 引数ゼロの super
-    super()    # []と表示される
+    # super with no arguments
+    super()    # shows []
 
-    # 引数を省略した super。super(a, b, c) と同じ効果
-    super      # [1, 2, 3]と表示される
+    # super with omitted arguments. Same result as super(a, b, c)
+    super      # shows [1, 2, 3]
   end
 end
 
@@ -884,33 +881,36 @@ end
 Here `public`, `private` and `protected are method calls without
 parentheses. These aren't reserved words.
 
-
-また`public`や`private`を引数付きで使うと特定のメソッドの可視性だけを
-変えることもできる。が、こちらの使いかたは仕組みが面白くないので省略。
+`public` and `private` can also be used with an argument to set
+the visibility of a particular method. But that's not really relevant.
+We'll leave this out.
 
 h4. Module functions
 
-モジュール`M`があったときに全く同じ内容で
+Given a module 'M'. If there are two methods with the exact same
+content
 
 * `M.method_name`
-* `M#method_name`(可視性は`private`)
+* `M#method_name`(Visibility is `private`)
+
 
-の両方が定義されている場合にそれをモジュール関数と呼ぶ。
+then we call this a module function.
 
-とは言えこの定義を聞いても存在価値がわからないと思う。使って嬉しい例を
-見るとわかりやすい。
+It is not apparent why this should be useful. But let's look
+at the next example which is happily used.
 
 <pre class="emlist">
-Math.sin(5)       # 数回使うだけならこちらのほうが楽で独立性も高い
+Math.sin(5)       # If used for a few times this is more convenient
 
 include Math
-sin(5)            # 何度も使うならこちらのほうが便利
+sin(5)            # If used more often this is more practical
 </pre>
 
-両方のメソッドが同じ内容、というところがポイントだ。`self`が違うのに一つ
-のコードで同じ動きをするということは、インスタンス変数が非常に使いにく
-いはずである。従ってそのようなメソッドは(`sin`のように)手続きだけを記
-述したメソッドである可能性が高い。だからモジュール「関数」と呼ぶのだ。
+It's important that both functions have the same content.
+With a different `self` but with the same code the behavior should 
+still be the same. Instance variables become extremely difficult to use.
+Hence these methods are probably only used
+for procedures like `sin`. That's why they are called module functions.
 
 h2. Iterators