ruby-japanize

日本語の別名や構文を定義してRubyを日本語で書けるようにする。

導入方法

Gemfileに次の行を追加します。

gem 'ruby-japanize'

そして次のコマンドを実行します。

$ bundle

または次のようにします。

$ gem install ruby-japanize

なぜRubyを日本語化しようと思ったのかについて

Rubyを日本語化しようと思ったきっかけは二つあります。一つはRubyの識別子 (変数名やメソッド名)にUTF-8が使えるため、その気になれば日本語だけで Rubyのスクリプトを書けるのではないかと思いついたことです。唯一、クラス名(≒定数名)はアルファベットの大文字で始まる必要があるため単純に日本語化できないのですが、試しにプロトタイプを作ってみたところちょっとした制限と工夫でなんとかなりそうだという感触を得ました。

もう一つのきっかけは、日本語で実用的なプログラミングを表現し切ることは、はたして可能なのだろうかと疑問に思ったことです。現在、Rubyを含む一般に広く普及している実用的なプログラミング言語は英語がベースになっていると言っていいと思います。日本語ベースのプログラミング言語も無くはないようですが、実用言語として広く普及しているとは言いがたい状況でしょう。Ruby を実用言語たらしめている要素は大きく二つあると思っていて、一つは見ために分かりやすい構文で、もう一つは豊富なクラスライブラリ(≒語彙)です。実用的なプログラミングのためには特に後者が重要だと個人的には思っていて、 Rubyは英語ベースなのでRubyが持つ語彙もすべて英語で表現されているわけで、日本語で実用的なプログラミングをするためにはこの語彙をすべて日本語で表現し切る必要があるのですが、はたしてそんなことは本当に可能なのでしょうか？

この疑問を解くためには、実際に作ってみるのが手っ取り早いということで、作ってみたのがこのgemです。

日本語化の基本方針

スクリプトエンコーディングはUTF-8で統一する。
外付けのライブラリにまで手を出すときりがないので、日本語化の範囲は組み込みライブラリまでにする。
Test::Unitはテストのために使うので例外的に日本語化の対象とする。
ファイル名は日本語化しない。(本当は日本語化したかったけど、環境によってファイル名の文字符号化方式が異なるとバイト表現が変わるため、ファイル名の日本語化はあきらめました)
演算子や記号などの英語でない名前は日本語化しない。

日本語の命名規則

カタカナ語はできるだけ使わない。どうしても日本語に該当する概念や言葉が無いときだけカタカナを使う。
よく使うメソッドは短く簡潔な名前にする。
使用頻度が低いメソッドや注意深く使う必要があるメソッドは冗長で分かりやすい名前にする。
述語メソッド(〜?)の名前は原則として〜か?で終わらせる。
述語メソッドにおける「が」と「は」の使い分け
- 述語メソッドがレシーバの状態を表すときは〜が〜か?とする。
- 述語メソッドが引数の状態を表すときは〜は〜か?とする。

日本語で書いたRubyスクリプトの例

https://www.ruby-lang.org/ja/about/に掲載されているRubyスクリプトを日本語で書いてみた例を以下に掲載しています。またRubyのソースコードに付属するサンプルを日本語で書き直した例が sampleにあります。

すべてがオブジェクト

元のRubyスクリプトの例:

5.times { print "We *love* Ruby -- it's outrageous!" }

日本語で書いたRubyスクリプトの例:

5.回{ 印字 "みんなRubyが*大好き* -- Rubyはすごいぜ!" }

Rubyの柔軟性

元のRubyスクリプトの例:

class Numeric
  def plus(x)
    self.+(x)
  end
end

y = 5.plus 6
# y は 11 になります

日本語で書いたRubyスクリプトの例:

組(数値) {
  定義(:足す) {|他の数|
    自分.+(他の数)
  }
}

ある数 = 5.足す 6
# ある数 は 11 になります

ブロック: 表現力豊かな機能

元のRubyスクリプトの例:

search_engines =
  %w[Google Yahoo MSN].map do |engine|
    "http://www." + engine.downcase + ".com"
  end

日本語で書いたRubyスクリプトの例:

検索エンジン =
  %w[Google Yahoo MSN].対応させる{|エンジン|
    "http://www." + エンジン.小文字にする + ".com"
  }

RubyとMixin

元のRubyスクリプトの例:

class MyArray
  include Enumerable
end

日本語で書いたRubyスクリプトの例:

組(:私家版の配列) {
  付加 列挙できる
}

日本語のRubyスクリプトの書き方

日本語の有効化

スクリプトエンコーディングをUTF-8に設定し、Rubyスクリプトの先頭で ruby-japanizeをrequireします。

# -*- coding: utf-8 -*-

require 'japanize'

元のRubyに日本語の定義を追加するだけなので、日本語で書くRubyスクリプトは日本語化していない通常のRubyスクリプトと共存できます。

日本語の変数と定数

ローカル変数(局所変数)、グローバル変数(大域変数)、インスタンス変数(生成物の変数)は特に何もしなくても普通に日本語が使えます。これはRubyの元々の機能です。

クラス変数は残念ながら日本語で書いたRubyスクリプトから使うことができません。これはクラス変数がレキシカルスコープと結び付いているのでメタプログラミングで実現している日本語の機能から参照できないためです。

日本語の定数

Rubyの定数はアルファベットの大文字で始まる規則になっています。日本語には一般的に大文字や小文字の概念がないので、そのままでは日本語で定数を定義できません。そこで定数の代わりに日本語のクラスメソッド/モジュールメソッドを使うことにしました。このため定数の定義や参照の仕方が元のRubyスクリプトと異なるので注意してください。

定数の定義

日本語の定数で定数を定義します。トップレベル(最上位)およびクラス(組)/モジュール(部)のスコープで使えます。

