Proč je syntaxe programovacích jazyků tak složitá?

[Ondra Satai Nekola]

Napr. v shellu

Kód: [Vybrat]

cat x | praveJsemNecoSpocital | druhaFunkce > velkyHovno.txt

Všichni kolem jsou debilové, ale s funkcemi víc argumentů tě počítat nenapadlo...

Tak zrovna u shellu těch závorek obvykle není moc potřeba, ani když je těch parametrů víc. Akorát všichni víme, jak je v něm snadné střelit se do nohy.

Bacha, nemichat parametry prikazu a jejich a STDIN/STDOUT.

[Reklama]

[Mirek Prýmek]

Všichni kolem jsou debilové, ale s funkcemi víc argumentů tě počítat nenapadlo...

Já se k tomu náhodou přidávám. Pipe operátor ("|>"), který mívají funkcionální jazyky (např. F#, Elixir. Haskell má podobné "$") je neuvěřitelně návykový. Hlavně proto, že se kód čte zleva doprava a ne obráceně. Funkce více argumentů nejsou větší problém. Osobně jsem si na to hodně zvykl a přijde mi to daleko čitenější než haskellovské skládání využívající curryfikace (YMMV).

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
list |> Enum.reverse() |> Enum.join("/")

# vysledek: "d/c/b/a"

versus

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
Enum.join(Enum.reverse(list), "/")

# vysledek: "d/c/b/a"

(obojí Elixir)

[Honza]

Pro porovnání totéž ve Smalltalku:

Kód: [Vybrat]

list := #( 'a' 'b' 'c' 'd' ).
list reversed joinUsing: '/'.
myslím, že tam je to takhle ještě krapet jednodušší

[listoper]

Pridam pro porovnani clojure:

Kód: [Vybrat]

(def letters `("a" "b" "c" "d"))
(->> letters reverse (join "/"))


[Ondra Satai Nekola]

Všichni kolem jsou debilové, ale s funkcemi víc argumentů tě počítat nenapadlo...

Já se k tomu náhodou přidávám. Pipe operátor ("|>"), který mívají funkcionální jazyky (např. F#, Elixir. Haskell má podobné "$") je neuvěřitelně návykový. Hlavně proto, že se kód čte zleva doprava a ne obráceně. Funkce více argumentů nejsou větší problém. Osobně jsem si na to hodně zvykl a přijde mi to daleko čitenější než haskellovské skládání využívající curryfikace (YMMV).

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
list |> Enum.reverse() |> Enum.join("/")

# vysledek: "d/c/b/a"

versus

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
Enum.join(Enum.reverse(list), "/")

# vysledek: "d/c/b/a"

(obojí Elixir)

Mne $ docela prirostl k srdci, ale vzdy jsem ho chapal jen jako mnohdy sikovnou pomucku a jsem rad, ze "default" je jinak.

Btw - ono je docela zajimave uvazovat o tom, ktere poradi je "vhodnejsi". S vnejsi aplikaci vlevo je zase nejvic po ruce "nejdulezitejsi" operace.

[Reklama]

[v]

Všichni kolem jsou debilové, ale s funkcemi víc argumentů tě počítat nenapadlo...

Já se k tomu náhodou přidávám. Pipe operátor ("|>"), který mívají funkcionální jazyky (např. F#, Elixir. Haskell má podobné "$") je neuvěřitelně návykový. Hlavně proto, že se kód čte zleva doprava a ne obráceně. Funkce více argumentů nejsou větší problém. Osobně jsem si na to hodně zvykl a přijde mi to daleko čitenější než haskellovské skládání využívající curryfikace (YMMV).

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
list |> Enum.reverse() |> Enum.join("/")

# vysledek: "d/c/b/a"

versus

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
Enum.join(Enum.reverse(list), "/")

# vysledek: "d/c/b/a"

(obojí Elixir)

Mne $ docela prirostl k srdci, ale vzdy jsem ho chapal jen jako mnohdy sikovnou pomucku a jsem rad, ze "default" je jinak.

Btw - ono je docela zajimave uvazovat o tom, ktere poradi je "vhodnejsi". S vnejsi aplikaci vlevo je zase nejvic po ruce "nejdulezitejsi" operace.

IMO pro čisté výrazy klasický zápis tak jak se učí na ZŠ a "podle pořadí vyhodnocení" pro výrazy s vedlejšíma účinkama

[operator]

Všichni kolem jsou debilové, ale s funkcemi víc argumentů tě počítat nenapadlo...

Já se k tomu náhodou přidávám. Pipe operátor ("|>"), který mívají funkcionální jazyky (např. F#, Elixir. Haskell má podobné "$") je neuvěřitelně návykový. Hlavně proto, že se kód čte zleva doprava a ne obráceně. Funkce více argumentů nejsou větší problém. Osobně jsem si na to hodně zvykl a přijde mi to daleko čitenější než haskellovské skládání využívající curryfikace (YMMV).

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
list |> Enum.reverse() |> Enum.join("/")

# vysledek: "d/c/b/a"

versus

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
Enum.join(Enum.reverse(list), "/")

# vysledek: "d/c/b/a"

(obojí Elixir)

A takto to má Python (list je klicove slovo):

Kód: [Vybrat]

lst = ['a', 'b', 'c', 'd']
'/'.join(reversed(lst))


[asdad]

'\0' je znak s hodnotou 0 (nikoli znak 0), používá se jako ukončovač c stringů.
Smutné je, že tento znak má označení ASCI NUL, nicméně pro tyto stringy se používá označení "null-terminated" string.

Velikost toho znaku '\0' je 1 znak (jeden char (8 bitů)), velikost NULL pointeru (pokud si to nikdo nepředeklaroval) je roven velikosti datového typu ukazatel (na daném železe)
(číselně mají tento znak i NULL pointer stejnou hodnotu)

Velkost jedneho charu 1 jeden bajt, jeden bajt nemusi mat 8 bitov. ;-)

[operator]

'\0' je znak s hodnotou 0 (nikoli znak 0), používá se jako ukončovač c stringů.
Smutné je, že tento znak má označení ASCI NUL, nicméně pro tyto stringy se používá označení "null-terminated" string.

Velikost toho znaku '\0' je 1 znak (jeden char (8 bitů)), velikost NULL pointeru (pokud si to nikdo nepředeklaroval) je roven velikosti datového typu ukazatel (na daném železe)
(číselně mají tento znak i NULL pointer stejnou hodnotu)

Velkost jedneho charu 1 jeden bajt, jeden bajt nemusi mat 8 bitov. ;-)

Ze char nemusi byt byte, tomu bych veril, ale ze byte neni 8 bitu, to bych rad vedel kde.

[Kadet]

Všichni kolem jsou debilové, ale s funkcemi víc argumentů tě počítat nenapadlo...

Já se k tomu náhodou přidávám. Pipe operátor ("|>"), který mívají funkcionální jazyky (např. F#, Elixir. Haskell má podobné "$") je neuvěřitelně návykový. Hlavně proto, že se kód čte zleva doprava a ne obráceně. Funkce více argumentů nejsou větší problém. Osobně jsem si na to hodně zvykl a přijde mi to daleko čitenější než haskellovské skládání využívající curryfikace (YMMV).

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
list |> Enum.reverse() |> Enum.join("/")

# vysledek: "d/c/b/a"

versus

Kód: [Vybrat]

list = ["a", "b", "c", "d"]
Enum.join(Enum.reverse(list), "/")

# vysledek: "d/c/b/a"

(obojí Elixir)

Mne $ docela prirostl k srdci, ale vzdy jsem ho chapal jen jako mnohdy sikovnou pomucku a jsem rad, ze "default" je jinak.

Btw - ono je docela zajimave uvazovat o tom, ktere poradi je "vhodnejsi". S vnejsi aplikaci vlevo je zase nejvic po ruce "nejdulezitejsi" operace.

IMO pro čisté výrazy klasický zápis tak jak se učí na ZŠ a "podle pořadí vyhodnocení" pro výrazy s vedlejšíma účinkama

Zbytecna komplikace. V APL jazycich neexistuje precedence operatoru, coz masivne zjednodusuje jazyk. Napr.

5 * 4 + 3

Vyhodnoti zprava doleva (5 * (4 + (3))). Otazka jestli lepsi zprava doleva nebo naopak je podle me vec preference.

V APL je to zprava protoze dava smysl prirazovat do promennych zapsanych vlevo.

X: 5 * 4 + 3

Misto

3 + 4 * 5 as X

Tomuhke se rika 'konkatenativni' jazyk. Skladas programy vedle sebe. Muses upravovat precedenci zavorkama dle libosti.

Vice argumetu resis bezne v techto jazycich. V shellu, haskellu nebo forthu to neni problem. V jazyce na kterym pracuju ja se to resi tak ze kazda funkce ma prave dva argumenty. Levej a pravej. Jako scitani a nasobeni napr.

Vychozi precedence operatoru je pouze ucebni pomucka pro prvnacky aby je nematly zavorky.

[asdad]

'\0' je znak s hodnotou 0 (nikoli znak 0), používá se jako ukončovač c stringů.
Smutné je, že tento znak má označení ASCI NUL, nicméně pro tyto stringy se používá označení "null-terminated" string.

Velikost toho znaku '\0' je 1 znak (jeden char (8 bitů)), velikost NULL pointeru (pokud si to nikdo nepředeklaroval) je roven velikosti datového typu ukazatel (na daném železe)
(číselně mají tento znak i NULL pointer stejnou hodnotu)

Velkost jedneho charu 1 jeden bajt, jeden bajt nemusi mat 8 bitov. ;-)

Ze char nemusi byt byte, tomu bych veril, ale ze byte neni 8 bitu, to bych rad vedel kde.

DSP, pozrite sa na makro CHAR_BIT ;-)

[operator]

'\0' je znak s hodnotou 0 (nikoli znak 0), používá se jako ukončovač c stringů.
Smutné je, že tento znak má označení ASCI NUL, nicméně pro tyto stringy se používá označení "null-terminated" string.

Velikost toho znaku '\0' je 1 znak (jeden char (8 bitů)), velikost NULL pointeru (pokud si to nikdo nepředeklaroval) je roven velikosti datového typu ukazatel (na daném železe)
(číselně mají tento znak i NULL pointer stejnou hodnotu)

Velkost jedneho charu 1 jeden bajt, jeden bajt nemusi mat 8 bitov. ;-)

Ze char nemusi byt byte, tomu bych veril, ale ze byte neni 8 bitu, to bych rad vedel kde.

DSP, pozrite sa na makro CHAR_BIT ;-)

Tam se nikde nehovori, ze byte neni 8 bitu.

[asdad]

'\0' je znak s hodnotou 0 (nikoli znak 0), používá se jako ukončovač c stringů.
Smutné je, že tento znak má označení ASCI NUL, nicméně pro tyto stringy se používá označení "null-terminated" string.

Velikost toho znaku '\0' je 1 znak (jeden char (8 bitů)), velikost NULL pointeru (pokud si to nikdo nepředeklaroval) je roven velikosti datového typu ukazatel (na daném železe)
(číselně mají tento znak i NULL pointer stejnou hodnotu)

Velkost jedneho charu 1 jeden bajt, jeden bajt nemusi mat 8 bitov. ;-)

Ze char nemusi byt byte, tomu bych veril, ale ze byte neni 8 bitu, to bych rad vedel kde.

DSP, pozrite sa na makro CHAR_BIT ;-)

Tam se nikde nehovori, ze byte neni 8 bitu.

https://en.cppreference.com/w/cpp/types/climits

pozrite sa na DSP ak viete co to je. A veci, o ktorej vy rozpravate sa spravne nazyva oktet. https://en.wikipedia.org/wiki/Octet_(computing)

[hawran diskuse]

...
Velkost jedneho charu 1 jeden bajt, jeden bajt nemusi mat 8 bitov. ;-)

Šmarjá.

[hawran diskuse]

...
https://en.cppreference.com/w/cpp/types/climits

pozrite sa na DSP ak viete co to je. A veci, o ktorej vy rozpravate sa spravne nazyva oktet. https://en.wikipedia.org/wiki/Octet_(computing)

To by mne zajímalo, co si tím kompenzuješ...