Názory k článku
Operátory a asociativní pole v jazyku Lua

Verze s nadbytečnou čárkou vypadá velmi podobně jako předchozí úryvek kódu:

pole={klic1="hodnota1", klic2="hodnota2"}


kde je tam ta carka? :D

pravda, je to velmi ale velmi podobné :-) Samozřejmě je to chyba, opravíme. Má tam být:

pole={klic1="hodnota1", klic2="hodnota2", }

Opraveno, diky za upozorneni.

mrzime jen ze neexistuji zkraceniny operaci jako in(de)krementace, +=, -=, /=, atd..

pocita se nekdy s nejakym vyraznym vyvojem tohota jazyka do podoby ktera se vice podoba dnesnim "vyssim" jazykum ??

Vyšším jazykem máte na mysli přesně co? ;-) Protože jestli Lua není vyšší jazyk, pak mě napadá snad už jedine Haskell. :] A co je na Lua nemoderního? ;)

Pise dnesnim vyssim jazykum. Tim nerika ze Lua neni vyssi jazyk, ale ze neni dnesni a ma uz zastaralou syntaxi. Treba Python to ve vrzi 1.x taky neumel, ve 2.x uz ano.

Já nevím, mně Lua přijde dnešní dost - má kupříkladu uzávěry, korutiny, téměř dokonalou reflexivitu, s knihovnou i makra, a vůbec spoustu dalších podobných věcí, které "včerejší vyšší jazyky" neměly.

A proč všechno zkracovat? Stejně si to += programátor musí podvědomě zase přelouskat na p=p+x :)

Programátorské postřižiny... ;-)

To mate recht, ja si vzdycky musim prelouskat

$x->{foo}[$index+2]{$bar} += 5;

na

$x->{foo}[$index+2]{$bar} = $x->{foo}[$index+2]{$bar} + 5;

a po tom prelouskani si jeste vzdycky zkontroluju jestli jsem nekde neudelal preklep.

Pravda, taky mě to zpočátku zarazilo, autoři tu absenci vysvětlují po svém, cituji:

"
Why does Lua lack the += operator, etc.?
One of Lua's design goals is simplicity. Most languages are large, meaning that they have many sophisticated features built-in. Examples are C, C++, Python, Lisp, ML. A very few languages are small. Examples are Forth and Lua. Lua aims to provide a small range of atomic features which are truly essential, and from which many other sophisticated features can be constructed if desired. Examples of sophisticated features which can be added to Lua from within the language include modules, object orientation, and now exceptions and threads which can be implemented via coroutines in Lua 5. The absent += operator is one more example.

I thought the reason was more practical. Many argue for adding these operators because of the efficiency gains they enable. But in Lua things would get confusing because of the extension system. It's in the lua-l archives somewhere... --JohnBelmonte

I think it's more basic than that - you must draw a line in the sand for the amount of operators a small language should have. You allow +=, then people ask why not *= and -= etc etc. Before you know it, you have added many operators which simply makes it bigger. Small and simple is Lua's tenet.
"

da se s tim zit (i kdyz nekdy skripu zuby), nebo pouzit tuto techniku:

http://lua-users.org/wiki/CustomOperators

Nebo http://metalua.luaforge.net/metalua-manual.html :-)

jj, s Metalua se daji delat veci... <flame>takový čitelnější Lisp :-)</flame>

To přece není pravda. Je rozdíl mezi vytvořením kopie instance a následným provedením operace a změnou hodnoty v původním objektu. Překladač by to sice v případě, že dochází k zapisování do té samé proměnné, mohl reflektovat, ale to mi nepřijde moc košer.

To snad záleží na sémantice operátoru, datovém modelu jazyka a konkrétních datových typech, ne? Kupříkladu u immediate hodnot (třeba tagovaných) žádné "vytvoření kopie instance" ani nepřichází v úvahu. (Jak byste chtěl třeba změnit hodnotu (abstraktního) celého čísla?)