元のRubyスクリプトの例:

FOO = 'FOO'

class Foo
  BAR = 'BAR'

  class Bar
    BAZ = 'BAZ'
  end
end

日本語で書いたRubyスクリプトの例:

日本語の定数 :イ, 'イ'

組(:甲) {                       # 日本語のクラス定義
  日本語の定数 :ロ, 'ロ'

  組(:乙) {
    日本語の定数 :ハ, 'ハ'
  }
}

定数の参照

日本語の定数は実際はメソッド(操作)で定義されているため、self(自分) を意識して参照する必要があります。

元のRubyスクリプトの例:

p FOO
p Foo::BAR
p Foo::Bar::BAZ

class Foo
  p FOO                         # 最上位の定数はどこからでも参照できる
  p BAR                         # 自クラスの定数を参照できる

  def foo
    p FOO                       # 最上位の定数はどこからでも参照できる
    p BAR                       # 自クラスの定数をメソッド(操作)から参照できる
  end

  class Bar
    p FOO                       # 最上位の定数はどこからでも参照できる
    p BAR                       # 外側の定数を内側から参照できる
    p BAZ                       # 自クラスの定数を参照できる

    def bar
      p FOO                     # 最上位の定数はどこからでも参照できる
      p BAR                     # 外側の定数を内側から参照できる
      p BAZ                     # 自クラスの定数をメソッド(操作)から参照できる
    end
  end
end

日本語で書いたRubyスクリプトの例:

点検 イ                         # 点検はpの日本語版
点検 甲::ロ
点検 甲::乙::ハ

組(甲) {
  点検 イ                       # 最上位の日本語定数はどこからでも参照できる
  点検 ロ                       # 自クラスの日本語定数は参照できる

  定義(:ある操作) {             # 日本語のメソッド定義
    点検 イ                     # 最上位の日本語定数はどこからでも参照できる
    点検 生成元::ロ             # self(自分)が異なるので日本語定数に生成元(self.classの日本語版)を付ける必要がある
    点検 ロ                     # これは失敗する
  }

  組(乙) {
    点検 イ                     # 最上位の日本語定数はどこからでも参照できる
    点検 ::JA::甲::ロ           # 自クラス以外の日本語定数は最上位(::JA)から参照する、通常の定数のように内側から参照することはできない
    点検 ハ                     # 自クラスの日本語定数は参照できる

    定義(:ある操作) {
      点検 イ                   # 最上位の日本語定数はどこからでも参照できる
      点検 ::JA::甲::ロ         # 自クラス以外の日本語定数は最上位(::JA)から参照する
      点検 生成元::ハ           # self(自分)が異なるので日本語定数に生成元(self.classの日本語版)を付ける必要がある
    }
  }
}

定数のinclude(付加)

モジュール(部)の定数はinclude(付加)した先で参照できますが、日本語の定数はモジュールメソッドになるためincludeした先で参照できません。

日本語の定数を付加できることを宣言すると日本語の定数もincludeした先で参照できるようになります。

元のRubyスクリプトの例:

module Foo
  FOO = 'FOO'
end

class Bar
  include Foo

  p FOO                         # includeした先で参照できる

  def bar
    p FOO
  end
end

日本語で書いたRubyスクリプトの例:

部(:甲) {                       # 日本語のモジュール定義
  日本語の定数 :イ, 'イ'
  日本語の定数 :ロ, 'ロ'

  日本語の定数を付加できること :イ
}

組(:乙) {
  付加 甲                       # 日本語のinclude宣言

  点検 イ                       # 付加できると宣言したので参照できる

  定義(:丙) {
    点検 生成元::イ
  }

  点検 ロ                       # 付加できると宣言してないので失敗する
}

日本語の制御構造

肯否分岐

if文に相当する制御構造

元のRubyスクリプトの例:

if (age >= 12) then
  print "adult fee\n"
else
  print "child fee\n"
end

gender = if (foo.gender == "male") then "male" else "female" end

日本語で書いたRubyスクリプトの例:

この条件が{ 年齢 >= 12 }.であるなら{
  印字 "大人料金\n"
}.でなければ{
  印字 "子供料金\n"
}.である

性別 = この条件が{ 甲.性別 == "男性" }.であるなら{ "男性" }.でなければ{ "女性" }.である

文法:

この条件が{ 式 }.であるなら{
  式 ...
[}.この条件が{ 式 }.であるなら{
  式 ... ]
...
[}.でなければ{
  式 ... ]
}.である

unless文に相当する制御構造

元のRubyスクリプトの例:

unless (baby?) then
  feed_meat
else
  feed_milk
end

日本語で書いたRubyスクリプトの例:

この条件が{ 赤ちゃんか? }.でなければ{
  肉を食べさせる
}.であるなら{
  ミルクを飲ませる
}.である

文法:

この条件が{ 式 }.でなければ{
  式 ...
[}.であるなら{
  式 ... ]
}.である

条件分岐

case文に相当する制御構造

元のRubyスクリプトの例:

case (age)
when 0..2
  "baby"
when 3..6
  "little child"
when 7..12
  "child"
when 13..18
  "youth"
else
  "adult"
end

日本語で書いたRubyスクリプトの例:

この値が{
  年齢
}.もし{ 0..2 }.であるなら{
  "赤ちゃん"
}.もし{ 3..6 }.であるなら{
  "幼児"
}.もし{ 7..12 }.であるなら{
  "子供"
}.もし{ 13..18 }.であるなら{
  "若者"
}.でなければ{
  "大人"
}.である

文法:

この値が{
  式
[}.もし{ 式 [}.か{ 式] ... }.であるなら{
  式... ]
...
[}.でなければ{
  式... ]
}.である

繰り返し

