Dlaczego Ruby nie obsługuje i ++ lub i-- (operatory inkrementacji / dekrementacji)?

Operator inkrementacji / dekrementacji pre / post ( ++i --) jest dość standardową składnią języka programowania (przynajmniej dla języków proceduralnych i obiektowych).

Dlaczego Ruby ich nie obsługuje? Rozumiem, że możesz osiągnąć to samo za pomocą +=i -=, ale wykluczenie czegoś takiego wydaje się dziwnie arbitralne, zwłaszcza że jest tak zwięzłe i konwencjonalne.

Przykład:

i = 0    #=> 0
i += 1   #=> 1
i        #=> 1
i++      #=> expect 2, but as far as I can tell, 
         #=> irb ignores the second + and waits for a second number to add to i

Rozumiem, że Fixnumjest niezmienny, ale jeśli +=mogę po prostu zainicjować nowy Fixnumi ustawić go, dlaczego nie zrobić tego samego dla ++?

Czy konsekwencja w przypisaniach zawierających =znak jest jedynym tego powodem, czy czegoś mi brakuje?

Oto jak Matz (Yukihiro Matsumoto) wyjaśnia to w starym wątku :

Hi,

In message "[ruby-talk:02706] X++?"
    on 00/05/10, Aleksi Niemelä <[email protected]> writes:

|I got an idea from http://www.pragprog.com:8080/rubyfaq/rubyfaq-5.html#ss5.3
|and thought to try. I didn't manage to make "auto(in|de)crement" working so
|could somebody help here? Does this contain some errors or is the idea
|wrong?

  (1) ++ and -- are NOT reserved operator in Ruby.

  (2) C's increment/decrement operators are in fact hidden assignment.
      They affect variables, not objects.  You cannot accomplish
      assignment via method.  Ruby uses +=/-= operator instead.

  (3) self cannot be a target of assignment.  In addition, altering
      the value of integer 1 might cause severe confusion throughout
      the program.

                            matz.

Jednym z powodów jest to, że do tej pory każdy operator przypisania (tj. Operator zmieniający zmienną) ma w sobie znak =. Jeśli dodasz ++i --, to już nie jest.

Innym powodem jest to, że zachowanie ++i --często dezorientują ludzi. Przykład: wartość zwracana i++w Twoim przykładzie będzie w rzeczywistości wynosić 1, a nie 2 (nowa wartość ibędzie jednak wynosić 2).

To nie jest konwencjonalne w językach OO. W rzeczywistości nie ma ++w Smalltalk, języku, który ukuł termin „programowanie obiektowe” (a język Ruby jest pod największym wpływem). Masz na myśli to, że jest konwencjonalny w C, a języki ściśle imitują C. Ruby ma składnię podobną do C, ale nie jest niewolniczy w trzymaniu się tradycji C.

Co do tego, dlaczego nie ma go w Ruby: Matz tego nie chciał. To naprawdę ostateczny powód.

Powodem ma czegoś takiego istnieje w Smalltalk to dlatego, że jest częścią języka jest nadrzędne filozofię, że przypisanie zmiennej jest zasadniczo inny rodzaj rzeczy niż wysyłanie wiadomości do obiektu - jest na innym poziomie. To myślenie prawdopodobnie wpłynęło na Matza podczas projektowania Rubiego.

Nie byłoby niemożliwe włączenie go do Rubiego - można łatwo napisać preprocesor, który przekształci wszystko ++w +=1. ale najwyraźniej Matzowi nie podobał się pomysł operatora, który wykonywał „ukryte zadanie”. Wydaje się również trochę dziwne, aby mieć operator z ukrytym operandem całkowitym w środku. Żaden inny operator w tym języku nie działa w ten sposób.

Myślę, że jest jeszcze jeden powód: ++w Rubim nie byłoby to nawet przydatne, jak w C i jego bezpośrednich następcach.

Powód jest taki, że forsłowo kluczowe: chociaż jest niezbędne w C, w Rubim jest przeważnie zbyteczne. Większość iteracji w Rubim odbywa się za pomocą metod Enumerable, takich jak eachi mappodczas iteracji przez pewną strukturę danych oraz Fixnum#timesmetody, gdy trzeba wykonać pętlę dokładną liczbę razy.

Właściwie, o ile widziałem, większość czasu +=1jest używana przez osoby, które niedawno przeszły na Ruby z języków w stylu C.

Krótko mówiąc, naprawdę wątpliwe jest, czy metody ++i --czy w ogóle byłyby używane.

Myślę, że uzasadnienie Matza, dlaczego ich nie lubi, jest takie, że faktycznie zastępuje zmienną nową.

dawny:

a = SomeClass.new
def a.go
  'Witaj'
koniec
# w tym momencie możesz zadzwonić do a.go
# ale jeśli zrobiłeś a ++
# to naprawdę oznacza a = a + 1
# więc nie możesz już dzwonić do a.go
# ponieważ zgubiłeś oryginał