A Lua (naštěstí) není C++. BTW, třeba Ruby ani nepovoluje definovat operaci x+=y tak, aby měla jinou sémantiku, než x=x+y. A taky mi to přijde jako docela dobrý nápad. Umím si živě představit, jaké bugy by se pak začaly vyskytovat.

Překladač by to sice v případě, že dochází k zapisování do té samé proměnné, mohl reflektovat, ale to mi nepřijde moc košer.

Tak to je asi nejstrašidelnější myšlenka dne. :)

No tak u konstantních objektů to fakt moc smysl nemá. Ale u sčítání matic a jiných větších objektů mi to smysl dává. Pokud Ruby něco takového fakt neumí, přijde mi to jako handicap.

Jasně, dokud na každou matici mám maximálně jednu referenci, tak mi nepřijde, že by na destruktivní změně mohlo být něco špatného. :]

No jasně, ale to platí o všech destruktivních změnách (například inverze matice. Pokud je jazyk povoluje a zhusta se používají, nevidím důvod, proč z toho vynechat tyhle operátory.

Inkrementace a dekrementace mi přijdou vcelku zbytečné; je to jenom speciální případ += a -= a prefixová a postfixová notace v C apod. jenom zbytečně zesložiťují jazyk a zdrojové kódy. += apod. naopak smysl mají všude tam, kde existuje možnost přetížení operátorů v typovém systému; pokud se bavíme o imperativním kódu.

Taky je zde otazka, jakou by ty operatory mely semantiku, protoze prirazeni v Lua je trosku obecnejsi, nez prirazeni v ceckovych jazycich. Urcite by se to dalo zadefinovat, ale mozna by to bylo trosku zmatecne (coz je presne proti tendencim, kam Lua miri):

a,b+=2,3

nebo jeste jinak:
a,b*=fce()

Nejsou? Myslím, že i ve vysokoúrovňových jazycích je to praktická věc (když potřebuju často vyhodnocovat kombinaci několika podmínek).

Kdyby byly přímo součástí jazyka, může na to interpret použít nějakou optimalilzaci, ale když operaci, pro kterou má většina procesorů přímo instrukce, musím řešit voláním funkce v interpretovaném jazyce, už to trochu ztrácí to kouzlo...

Asi taky jde o tu jednoduchost, a když náhodou potřebuju opravdu rychlost, tak si to mám napsat v C -- když už je to "embedded" jazyk.

mohlo by pomoci nejake rozsireni nebo patch z: http://lua-users.org/wiki/BitwiseOperators

IMHO tam tyto operatory nejsou ze dvou duvodu:

1) je tezke definovat, co tyto operatory delaji nad defaultnim ciselnym typem, coz je v Lua double. Napriklad JavaScript (taktez s jednim typem numeric) s tim ma problemy, staci si vyzkouset v prohlizeci (adresni radek + Enter):
javascript:alert(1|2)
versus
javascript:alert(1|1.99999999999)
to druhe muze byt vysledek nejake bezne pocetni operace nad doublem, klidne i jednoduchy soucet.

2) pouziti techto operatoru je dvoji: sahani na jednotlive bity napriklad v hlavickach souboru ci protokolu - zde stejne nema smysl to delat nad doublem (viz vyse, lepsi je volat nejakou c-ckovou funkci ci pouzit patch/rozsireni) a potom bitove mnoziny (to jsou ony podminky) - zde je ovsem ve vysokourovnovem jazyku IMHO vhodnejsi pouzit skutecne bitove mnoziny, ktere nejsou omezeny na 32/64 bitu, vysledek je i citelnejsi, protoze se nemusi vytvaret nejake enum-like konstanty apod.

Ahoj. Nevěděl by jste někdo jak načíst číslice, která jsou v řádcích pod sebou v souboru.txt do pole, tak aby mi to vzala Lua 4.0. Pro Lua 5.0 to umím, ale pro 4 ani náhodou – nedaří se mi získat více jak jeden řádek. Jeden řádek mám read(readfrom(sou­boru.txt)), ale potřeboval bych udělat nějak cykl aby to šlo po řádcích až do konce. Zkoušel jsem několik variant, ale stále se mi to nedaří dát dohromady. Díky