while文に相当する制御構造

元のRubyスクリプトの例:

ary = [ 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 ]
i = 0
while (i < ary.length)
  puts ary[i]
  i += 1
  # break, next, redo が使える
end

日本語で書いたRubyスクリプトの例:

一覧 = [ 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 ]
添字 = 0
この条件なら{ 添字 < 一覧.長さ }.繰り返す{ #|制御|
  行出力 一覧[添字]
  添字 += 1
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}

文法:

この条件なら{ 式 }.繰り返す{[|制御|]
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む]
  [制御.やり直す]
  式 ...
}

until文に相当する制御構造

元のRubyスクリプトの例:

until (f.eof?)
  print f.gets
  # break, next, redo が使える
end

日本語で書いたRubyスクリプトの例:

この条件まで{ あるファイル.終端か? }.繰り返す{ #|制御|
  印字 あるファイル.行を取得
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}

文法:

この条件まで{ 式 }.繰り返す{[|制御|]
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む]
  [制御.やり直す]
  式 ...
}

後置のwhile文に相当する制御構造

元のRubyスクリプトの例:

send_request(data)
begin
  res = get_response()
  # break, next, redo が使える
end while (res == 'Continue')

日本語で書いたRubyスクリプトの例:

要求を送信(情報)
繰り返す{ #|制御|
  結果 = 応答を取得()
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}.この条件なら{ 結果 == '継続' }

文法:

繰り返す{[|制御|]
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む]
  [制御.やり直す]
  式 ...
}.この条件なら{ 式 }

後置のuntil文に相当する制御構造

元のRubyスクリプトの例:

send_request(data)
begin
  res = get_response()
  # break, next, redo が使える
end until (res == 'OK')

日本語で書いたRubyスクリプト例:

要求を送信(情報)
繰り返す{ #|制御|
  結果 = 応答を取得()
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}.この条件まで{ 結果 == '完了' }

文法:

繰り返す{[|制御|]
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む]
  [制御.やり直す]
  式 ...
}.この条件まで{ 式 }

for文に相当する制御構造

for文に相当する繰り返しを実行するには、eachメソッド(操作)の日本語の別名である個別にメソッドを使います。繰り返しを日本語で制御 (break/next/redo)する場合は繰り返すメソッドを使います。 個別にメソッドが列挙(Enumerator)を返す場合に繰り返すメソッドが使えます。また繰り返すメソッドは個別にメソッドに限らず列挙を返す全てのメソッドで使えます。

元のRubyスクリプトの例:

for i in [ 1, 2, 3 ]
  print i * 2, "\n"
  # break, next, redo が使える
end

日本語で書いたRubyスクリプトの例:

[ 1, 2, 3 ].個別に{|数|
  印字 数 * 2, "\n"
}

または

[ 1, 2, 3 ].個別に.繰り返す{|制御, 数|
  印字 数 * 2, "\n"
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}

文法:

式.個別に{|引数 ...|
  式 ...
}

または

式.個別に.繰り返す{|制御[, 引数 ...]|
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む]
  [制御.やり直す]
  式 ...
}

例外処理

例外の発生

例外を発生させるにはraiseの別名である例外を発生を使います。

元のRubyスクリプトの例:

raise "you lose"                # 例外 RuntimeError を発生させる

# 以下の二つは SyntaxError を発生させる
raise SyntaxError, "invalid syntax"
raise SyntaxError.new("invalid syntax")

raise                           # 最後の例外の再発生

日本語で書いたRubyスクリプトの例:

例外を発生 "損失"               # 例外 実行時の失敗 (RuntimeError) を発生させる

# 以下の二つは 文法誤りのため失敗 (SyntaxError) を発生させる
例外を発生 文法誤りのため失敗, "文法が不正です"
例外を発生 文法誤りのため失敗.新規("文法が不正です")

例外を発生                      # 最後の例外を再発生

begin/endに相当する制御構造

元のRubyスクリプトの例:

begin
  do_something
rescue => e
  recover(e)
  # retry が使える
ensure
  must_to_do
end

日本語で書いたRubyスクリプトの例:

領域{|制御|
  制御.本処理{
    何かをする
  }
  制御.例外を補足{|発生した例外|
    復旧する(発生した例外)
    # 制御.やり直す が使える
  }
  制御.後始末{
    必ず実行する
  }
}

文法:

領域{|制御|
  制御.本処理{
    式 ...
    [制御.戻る [式[, 式] ...]]
    式 ...
  }
  [制御.例外を捕捉[(式[, 式] ...)] {|発生した例外|
    式 ...
    [制御.戻る [式[, 式] ...]]
    [制御.やり直す]
    式 ...
  }]
  ...
  [制御.例外が無い時{
    式 ...
    [制御.戻る [式[, 式] ...]]
    式 ...
  }]
  [制御.後始末{
    式 ...
  }]
}

日本語のクラス(組)/メソッド(操作)の定義

クラス(組)の定義

クラス(組)を定義するには組を使います。クラスの名前は記号(Symbol) で与えます。既に定義済みのクラスを再定義する時は、名前の代わりにクラスを返す式を与えてもかまいません。

元のRubyスクリプトの例:

class Foo < Super
  def test
    :
  end
    :
end

日本語で書いたRubyスクリプトの例:

組(:甲, 原型: 親) {
  定義(:試行) {
    :
  }
    :
}

文法:

組(記号または式[, 原型: 親クラス]) {
  式 ...
}

定義したクラス(組)の参照

記号で名前を与えてクラス(組)を定義した場合、そのクラスの名前の日本語の定数が定義されます。このため定義したクラスの名前で参照することができるようになります。

元のRubyスクリプトの例:

class Foo
end

p Foo

日本語で書いたRubyスクリプトの例:

