Názory k článku Groovy: Java má vzdáleného bratrance

Vymena obsahu premennych bez pomocnej premennej?

Ten Python a Ruby beriem (syntax inspirovana Perlom). Priklad v OCaml robi nie co ine; definuje nove premenne, ktore zakryju v danom rozsahu povodne a, b. Premenne (okrem ref) su v OCaml predsa konstantne.

Ok, vymena premennych nevysla. Co tak parsovanie URL argumentov do hash/map premennej?

$urlArgs = 'key1=value1&key2=value2';

%params = map { $$_[0] => $$_[1] }
          map { [ split /=/, $_ ] }
          split /\&/, $urlArgs;

Ako nieco podobne bude vyzerat v Python/Ruby?

Redakcni system sezral odsazeni, ale v tomto pripade neni z hlediska funkce nutne.

Tiez jeden z dovodov, preco mi to vynutene odsadzovanie nesedi :)

V Perle mozem jednoducho doplnit tuto logiku to povodneho riesenia:

%params = map  { +"\l$_->[0]" => "\l$$_[1]" }
          grep { $$_[0] =~ /^\p{IsUpper}/ && $$_[1] =~ /^\p{IsUpper}/ }
          map  { [ split /=/, $_ ] }
          split '&', $urlArgs;

Vsimite si ako je ten kod linearizovany - ziadny vnoreny "for" a cely kod neprehladne uzaverety do volania dict(). Moje riesenie je uplne standardny Perl - vas Python kod by ste v normalnom projekte takto nezapisali pretoze ten vnoreny for je neprehladny.

Dajme si este jedno kolo - ake je hodnota parametra vo formate YYYY-MM-DD a rok je nizsi ako 2000, tak nech je zapisany ako rok 2000.

Pre referenciu predkladam riesenie v Perle:

#!/usr/bin/perl

$urlArgs = '=Value1&Key2=Value2&Key3=1999-12-02';

%params = map  { +"\l$$_[0]" => "\l$$_[1]" }
          map  { $$_[1] =~ s/^(\d{4})/$1 < 2000 ? 2000 : $1/e; $_ }
          grep { $$_[0] =~ /^\p{IsUpper}/ &&
                 $$_[1] =~ /^(\p{IsUpper}|\d{4}(-\d\d){2}$)/ }
          map  { [ split /=/, $_ ] }
          split '&', $urlArgs;

print "$params{key3}\n";

Opat linearne pridanie zopar prikazov do existujuceho kodu. Standardny Perlovsky text-processing.

Tiez som si vsimol, ze vo vasom kode ak zadam nespravny vstup; napr:

urlArgs = '=Value1&Key2=Value2'

tak to hodi, vynimku. Moja Perl verzia nespravne hodnoty korektne odfiltruje/ignoruje.

Tak skuste chciet aj osetrit nespravny vstup. Google na vas tiez nevyhodi vynimku ked zadate:

V Perle to bolo osetrene hned na prvy krat.

Sorry, to jakej si programátor se nezjišťuje podle toho, zdali přečteš tu syntaktickou sračku perl ... piš si v něm. Klidně. Ale skutečného programátora to z tebe nedělá.

Perl pouziva rozne specialne znaky pre dobry dovod. Napr. podla

%var = funkcia();

viem, ze funkcia vratila hash/dictionary. V Pythone podla:

var = funkcia()

Neviem o premennej var absolutne nic.

Pravda, nie je to celkom univerzalne ale zvysuje to citatelnost kodu dost zasadne v mnohych situaciach. type(var) (obdoba ref(EXPR) v Perle) je pekna vec ale tu ide o citalenost kodu a nie jeho debuggovanie.

Inak zvlastne, ze ked niekto kritizuje v Pythone vynutene odsadzovanie - tak argument je, ze to zvysuje citatelnost kodu a teda to nemoze byt ponechane na slobodnom uvazeni programatora. Ale ak niekto poukaze, ze jazyk nevynucuje lahke odlisenie zakladnych datovych typov, tak argument je, ze je na programatorovi aby uvazene nazval premenne :)

Pekna linearna verzia. Dokonca zvlada aj urcite nekorektne vstupy. Avsak nie takyto:

$urlArgs = 'key0&&key1=value1&key2=value2'

$params = Hash[*$urlArgs.split(/&/).grep(/([^=]+)=([^=]+)/){[$1,$2]}.flatten]

Hehe, tak to je skvela finta! V Perle by som to zapisal takto:

%params = map { @$_ } grep { /([^=]+)=([^=]+)/ && ($_=[$1,$2]) } split /&/, $urlArgs;

my %params = map { split /=/, $_, 2 } grep { /=/ } split /&/, $urlArgs;

Pekne riesenie. Nie je to sice presne to iste ako predtym uvedene riesenie. Napr. vstup ako:

$urlArgs = 'Key1=Value1a=Value1b&Key2=Value2';

To spracuje inak, ale myslim, ze spravnejsie.

Podobna "priamociara" verzia, ktora neosetruje vsetky nekoretkne vstupy vyzera takto

%params = map { split /=/ } split /&/, $urlArgs;

my %params = map { ( split /=/, $_ )[ 0, 1 ] } split /&/, $urlArgs;

Moj zoznam vyhod:

• mod_perl2
• vela kvalitnych a stabilnych CPAN modulov
• dostupnost na kazdom UNIX-like systeme
• dobra podpora regularnych vyrazov
• podpora unicode
• rychlost
• mne viac-menej vyhovujuca syntax
• programovat v Perle je zabava
• lamy v Perle nekoduju

Nevyhody:

• objektove programovanie je hack (funkcny ale stale hack)
• obmedzena moznost explicitnej typovej kontroly
• primitivny GC

Vsetky nevyhody su opravene v Perl6 - ale ked ten bude hotovy a pouzitelny, tak ja uz budem v dochodkovom veku ;)