Teraz gdyby ktoś mógł go przekonać, że powinien po prostu zadzwonić na #succ! a co nie, to miałoby większy sens i pozwoliło uniknąć problemu. Możesz zasugerować to na rubinowym rdzeniu.

Możesz zdefiniować .+operator autoinkrementacji:

class Variable
  def initialize value = nil
    @value = value
  end
  attr_accessor :value
  def method_missing *args, &blk
    @value.send(*args, &blk)
  end
  def to_s
    @value.to_s
  end

  # pre-increment ".+" when x not present
  def +(x = nil)
    x ? @value + x : @value += 1
  end
  def -(x = nil)
    x ? @value - x : @value -= 1
  end
end

i = Variable.new 5
puts i                #=> 5

# normal use of +
puts i + 4            #=> 9
puts i                #=> 5

# incrementing
puts i.+              #=> 6
puts i                #=> 6

Więcej informacji na temat „zmiennej klasy” można znaleźć w sekcji „ Zmienna klasy w celu zwiększenia liczby obiektów o stałej liczbie ”.

I słowami Davida Blacka z jego książki „The Well-Grounded Rubyist”:

Niektóre obiekty w Rubim są przechowywane w zmiennych jako wartości bezpośrednie. Należą do nich liczby całkowite, symbole (które wyglądają tak: this) i specjalne obiekty true, false i nil. Po przypisaniu jednej z tych wartości do zmiennej (x = 1), zmienna przechowuje samą wartość, a nie odniesienie do niej. W praktyce nie ma to znaczenia (i często będzie to sugerowane, a nie powtarzane wielokrotnie, w dyskusjach na temat odniesień i powiązanych tematów w tej książce). Ruby automatycznie obsługuje wyłuskiwanie odniesień do obiektów; nie musisz wykonywać żadnej dodatkowej pracy, aby wysłać wiadomość do obiektu, który zawiera, powiedzmy, odniesienie do łańcucha, w przeciwieństwie do obiektu, który zawiera bezpośrednią wartość całkowitą. Jednak zasada reprezentacji wartości bezpośredniej ma kilka interesujących konsekwencji, zwłaszcza jeśli chodzi o liczby całkowite. Po pierwsze, każdy obiekt, który jest reprezentowany jako wartość natychmiastowa, jest zawsze dokładnie tym samym obiektem, bez względu na to, do ilu zmiennych jest przypisany. Jest tylko jeden obiekt 100, tylko jeden obiekt fałszywy i tak dalej. Bezpośrednia, unikalna natura zmiennych związanych z liczbami całkowitymi leży u podstaw braku operatorów przed i po inkrementacji w Rubim - co oznacza, że ​​nie można tego zrobić w Rubim: x = 1 x ++ # Brak takiego operatora Przyczyna jest taka do bezpośredniej obecności 1 w x, x ++ byłoby podobne do 1 ++, co oznacza, że ​​zmieniłbyś liczbę 1 na liczbę 2 - i to nie ma sensu. bez względu na to, do ilu zmiennych jest przypisana. Jest tylko jeden obiekt 100, tylko jeden obiekt fałszywy i tak dalej. Bezpośrednia, unikalna natura zmiennych związanych z liczbami całkowitymi leży u podstaw braku operatorów przed i po inkrementacji w Rubim - co oznacza, że ​​nie można tego zrobić w Rubim: x = 1 x ++ # Brak takiego operatora Powód jest taki do bezpośredniej obecności 1 w x, x ++ byłoby podobne do 1 ++, co oznacza, że ​​zmieniłbyś liczbę 1 na liczbę 2 - i to nie ma sensu. bez względu na to, do ilu zmiennych jest przypisana. Jest tylko jeden obiekt 100, tylko jeden obiekt fałszywy i tak dalej. Bezpośrednia, unikalna natura zmiennych związanych z liczbami całkowitymi leży u podstaw braku operatorów przed i po inkrementacji w Rubim - co oznacza, że ​​nie można tego zrobić w Rubim: x = 1 x ++ # Brak takiego operatora Przyczyna jest taka do bezpośredniej obecności 1 w x, x ++ byłoby podobne do 1 ++, co oznacza, że ​​zmieniłbyś liczbę 1 na liczbę 2 - i to nie ma sensu.

Czy nie można tego osiągnąć, dodając nową metodę do klasy fixnum lub Integer?

$ ruby -e 'numb=1;puts numb.next'

zwraca 2

Wydaje się, że metody „destrukcyjne” są dołączane w !celu ostrzeżenia potencjalnych użytkowników, więc dodanie nowej metody o nazwie w next!zasadzie zrobiłoby to, o co proszono, tj.

$ ruby -e 'numb=1; numb.next!; puts numb' 

zwraca 2 (ponieważ liczba numb została zwiększona)

Oczywiście next!metoda musiałaby sprawdzić, czy obiekt był zmienną całkowitą, a nie liczbą rzeczywistą, ale ta powinna być dostępna.

Sprawdź te operatory z rodziny C w irb Rubiego i przetestuj je samodzielnie:

x = 2    # x is 2
x += 2   # x is 4
x++      # x is now 8
++x      # x reverse to 4