Где и как указывается переменная _ (подчеркивание)?

Большинство из них знает о _специальном значении «S в IRB в качестве держателя для последнего возвращаемого значения, но это не то , что я спрашиваю здесь.

Вместо этого я спрашиваю, _когда используется в качестве имени переменной в старом старом коде Ruby. Здесь, похоже, он ведет себя по-особенному, сродни «переменной безразличия» (à la Prolog ). Вот несколько полезных примеров, иллюстрирующих его уникальное поведение:

lambda { |x, x| 42 }            # SyntaxError: duplicated argument name
lambda { |_, _| 42 }.call(4, 2) # => 42
lambda { |_, _| 42 }.call(_, _) # NameError: undefined local variable or method `_'
lambda { |_| _ + 1 }.call(42)   # => 43
lambda { |_, _| _ }.call(4, 2)  # 1.8.7: => 2
                                # 1.9.3: => 4
_ = 42
_ * 100         # => 4200
_, _ = 4, 2; _  # => 2

Все они запускались непосредственно в Ruby (с putsдобавлением s), а не в IRB, чтобы избежать конфликта с его дополнительными функциями.

Это все результат моих собственных экспериментов, поскольку я нигде не могу найти никакой документации по такому поведению (по общему признанию, это не самая простая вещь для поиска). В конце концов, мне любопытно, как все это работает внутри, чтобы я мог лучше понять, в чем именно особенность _. Поэтому я прошу ссылки на документацию и, желательно, на исходный код Ruby (и, возможно, RubySpec ), которые показывают, как _ведет себя Ruby.

_{Примечание: большая часть этого возникла в результате обсуждения с @Niklas B.}

В источнике есть специальная обработка для подавления ошибки «повторяющееся имя аргумента». Сообщение об ошибке появляется только shadowing_lvar_genвнутри parse.y, версия 1.9.3 выглядит так :

static ID
shadowing_lvar_gen(struct parser_params *parser, ID name)
{
    if (idUScore == name) return name;
    /* ... */

и idUScoreэто определено вid.c следующим образом:

REGISTER_SYMID(idUScore, "_");

Вы увидите похожую особую обработку в warn_unused_var:

static void
warn_unused_var(struct parser_params *parser, struct local_vars *local)
{
    /* ... */
    for (i = 0; i < cnt; ++i) {
        if (!v[i] || (u[i] & LVAR_USED)) continue;
        if (idUScore == v[i]) continue;
        rb_compile_warn(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
    }
}

Вы заметите, что предупреждение подавляется во второй строке forцикла.

Единственная особая обработка, _которую я смог найти в источнике 1.9.3, приведена выше: ошибка дублирования имени подавляется, а предупреждение о неиспользуемой переменной подавляется. Помимо этих двух вещей, _это просто старая обычная переменная, как и любая другая. Я не знаю какой-либо документации о (незначительной) особенности _.

В Ruby 2.0 idUScore == v[i]тест warn_unused_varзаменяется вызовом is_private_local_id:

if (is_private_local_id(v[i])) continue;
rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));

и is_private_local_idподавляет предупреждения для переменных, которые начинаются с _:

if (name == idUScore) return 1;
/* ... */
return RSTRING_PTR(s)[0] == '_';

а не только _себя. Так что 2.0 немного расслабляет.

_- действительный идентификатор. Идентификаторы не могут содержать только подчеркивания, они также могут быть подчеркиванием.

_ = o = Object.new
_.object_id == o.object_id
# => true

Вы также можете использовать его как имена методов:

def o._; :_ end
o._
# => :_

Конечно, это не совсем читаемое имя, и при этом оно не передает читателю никакой информации о том, на что ссылается переменная или что делает метод.

IRB, в частности, устанавливает _значение последнего выражения:

$ irb
> 'asd'
# => "asd"
> _
# => "asd"

Как и в исходном коде , он просто устанавливает _последнее значение:

@workspace.evaluate self, "_ = IRB.CurrentContext.last_value"

Изучал репозиторий. Вот что я нашел:

В последних строках файла id.cесть вызов:

REGISTER_SYMID(idUScore, "_");

grepПоиск источника idUScoreдал мне два, казалось бы, релевантных результата:

• В shadowing_lvar_genфункции
• В warn_unused_varфункции

shadowing_lvar_genкажется механизмом, посредством которого формальный параметр блока заменяет переменную с тем же именем, которая существует в другой области. Это функция, которая, кажется, вызывает SyntaxErrorпредупреждение «дублированное имя аргумента» и «затенение внешней локальной переменной».

После grepдобавления исходного кода shadowing_lvar_genя обнаружил в журнале изменений для Ruby 1.9.3 следующее :

Вт 11 дек, 01:21:21 2007 Юкихиро Мацумото

• parse.y (shadowing_lvar_gen): нет повторяющейся ошибки для "_".

Что, вероятно, является источником этой строки :

if (idUScore == name) return name;

Из этого я делаю вывод, что в такой ситуации, как proc { |_, _| :x }.call :a, :bодна _переменная просто затеняет другую.

Вот коммит, о котором идет речь . В основном он представил эти две строки:

if (!uscore) uscore = rb_intern("_");
if (uscore == name) return;

idUScoreВидимо, из тех времен, когда даже не существовало.