Názory k článku Ruby v příkladech (2) - Složitější skripty

Není nutné používat "třidní" notaci. Pokud vím, tak v Ruby se dají také operátory "přetížit". Přesněji řečeno, nejedná se o typické přetížení jako v C++, spíše se jedná o předefinování standarních metod, které mají infixovou notaci. Nepohodlné by spíše bylo jen zadávání necelých konstant, infixovou notaci aritmetických operátorů mají všechny ty třídy, o kterých se bavíme. Takže například funguje:

a = Rational(1,3) # => 1/3
b = Rational(1,4) # => 1/4
c = Rational(1,5) # => 1/5
d = 1 + a/2 + b*c # => 73/60 

Výsledek v proměnné d je také typu Rational.

Aha, tak tím se to řeší. Jde tedy o to, že každá třída může přijímat volání standardních metod + apod. ? Trošku mě totiž zarazil ten poslední příklad, který je například v C++ trošku problematický (hrátky s konstruktory). Je totiž rozdíl v zápisu:

xx=1+Rational.
a
yy=Rational+1

Přesně tak: +, - atd. jsou normální metody, které může přijímat objekt libovolné třídy (i třída sama, ale použít to by asi bylo dost drsné :-). Oproti C++ je tam nevýznamné omezení, že pokud se předefinuje např. metoda '+', automaticky se předefinuje i chování metody '+=', aby bylo kompatibilní (podobně pro další operátory). Kupodivu logické operátory ('and', '&&', '!', 'not' atd.) nejsou metody a nejdou tedy předefinovat.

Jen pro představu jsem napsal kratičký testík, kdy se k nule přičítala milionkrát setina a měřil jsem čas pro Float (tj. binární reprezentace floating point), BigDecimal (decimální aritmetika s libovolnou přesností) a Rational (aritmetika se zlomky). Časy jsou:

• Float: okolo 0.7 sec, výsledek ovlivněn zaokrouhlovací chybou (10000.0000001719)
• BigDecimal: okolo 3 sec, výsledek přesný (0.1E5)
• Rational: okolo 60 sec, výsledek přesný (10000/1)

Testík např pro BigDecimal vypadal takto:

t0 = Time.new
a = BigDecimal('0', 50)
b = BigDecimal('0.01')
1000000.times { a += b }
puts Time.new - t0

To nejsou špatné výsledky, například BigDecimal je pouze 4x pomalejší - čekal jsem, že ty rozdíly budou větší.

Já taky. Příjemně mne to překvapilo. Na druhé straně jsem zase čekal trochu lepší výsledky se zlomkama - jde v podstatě jen o celočíselnou aritmetiku.

Vyzkoušel jsem Squeak Smalltalk a výsledky byly neméně překvapivé.

Verze s floaty mi trvala 405 ms a verze se zlomky 3899 ms. Na druhou stranu při použití ScaledDecimals celých 167 s.

[ a := 0.
  b := 1/10.
  1000000 timesRepeat: [ a := a + b ]
] timeToRun

1/100, samozřejmě :-)

Nevim jak to dela Ruby, ale Lisp se pri praci se zlomkama po kazde operaci snazi dostat ve vysledku co nejmensi delitel (nebo jak se presne jmenuje to cisilko pod zlomkovou carou). Takze i pri "pouhem" scitani to vlastne iterativne provadi i dalsi vypocty apod.

Ale já jsem s výsledkem spokojený, protože to odpovídá mému názoru, že použití nativních datových typů v této sortě programovacích jazyků je vlastně zbytečné. Pokud je BigDecimal pouze 4x pomalejší, tak bych Float do jazyka vůbec nezatahoval, samozřejmě kromě několika knihovních konverzních funkcí (aby se daly načítat vstupy a výstupy). Float (a další podobné) s sebou přináší spoustu problémů, které se bohužel neprojevují typickými chybami (a mnohdy se neodhalí ani na testovacích datech - viz rozdíly v kompilaci), takže proč ho mít v jazycích, které slouží především pro urychlení vývoje?

Sorry, tak daleko jsem v Pythonu ještě nebyl :-) Teď jsem se na to přetěžování díval a vypadá to dost dobře - zápis operátorů pomocí slov a celkově je ta deklarace operátoru mnohem jednodušší než v C++. Předpokládám, že jde vytvořit i přetížený operátor, kde může být nějaká třída na "obou stranách" operátoru.

BTW: teď trošku studuji Python a zarazily mě na něm dvě věci: uzávěry a lambda výrazy. Chová se to odlišně než jsem čekal (po zkušenostech s jinými jazyky, asi víš, který myslím :-). Existuje nějaký dokument, kde by se o uzávěrech a lambda výrazech nějak podrobněji diskutovalo. Zatím jsem našel vždycky nějaký jednoduchý příkládek, chtělo by to něco složitějšího.