組(:甲) {
}

点検 甲

特異クラス(特異組)の定義

特異クラス(特異組)を定義するには特異組を使います。特異組は 物(Object)が持つメソッド(操作)です。

元のRubyスクリプトの例:

obj = Object.new
class << obj
  def test
    :
  end
    :
end

日本語で書いたRubyスクリプトの例:

ある物 = 物.新規
ある物.特異組{
  定義(:試行) {
    :
  }
    :
}

文法:

式.特異組{
  式 ...
}

特異クラス(特異組)の参照

特異クラス(特異組)を参照するには特異組を使います。特異組は 物(Object)が持つメソッド(操作)です。

元のRubyスクリプトの例:

obj = Object.new
p obj.singleton_class

日本語で書いたRubyスクリプトの例:

ある物 = 物.新規
点検 ある物.特異組

モジュールの定義

モジュール(部)を定義するには部を使います。モジュールの名前は記号 (Symbol)で与えます。既に定義済みのモジュールを再定義する時は、名前の代わりにモジュールを返す式を与えてもかまいません。

元のRubyスクリプトの例:

module Foo
  def test
    :
  end
    :
end

日本語で書いたRubyスクリプトの例:

部(:甲) {
  定義(:試行) {
    :
  }
    :
}

文法:

部(記号または式) {
  式 ...
}

定義したモジュール(部)の参照

記号で名前を与えてモジュール(部)を定義した場合、そのモジュールの名前の日本語の定数が定義されます。このため定義したモジュールの名前で参照することができるようになります。

元のRubyスクリプトの例:

module Foo
end

p Foo

日本語で書いたRubyスクリプトの例:

部(:甲) {
}

点検 甲

メソッド(操作)の定義

メソッド(操作)を定義するにはdefine_methodの別名である定義を使います。

元のRubyスクリプトの例:

def fact(n)
  if (n == 1) then
    1
  else
    n * fact(n - 1)
  end
end

日本語で書いたRubyスクリプトの例:

定義(:階乗) {|数|
  もし条件が{ 数 == 1 }.であるなら{
    1
  }.でなければ{
    数 * 階乗(数 - 1)
  }.である
}

文法:

定義(記号) {[|引数 ...|]
  式 ...
}

ブロック(手続き)の実行

define_methodで定義したメソッド(操作)はyieldでブロック(手続き)を実行することができません。したがってdefine_methodの別名である定義で定義したメソッドも同様にyieldが使えません。

ブロックの実行はブロック引数を使ってください。

元のRubyスクリプトの例:

def foo
  if (block_given?) then
    yield(1, 2)
  end
end

日本語で書いたRubyスクリプトの例:

定義(:甲) {|&塊|
  # yield だけでなく block_given? も使えない
  もし条件が{ 塊.無値か? }.でなければ{
    塊[1, 2]
  }.である
}

return文に相当する制御構造

Rubyではメソッド(操作)から抜けるのにreturnを使いますが、returnは予約語なのでメソッド(操作)のように日本語の別名を定義することができません。日本語の制御構造でreturnと同様の動作を行うには、メソッドの内側で 領域を定義し領域から戻ることで実現します。

元のRubyスクリプトの例:

def foo
  return 1, 2, 3
end

日本語で書いたRubyスクリプトの例:

定義(:甲) {
  領域{|制御|
    制御.戻る 1, 2, 3
  }
}

文法:

定義(記号) {[|引数 ...|]
  領域{|制御|
    式 ...
    [制御.戻る [式[, 式] ...]]
    式 ...
  }
}

英語のメソッド(操作)の自動定義

Rubyのいくつかのメソッド(操作)はシステムと連係します。例えばオブジェクト(物)の状態をp(点検)するのにinspectの結果を使ったり、オブジェクトを文字列に変換するのにto_sを使ったりなどです。

そこで、これらの英語のメソッドを日本語でも定義できるようにしています。特定の名前の日本語のメソッドを定義すると、その日本語のメソッドを呼び出す英語のメソッドを自動的に定義するようになっています。

英語のメソッドが自動的に定義される日本語のメソッドは次のとおりです。

メソッド(操作)の分類	日本語のメソッド(操作)	英語のメソッド(操作)
変換操作	`検査`	`inspect`
変換操作	`配列に変換`	`to_a`
変換操作	`連想配列に変換`	`to_h`
変換操作	`文字列に変換`	`to_s`
変換操作	`記号に変換`	`to_sym`
変換操作	`整数に変換`	`to_i`
変換操作	`浮動小数点に変換`	`to_f`
変換操作	`有理数に変換`	`to_r`
変換操作	`複素数に変換`	`to_c`
繰り返し操作	`個別に`	`each`
繰り返し操作	`キー毎に`	`each_key`
繰り返し操作	`値毎に`	`each_value`
繰り返し操作	`対毎に`	`each_pair`
入れ物の操作	`取得`	`fetch`
入れ物の操作	`格納`	`store`
入れ物の操作	`削除`	`delete`
入れ物の操作	`大きさ`	`size`
入れ物の操作	`長さ`	`length`
入れ物の操作	`空か?`	`empty?`
入れ物の操作	`キーの一覧`	`keys`
入れ物の操作	`キーか?`	`key?`
入れ物の操作	`キーを持つか?`	`has_key?`
入れ物の操作	`含むか?`	`include?`
入れ物の操作	`一員か?`	`member?`
物を分解する操作	`分解`	`deconstruct`
物を分解する操作	`キーで分解`	`deconstruct_keys`

特異メソッド(特異操作)の定義

特異メソッド(特異操作)を定義するにはdefine_singleton_methodの別名である特異操作の定義を使います。特異操作の定義は物(Object)が持つメソッド(操作)です。

元のRubyスクリプトの例:

def foo.test
  print "this is foo\n"
end

日本語で書いたRubyスクリプトの例:

甲.特異操作の定義(:試行) {
  印字 "これは甲です\n"
}

文法:

式.特異操作の定義(記号) {[|引数 ...|]
  式 ...
}

ブロック(手続き)の実行

通常のメソッド(操作)と同様です。

return文に相当する制御構造

通常のメソッド(操作)と同様です。

英語のメソッド(操作)の自動定義

通常のメソッド(操作)と同様です。

逆引用符(`)記法によるメソッド(操作)の定義

逆引用符(`)内で定義を使うことでメソッド(操作)を定義できます。この逆引用符(`)記法はRubyのdef文によるメソッド(操作) の定義に相当します。Rubyのdef文はendで終了する必要がありますが、逆引用符(`)記法は逆引用符(`)で終了が明示されるので endに相当する日本語の予約語はありません。

元のRubyスクリプトの例:

def fact(n)
  if (n == 1) then
    1
  else
    n * fact(n - 1)
  end
end

日本語で書いたRubyスクリプトの例:

`定義 階乗(数)
  もし条件が{ 数 == 1 }.であるなら{
    1
  }.でなければ{
    数 * 階乗(数 - 1)
  }.である
`

メソッド(操作)の引数を転送する略記法

逆引用符(`)記法によるメソッド(操作)の定義ではRuby 2.7で導入された、メソッド(操作)の引数を転送する略記法((...))が使えます。またRuby 2.7だけでなくRuby 2.6でも略記法((...))が使えます。

元のRubyスクリプトの例:

# Ruby 2.7から有効
def foo(...)
  @other.foo(...)
end

日本語で書いたRubyスクリプトの例:

# Ruby 2.7だけでなくRuby 2.6でも有効
`定義 甲(...)
   @別の物.甲(...)
`

メソッド(操作)の末尾の引数を転送する略記法