Doporučuji tohle:
http://www.martinfowler.com/bliki/Closure.html
a tohle
http://www.martinfowler.com/bliki/CollectionClosureMethod.html
Je to spíše o uzávěrech obecně v různých jazycích, příklady jsou ale většinou v Ruby. Jsou tam i nějaké užitečné odkazy.

Pak se mne ještě zaujalo interview, kde Yukihiro Matsumoto (tvůrce Ruby) vysvětluje, jak uzávěry chodí a proč jsou v Ruby. Začíná to na konci této stránky:
http://www.artima.com/intv/closures.html

Uzávěry, IMHO, nejsou nijak zvlášť složité ani kontroverzní, takže si nejsem jistý, jestli o tom existuje nějaký podrobnější materiál.

Děkuji za odkazy. Já nemám problémy s uzávěry jako takovými, ty se přece používají už pěkně dlouhou dobu a jejich vlastnosti i použití jsou známé. Jen mě zarazilo chování uzávěrů v Pythonu, samozřejmě neříkám, že tam nefunguje, ale je to trošku jiné, než na co jsem zvyklý.

No, takhle to umí Lisp už cca dvacet let :-) Dnešní dynamické jazyky (mimo Smalltalku, ať mě nebacíš) se Lispu blíží, ale přichází z druhé strany - od Algolu, takže si ještě musíme chvíli počkat :-)))

Bacit tě? To by mi Johanka dala... ;-)

Nevím. Autor jazyka je pravděpodobně toho názoru, že celočíselné dělení je užitečnější, než zlomky. Nicméně, pokud to tak chcete mít ve vaší aplikaci, tak není problém předefinovat operátor dělení standardní třídy Fixnum takto:

class Fixnum
  def /(other)
    return Rational(self, other)
  end
end

Rezervované slovo return je v tomto případě nepovinné, dal jsem ho tam kvůli čitelnosti. Potom výraz 1/2 vrací výsledek Rational(1,2). Já bych to ale asi bez pořádně silného důvodu nedělal. Trpí tím, IMHO, čitelnost programu a kdoví kde všude se používá celočíselné dělení a jaké by to mohlo mít vedlejší efekty.

Teď se tady míchají dvě věci.

Pokud jsme správně pochopil původní dotaz tohoto vlánka, tak tam šlo o to, že se nějak definuje třída, vytvoří se nějaké její instance a pak se definice té třídy nějak změní a vytvoří se její další instance. To v Ruby jde - definice třídy se může dělat "per partes" a všechny instance i ty původní budou mít nakonec vlastnosti po, řekněme, "sjednocení" definic. Trochu se nám to toho pletou ty vnitřní proměnné instance - jenže v Ruby jsou soukromé. Takže se samozžejmě dá s nima různě manipulovat a dají se dynamicky přidávat, ale je to bezpředmětné, když jsou dostupné jen přes veřejné metody. Metody se samozřejmě dají také dynamicky přidávat (všem instancím třídy) - to je v článku.

Ten příklad v Pythonu je jiný problém, jedná se o přidávání k _jediné_ instanci. Metody lze v Ruby přidávat jediné instanci také - to je též v článku (singleton methods). A ty "vnitřní" proměnné jsou i u jedné instance soukromé, takže zase se o nich nemá smysl bavit.

V Ruby je prostě potřeba přidat "přístupové metody" k vnitřním atributům. To lze různým způsobem. Obecně je nejednodušší použít attr_reader, attr_writer nebo attr_accessor podle toho, zda ten atribut chceme mít read only, write only nebo read-write.

Takže pokud bych měl ten pythonový kód nasimulovat v Ruby, vypadalo by to asi takto:

# vytvoreni tridy A s read/write atributem
class A
attr_accessor :a
def initialize
@a = 4
end
end

a1 = A.new
a2 = A.new

# vytvor anonymni tridu pro objekt a2 a pridej do ni read/write atribut b
class << a2
attr_accessor :b
end

a2.b = 5

print a1.a # vytiskne 4
print a2.a # vytiskne 4
print a2.b # vytiskne 5
print a1.b # chyba: nezna metodu b (metoda je jen v instanci a2)

To "attr_accessor :a" je normální zavolání procedury, která do té definice třídy doplní ty potřebné přístupové metody. Takže definice třídy A by se dala "ručně" napsat takto:

class A

def a
return @a
end

def a=(value)
@a = value
end

def initialize
@a = 4
end

end

Pokud u té druhé definice napíšu "class A" místo toho "class << a2", dodefinuje se atribut b do všech instancí třídy A, tedy i do a1.

(Omlovám se za formátování, ale v HTML se mi to nějak mršilo.)