逆引用符(`)記法によるメソッド(操作)の定義では末尾の引数を転送する略記法([...])が使えます。この略記法は独自の機能です。

元のRubyスクリプトの例:

# 明示的に引数を転送しなければならない
def method_missing(name, *args, **kw_args, &block)
  @other.__send__(name, *args, **kw_args, &block)
end

日本語で書いたRubyスクリプトの例:

# 略記法で末尾の引数を転送できる
`定義 不明な操作(名前, [...])
   @別の物.__送信__(名前, [...])
`

メソッド(操作)の呼び出し

メソッド(操作)の呼び出しは、メソッドの名前が日本語になっただけで元々の Rubyと変わりはありません。

superの日本語の定義は無い

superの日本語の定義は無いので、オーバーライドしたメソッド(操作)を呼び出すにはそのままsuperを使ってください。

superは予約語なのでメソッドのように日本語の別名を定義することができません。superを日本語で定義することはメタプログラミングを駆使すればできなくはないのですが、効率が悪いので実装する意味は無いと判断しました。

ブロック(手続き)の制御

単純にブロック(手続き)付きでメソッド(操作)を呼ぶだけなら元々のRubyと変わりはありません。ブロックを日本語で制御(break/next/redo)する場合は手続きを渡すを使います。手続きを渡すは物(Object)が持つメソッドです。

元のRubyスクリプトの例:

count = 0
ARGF.each_line do |line|
  next if line.strip.empty?     # 空行を無視
  break if (line =~ /eof/)      # 終了
  print line
  if (line =~ /dup/) then       # 再実行×3回
    if (count < 3) then
      count += 1
      redo
    end
  end
end

日本語で書いたRubyスクリプトの例:

回数 = 0
スクリプトの入力.手続きを渡す(:行毎に) {|制御, 行|
  もし条件が{ 行.空白を削る.空か? }.であるなら{ 制御.次へ進む }.である
  もし条件が{ 行 =~ /終わり/ }.であるなら{ 制御.終わる }.である
  印字 行
  もし条件が{ 行 =~ /繰り返し/ }.であるなら{
    もし条件が{ 回数 < 3 }.であるなら{
      回数 += 1
      制御.やり直す
    }.である
  }.である
}

文法:

式.手続きを渡す(記号[, 引数 ...][, 秘密の操作を許可: 真偽値]) {|制御[, 引数 ...]|
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む [式]]
  [制御.やり直す]
  式 ...
}

オブジェクト(物)の初期化

newの代わりに新規を呼ぶことで新しいオブジェクト(物)を作成し、 initializeの代わりに初期化を定義することでオブジェクトを初期化できます。

元のRubyスクリプトの例:

class Foo
  def initialize(name)
    puts "initialize Foo"
    @name = name
  end
end

class Bar < Foo
  def initialize(name, pass)
    puts "initialize Bar"
    super(name)
    @pass = pass
  end
end

it = Bar.new('myname', '0500')
p it
#=> initialize Bar
#   initialize Foo
#   #<Bar:0x2b68f08 @name="myname", @pass="0500">

日本語で書いたRubyスクリプトの例:

組(:甲) {
  定義(:初期化) {|名前|
    行を出力 "甲を初期化"
    @名前 = 名前
  }
}

組(:乙, 原型: 甲) {
  定義(:初期化) {|名前, 符丁|
    行を出力 "乙を初期化"
    super(名前)
    @符丁 = 符丁
  }
}

ある物 = 乙.新規('自分の名前', '0500')
点検 ある物
#=> 乙を初期化
#   甲を初期化
#   #<JA::JA乙:0x2b68f08 @名前="自分の名前", @符丁="0500">

日本語で書けない機能

次の予約語はメソッド(操作)による代替が困難なため日本語で書けません。必要ならそのまま英語で使ってください。

BEGIN
END
not (!を使ってください)
and (&&を使ってください)
or (||を使ってください)
super
__END__
__LINE__
__FILE__
__ENCODING__

補遺

組み込みライブラリの日本語対応表

組み込みのグローバル変数(大域変数)の日本語対応表

グローバル変数(大域変数)の日本語名	グローバル変数(大域変数)の英語名	グローバル変数(大域変数)の定義
`$配置された機能の一覧`	`$LOADED_FEATURES`	`lib/japanize/names.rb`
`$配置対象の探索経路`	`$LOAD_PATH`	`lib/japanize/names.rb`
`$点検中`	`$DEBUG`	`lib/japanize/names.rb`
`$冗長`	`$VERBOSE`	`lib/japanize/names.rb`
`$プログラムの名前`	`$PROGRAM_NAME`	`lib/japanize/names.rb`
`$ファイル名`	`$FILENAME`	`lib/japanize/names.rb`
`$安全度`	`$SAFE`	`lib/japanize/names.rb`
`$標準入力`	`$stdin`	`lib/japanize/names.rb`
`$標準出力`	`$stdout`	`lib/japanize/names.rb`
`$標準エラー出力`	`$stderr`	`lib/japanize/names.rb`

組み込みのオブジェクト(物)の日本語対応表

オブジェクト(物)の日本語名	オブジェクト(物)の英語名	オブジェクト(物)の定義
`自分`	`self`	`lib/japanize/core.rb`
`無値`	`nil`	`lib/japanize/names.rb`
`真値`	`true`	`lib/japanize/names.rb`
`偽値`	`false`	`lib/japanize/names.rb`
`スクリプトの引数`	`ARGV`	`lib/japanize/names.rb`
`スクリプトの入力`	`ARGF`	`lib/japanize/globals.rb`
`スクリプトの資料`	`DATA`	`lib/japanize/names.rb`
`環境変数`	`ENV`	`lib/japanize/globals.rb`
`標準エラー出力`	`STDERR`	`lib/japanize/names.rb`
`標準入力`	`STDIN`	`lib/japanize/names.rb`
`標準出力`	`STDOUT`	`lib/japanize/names.rb`
`最上位の束縛`	`TOPLEVEL_BINDING`	`lib/japanize/names.rb`

組み込みのクラス(組)の日本語対応表

クラス(組)の日本語名	クラス(組)の英語名	クラス(組)の定義
`物の土台`	`BasicObject`	`lib/japanize/base.rb`
`物`	`Object`	`lib/japanize/base.rb`
`配列`	`Array`	`lib/japanize/container.rb`
`束縛`	`Binding`	`lib/japanize/sys.rb`
`ディレクトリ`	`Dir`	`lib/japanize/io.rb`
`文字符号化方式`	`Encoding`	`lib/japanize/string.rb`
`文字符号化方式::変換器`	`Encoding::Converter`	`lib/japanize/string.rb`
`列挙`	`Enumerator`	`lib/japanize/enum.rb`
`列挙::継手`	`Enumerator::Chain`	`lib/japanize/enum.rb`
`列挙::生成器`	`Enumerator::Generator`	`lib/japanize/enum.rb`
`列挙::補給器`	`Enumerator::Yielder`	`lib/japanize/enum.rb`
`列挙::生産器`	`Enumerator::Producer`	`lib/japanize/enum.rb`
`列挙::等差数列`	`Enumerator::ArithmeticSequence`	`lib/japanize/enum.rb`
`列挙::遅延評価`	`Enumerator::Lazy`	`lib/japanize/enum.rb`
`偽値の組`	`FalseClass`	`lib/japanize/base.rb`
`ファイバー`	`Fiber`	`lib/japanize/thread.rb`
`ファイル::状態`	`File::Stat`	`lib/japanize/io.rb`
`連想配列`	`Hash`	`lib/japanize/container.rb`
`入出力`	`IO`	`lib/japanize/io.rb`
`ファイル`	`File`	`lib/japanize/io.rb`
`正規表現が一致した結果`	`MatchData`	`lib/japanize/string.rb`
`操作`	`Method`	`lib/japanize/sys.rb`
`部`	`Module`	`lib/japanize/base.rb`
`組`	`Class`	`lib/japanize/base.rb`
`無値の組`	`NilClass`	`lib/japanize/base.rb`
`数値`	`Numeric`	`lib/japanize/num.rb`
`複素数`	`Complex`	`lib/japanize/num.rb`
`浮動小数点`	`Float`	`lib/japanize/num.rb`
`整数`	`Integer`	`lib/japanize/num.rb`
`有理数`	`Rational`	`lib/japanize/num.rb`
`物の空間::弱参照の連想配列`	`ObjectSpace::WeakMap`	`lib/japanize/sys.rb`
`手続き型`	`Proc`	`lib/japanize/sys.rb`
`プロセス::状態`	`Process::Status`	`lib/japanize/process.rb`
`プロセス::積算時間`	`Process::Tms`	`lib/japanize/process.rb`
`プロセス::子プロセスの終了の待機`	`Process::Waiter`	`lib/japanize/process.rb`
`疑似乱数生成器`	`Random`	`lib/japanize/num.rb`
`疑似乱数生成器::書式`	`Random::Formatter`	`lib/japanize/num.rb`
`範囲`	`Range`	`lib/japanize/container.rb`
`正規表現`	`Regexp`	`lib/japanize/string.rb`
`文字列`	`String`	`lib/japanize/string.rb`
`構造体`	`Struct`	`lib/japanize/container.rb`
`記号`	`Symbol`	`lib/japanize/string.rb`
`スレッド`	`Thread`	`lib/japanize/thread.rb`
`スレッド::呼び出し履歴::場所`	`Thread::Backtrace::Location`	`lib/japanize/thread.rb`
`スレッド::条件変数`	`Thread::ConditionVariable`	`lib/japanize/thread.rb`
`スレッド::相互排他制御`	`Thread::Mutex`	`lib/japanize/thread.rb`
`スレッド::待ち行列`	`Thread::Queue`	`lib/japanize/thread.rb`
`スレッド::上限付き待ち行列`	`Thread::SizedQueue`	`lib/japanize/thread.rb`
`スレッドの群れ`	`ThreadGroup`	`lib/japanize/thread.rb`
`時刻`	`Time`	`lib/japanize/time.rb`
`発生事象の追跡`	`TracePoint`	`lib/japanize/sys.rb`
`真値の組`	`TrueClass`	`lib/japanize/base.rb`
`未束縛の操作`	`UnboundMethod`	`lib/japanize/sys.rb`

次のクラスは適切な日本語名称がないので定義していません。英語のままで使ってください

RubyVM

組み込みのモジュール(部)の日本語対応表

モジュール(部)の日本語名	モジュール(部)の英語名	モジュール(部)の定義
`比較できる`	`Comparable`	`lib/japanize/num.rb`
`列挙できる`	`Enumerable`	`lib/japanize/enum.rb`
`ファイル::定数`	`File::Constants`	`lib/japanize/io.rb`
`ファイルの検査`	`FileTest`	`lib/japanize/io.rb`
`ゴミ集め`	`GC`	`lib/japanize/sys.rb`
`ゴミ集め::統計情報`	`GC::Profiler`	`lib/japanize/sys.rb`
`入出力::読み込み待ちのため失敗`	`IO::WaitReadable`	`lib/japanize/io.rb`
`入出力::書き込み待ちのため失敗`	`IO::WaitWritable`	`lib/japanize/io.rb`
`核`	`Kernel`	`lib/japanize/base.rb`
`直列化`	`Marshal`	`lib/japanize/sys.rb`
`数学`	`Math`	`lib/japanize/num.rb`
`物の空間`	`ObjectSpace`	`lib/japanize/sys.rb`
`プロセス`	`Process`	`lib/japanize/process.rb`
`プロセス::グループ識別番号`	`Process::GID`	`lib/japanize/process.rb`
`プロセス::識別番号のシステムコール`	`Process::Sys`	`lib/japanize/process.rb`
`プロセス::ユーザ識別番号`	`Process::UID`	`lib/japanize/process.rb`
`シグナル`	`Signal`	`lib/japanize/process.rb`
`警告の出力`	`Warning`	`lib/japanize/sys.rb`

次のモジュールは適切な日本語名称がないので定義していません。英語のままで使ってください

Errno

組み込みの例外の日本語対応表

例外の日本語名	例外の英語名	例外の定義
`例外`	`Exception`	`lib/japanize/base.rb`
`記憶領域不足のため失敗`	`NoMemoryError`	`lib/japanize/names.rb`
`スクリプトの失敗`	`ScriptError`	`lib/japanize/names.rb`
`配置の失敗`	`LoadError`	`lib/japanize/errors.rb`
`未実装のため失敗`	`NotImplementedError`	`lib/japanize/names.rb`
`文法誤りのため失敗`	`SyntaxError`	`lib/japanize/names.rb`
`安全を侵害するため失敗`	`SecurityError`	`lib/japanize/names.rb`
`シグナルの例外`	`SignalException`	`lib/japanize/errors.rb`
`割り込み`	`Interrupt`	`lib/japanize/names.rb`
`標準的な失敗`	`StandardError`	`lib/japanize/names.rb`
`引数が誤っているため失敗`	`ArgumentError`	`lib/japanize/names.rb`
`脱出を捕捉できないため失敗`	`UncaughtThrowError`	`lib/japanize/errors.rb`
`文字符号化方式の失敗`	`EncodingError`	`lib/japanize/names.rb`
`文字符号化方式::互換性がないため失敗`	`Encoding::CompatibilityError`	`lib/japanize/names.rb`
`文字符号化方式::変換器が存在しないため失敗`	`Encoding::ConverterNotFoundError`	`lib/japanize/names.rb`
`文字符号化方式::バイト列が不正なため失敗`	`Encoding::InvalidByteSequenceError`	`lib/japanize/errors.rb`
`文字符号化方式::変換後の文字が存在しないため失敗`	`Encoding::UndefinedConversionError`	`lib/japanize/errors.rb`
`ファイバーの失敗`	`FiberError`	`lib/japanize/names.rb`
`入出力の失敗`	`IOError`	`lib/japanize/names.rb`
`ファイル終端のため失敗`	`EOFError`	`lib/japanize/names.rb`
`添字が範囲外のため失敗`	`IndexError`	`lib/japanize/names.rb`
`キーの照合に失敗`	`KeyError`	`lib/japanize/errors.rb`
`繰り返しの停止`	`StopIteration`	`lib/japanize/errors.rb`
`待ち行列が閉鎖済みのため失敗`	`ClosedQueueError`	`lib/japanize/names.rb`
`局所的な跳躍に失敗`	`LocalJumpError`	`lib/japanize/errors.rb`
`数学::定義域外のため失敗`	`Math::DomainError`	`lib/japanize/names.rb`
`名前解決に失敗`	`NameError`	`lib/japanize/errors.rb`
`操作が無いため失敗`	`NoMethodError`	`lib/japanize/errors.rb`
`範囲外のため失敗`	`RangeError`	`lib/japanize/names.rb`
`浮動小数点の定義域外のため失敗`	`FloatDomainError`	`lib/japanize/names.rb`
`正規表現の失敗`	`RegexpError`	`lib/japanize/names.rb`
`実行時の失敗`	`RuntimeError`	`lib/japanize/names.rb`
`凍結済みのため失敗`	`FrozenError`	`lib/japanize/names.rb`
`適合する類型が無いため失敗`	`NoMatchingPatternError`	`lib/japanize/names.rb`
`システムコールの失敗`	`SystemCallError`	`lib/japanize/errors.rb`
`スレッドの失敗`	`ThreadError`	`lib/japanize/names.rb`
`型が合わないため失敗`	`TypeError`	`lib/japanize/names.rb`
`零除算のため失敗`	`ZeroDivisionError`	`lib/japanize/names.rb`
`システムの終了`	`SystemExit`	`lib/japanize/errors.rb`
`システムのスタックが超過したため失敗`	`SystemStackError`	`lib/japanize/names.rb`

次の例外は適切な日本語名称がないので定義していません。英語のままで使ってください

Errno::*

代表的な用語の日本語と英語の対応表

日本語	英語
引数	args
塊	block
組, 生成元	class
生成物	instance
操作	method
部	module
物	object
原型	superclass

どうしても日本語に直せなかったカタカナ語の一覧表

カタカナ語	英語	備考
グリニッジ標準時	GMT	固有名詞
ネイピア数	Napier's constant	固有名詞
XMLスキーマ	XML schema	固有名詞
アスキー	ascii	固有名詞
バイナリ	binary	概念を一言で表現できなかった
ビット	bit	概念を一言で表現できなかった
バイト	byte	概念を一言で表現できなかった
(オペレーティングシステムの)コマンド	command	概念を一言で表現できなかった
カリー化	curry	概念を一言で表現できなかった
データ領域	data	概念を一言で表現できなかった
ディレクトリ	directory	概念を一言で表現できなかった
ファイバー	fiber	概念を一言で表現できなかった
ファイル	file	概念を一言で表現できなかった
ファイルシステム	filesystem	概念を一言で表現できなかった
書記素クラスタ	grapheme cluster	固有名詞
(オペレーティングシステムの)グループ	group	概念を一言で表現できなかった
ハッシュ値	hash	概念を一言で表現できなかった
キー	key	直訳では実際の用途を表現できなかった
ロケール	locale	概念を一言で表現できなかった
電子メール	mail	固有名詞
マイクロ	micro	SI接頭辞
ナノ	nano	SI接頭辞
(オペレーティングシステムの)プロセス	process	概念を一言で表現できなかった
プログラム	program	概念を一言で表現できなかった
スクリプト	script	概念を一言で表現できなかった
(オペレーティングシステムの)シグナル	signal	概念を一言で表現できなかった
ソケット	socket	概念を一言で表現できなかった
スタック	stack	概念を一言で表現できなかった
標準エラー出力	stderr	固有名詞
システム	system	概念を一言で表現できなかった
システムコール	system call	概念を一言で表現できなかった
スレッド	thread	概念を一言で表現できなかった
ユニコード	unicode	固有名詞
(オペレーティングシステムの)ユーザ	user	概念を一言で表現できなかった

貢献方法

問題報告やプルリクはGithubのhttps://github.com/y10k/ruby-japanizeで受け付けています。

ライセンス

このgemはMIT Licenseライセンスの元でオープンソースとして提供されます。

Name		Name	Last commit message	Last commit date
Latest commit History 261 Commits
bin		bin
lib		lib
misc		misc
sample		sample
test		test
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
Gemfile		Gemfile
LICENSE.txt		LICENSE.txt
README.md		README.md
Rakefile		Rakefile
ruby-japanize.gemspec		ruby-japanize.gemspec

License

y10k/ruby-japanize

Folders and files

Latest commit

History

Repository files navigation

ruby-japanize

導入方法

なぜRubyを日本語化しようと思ったのかについて

日本語化の基本方針

日本語の命名規則

日本語で書いたRubyスクリプトの例

すべてがオブジェクト

Rubyの柔軟性

ブロック: 表現力豊かな機能

RubyとMixin

日本語のRubyスクリプトの書き方

日本語の有効化

日本語の変数と定数

日本語の定数

定数の定義

定数の参照

定数のinclude(付加)

日本語の制御構造

肯否分岐

if文に相当する制御構造

unless文に相当する制御構造

条件分岐

case文に相当する制御構造

繰り返し

while文に相当する制御構造

until文に相当する制御構造

後置のwhile文に相当する制御構造

後置のuntil文に相当する制御構造

for文に相当する制御構造

例外処理

例外の発生

begin/endに相当する制御構造

日本語のクラス(組)/メソッド(操作)の定義

クラス(組)の定義

定義したクラス(組)の参照

特異クラス(特異組)の定義

特異クラス(特異組)の参照

モジュールの定義

定義したモジュール(部)の参照

メソッド(操作)の定義

ブロック(手続き)の実行

return文に相当する制御構造

英語のメソッド(操作)の自動定義

特異メソッド(特異操作)の定義

ブロック(手続き)の実行

return文に相当する制御構造

英語のメソッド(操作)の自動定義

逆引用符(`)記法によるメソッド(操作)の定義

メソッド(操作)の引数を転送する略記法

メソッド(操作)の末尾の引数を転送する略記法

メソッド(操作)の呼び出し

superの日本語の定義は無い

ブロック(手続き)の制御

オブジェクト(物)の初期化

日本語で書けない機能

補遺

組み込みライブラリの日本語対応表

組み込みのグローバル変数(大域変数)の日本語対応表

組み込みのオブジェクト(物)の日本語対応表

組み込みのクラス(組)の日本語対応表

組み込みのモジュール(部)の日本語対応表

組み込みの例外の日本語対応表

代表的な用語の日本語と英語の対応表

どうしても日本語に直せなかったカタカナ語の一覧表

貢献方法

ライセンス

About

Topics

Resources

License

Stars

Watchers

Forks

Releases

Packages