Portál AbcLinuxu, 6. května 2025 14:37
(display "Hello World!")(newline)
21.9.2007 07:49
freshmouse | skóre: 42
| blog: Bruno Banány
.
21.9.2007 14:39
Luboš Doležel (Doli) | skóre: 98
| blog: Doliho blog
| Kladensko
Na dokopávání se pracuje , ale čas velí zatím jinak. Je pravda, že začít takhle (↑) asi není úplně vhodné. Já se jen bojím, aby - kdybych něco takového začal psát - aby to neskončilo jako pouhý plagiát SICP. To se totiž dá jen velmi těžko přebít, a tak kvalitní učivo člověk z hlavy prostě vytlačit nedokáže. Na druhou stranu, směska poznatků ze studia Bible...totiž co to říkám, SICP (i když pro lispery to je totéž ) a věcí specifických pro Gauche, které je docela pěkně udělané (a navíc jsem si pro něj udělal balíček a jsem líný používat něco jiného ), by mohla být použitelná. Nicméně jediný použitelný algoritmus, který mě napadá, je časově trošku náročnější. Teď mě omluvte, půjdu pozřít ještě nějaké lispohlávky.
Do studia celé SICP by se poustil asi jen opravdu vážný zájemce o Scheme. Zato občasné články napsané člověkem, který už o Scheme něco ví (třeba i inspirované SCIP, na tom není nic špatného), navíc psané se zaměřením na jednu z těch opravdu praktičtěji použitelných implementací, by možná přilákaly ke Scheme více lidí.
S chutí do toho a půl je hotovo. Neber to zas tak zodpovědně. Sem tam další díl případného seriálu, to tě nezabije.
Já už plánuju naučit se Scheme a Haskell asi rok, ale z nedostatku času na podrobnější studium jsem se nedostal dál než k úplným trivialitkám. Nakonec to dopadne tak, že se k nim dostanu až teď v Neprocedurálním programování na MFF. A i tak mám dojem, že to bude zaměřeno spíše na Prolog, takže si Scheme a Haskell nakonec stejně budu muset nastudovat sám.
Nevíte někdo, jestli se dá ta kniha koupit tady u nás? Nebyl by problém si ji objednat ze zahraničí, ale takhle by to bylo jednodušší.
Asi jsem měl štěstí. Nicméně i za ty dva tisíce je to levné, ten obsah má cenu zlata. Není žádný substituent, knížek o algoritmech je kupa, prakticky o každém jazyku taky, ale tahle učí, jak myslet, a v žádné jiné nic podobného není.
Mno, mám tu zbytečnou, nikdy nepoužitou knihu "Mistrovství v C++", jejíž prodej by mi mohl pár stovkama pomoct. Teď to řešit nebudu, ale v brzké době si asi vážně SICP koupím. Kdybych furt jenom čekal a čekal, tak ji nebudu mít nikdy.
A ani mě to moc neláká, moc se mi ten jazyk nelíbí. Více se mi líbí čisté Céčko, už jen z čistě estetických důvodů.
Takže to Mistrovství asi někomu střelím, něco málo přidám a pořídím si SICP. Ještě jednou bych se rád zeptal: dá se ta kniha koupit i tady v ČR?
C++ a Java inak nie su zle jazyky. Problem je, ze ich tlacia ludom do hlavy este predtym, kym sa naucia programovat (vymyslat algoritmy) a nepovedia im, ze existuju aj ine (lepsie) alternativy (ktore by ich prave mysliet naucili). Tak sa nam rodia zastupy cvicenych opic pripravenych pisat 
21.9.2007 07:15
21.9.2007 09:15
22.9.2007 12:10
public static int … az do konca zivota.
C++ (a v mensej miere aj Java) je ale dobry jazyk, ked uz clovek programovat vie a rovnako vie, preco ho chce pouzit (typicky rychlost programu alebo sprava pamate). Skoda len, ze takych ludi je desiva mensina. Tolko moj dnesny povzdych
s vyse uvedenym clankem je potiz -- ze vlastne krome par vtipku a strucneho uvodu nic neresi... ani prefixovou notaci, natoz proces vyhodnocovani, na toz vubec podstatu lisp-like jazyku.... mozna by to chtelo cely serial malinko zhutnit...Přesně o to mi šlo – není problém napsat pár článků o syntaxi Scheme, o tom, jak se píšou podmínky atd. Ale zrovna u jazyků LISPovské rodiny je celkem vhodné se rozepsat i o jejich podstatě a filozofii. A to už není jen tak... No bezva, tak to už jsme dva, kdo budeme na Kyosukeho vyvíjet mírný nátlak v mezích zákona.
), KMP algoritmus rozebraný na kousky, LCS a diff, Wrightův pattern matcher, Kiselyovův XML parser, podpora asi třiceti SRFIček...seznam je pekelně dlouhý.
Tam ocením spíš fíčury a všeobecnou použitelnost. Co je však efektivní, to je spouštění toho zkompilovaného kódu. Startup time je minimální, takže i unixoidní (krátké, často spouštěné) skripty v něm mají docela smysl. Když to kamarádovi stačí na realtimové řízení, asi těžko budu víc náročný.
(A vůbec, co je to "kompletní program"?)
Ale nepotřebuju ho, tak jsem ho zatím nezkoušel. Jen vím, že tahle implementace je hodně poctivá, ze skušeností kamarádů.
A trošku to ukazuje, že Shiro Kawai to myslí fakt vážně.
Viz článek De-Scheming MIT.
, ale však taky ten předmět míří spíš k robotice než k softwarovým abstrakcím. Jsem si jistý, že Hal Abelson, jeden s příznivců nových osnov, určitě na svůj oblíbený jazyk nezanevřel jen proto, že by Python byl najednou nějak zázračně lepší na věci, na které dosub bylo (a věřím, že i bude) lepší Scheme. Nový předmět prostě řeší jiné věci a člověk přeci nebude dělat textový editor ve Fortranu ani simulátor elektrických obvodů v COBOLu. Python studentům pro ty jednoduché věci bude bližší než Scheme a určitě to není špatná volba pro ty, co nechtějí celý život psát kompilátory.
(Hint: Důvody pro výběr jazyka mohou být všelijaké, a hlavně, většinu strojových cyklů stráví Google v C++, protože Python na to nemá (i když kompilátor Common Lispu by mít mohl - za šílené licenční sumy ovšem), a obsluhuje ty vyšší vrstvy.)
seznam[::-1] zvykl na (reverse seznam) protože to druhé je oproti tomu prvnímu šíleně nečitelné a nepraktické. </rejp>
<type 'reversed'>". Netuším, co to má znamenat (představuju si, že typy pasují skutečně k typům hodnot, jako je float, int, list a podobně), ale moje představa je taková, že objektový jazyk by mohl mít něco jako univerzální API pro sekvence - jako že když nad objektem zavolám o.reversed(), vrátí mi objekt stejného typu, jen pozadu. Když chci udělat vlastní typ s rozhraním sekvence, netuším, jak ho pro reversed(o) přetížím (pokud Python nemá CLOSoidní objektový systém, jako má třeba Gauche), leda, že bych všude psal type(a)(reversed(a)), což je ukrutné. A o.reverse() je zase destruktivní.
Koukám teď, že sorted(o) bude téhož zrna. Nemám námitky proti Pythonu jako jazyku (nebo jen víceméně malé), ale spíš proti takovýmhle věcem. Jak píšu jinde, ve Scheme leckdy název funkce a způsob jejího použití jednoduše uhádnu (a nemusím hledat), páč je to mírně konzistentnější, což mi je velmi milé. Ale to možná je jen věc vkusu, různí lidé si standardní knihovnu asi mohou představovat jinak.
Nicméně otázka, jaký přístup k iterování datových kolekcí je nejlepší, zůstává obecně stále otevřená (třeba [1], [2], [3], [4]). Skoro se zdá, že každý jednotlivý přístup je dobrý tak na 80-90 % věcí a chtít po něm i zbytek smrdí problémem. (Hmm, aspoň budou mít teoretici spoustu zábavy na příští desítky let. ) V kontextu Pythonu generátory zapadají velice pěkně, o tom žádná.
Rozumný člověk by použil nějakou knihovnu pro numerickou matematiku (nebo rovnou Cčko), ale myslím, že ani ve Scheme to nemusí být tak strašné. Hmm, budu si to muset zkusit. Myslím, že v Gauchi to nebude taková hrůza. V Pythonu se zase blbě symbollicky derivuje. Asi každý jazyk má to svoje. A globální proměnné? Proč globální proměnné, když člověk má uzávěry? Nemyslíš jen obyčejné volné proměnné? Možnost definovat související funkce uvnitř daného obklopující formou (definicí funkce, příkazem let...) tak, aby mohly používat společnou proměnnou, mi přijde jako krásná, jak funkčně, tak esteticky.
21.9.2007 23:51
;; Funkce přijímá matici A velikosti (m x n) [(sloupce x řádky)]
;; a matici B velikosti (o x m). Vrací matici
;; velikosti (o x n).
(define (mmul A B)
(let ((m (array-length A 1)) ;; Počet sloupců matice A (vlevo)
(n (array-length A 0)) ;; Počet řádků matice A (vlevo)
(o (array-length B 1))) ;; Počet sloupců matice B (nahoře)
(tabulate-array (shape 0 o 0 n) ;; Generujeme prvky výsledku
(lambda (i j) ;; (o x n) po řádcích.
(sum-ec (: k 0 m) ;; Sečteme pro všechny
(* (array-ref A i k) ;; sloupce A a řádky B
(array-ref B k j)))))))
Ale nejsem až taký dobrý schemař, třeba mě časem napadne i něco lepšího. S vícerozměrnými poli ve Scheme si teď hraju vůbec prvně a to API neznám. Tohle ale IMHO vypadá celkem rozumně.
PS. Diky za upozorneni na SRFI, to jsem neznal.
Za prve, LispMe prostredi je hodne spartanske, a ja ho musel pouzit, protoze jsem nic jineho k ruce nemel (i kdyz je fakt, ze jsem se Scheme trochu naucit chtel).Já myslím, že od prostředí s pár sty kilobajty se toho zas až tolik čekat nedá...
Patrne proto jste pouzil funkce z urcite (ne)standardni knihovny, ktere tuto komplikaci odstinuji.Standardní. Ale upozorňuji, že to nejsou všechno funkce, comprehensions jsou syntaktické rozšíření (ostatně je máte i v Pythonu). Nicméně tahle rozšíření prošla peer-review, jsou již několik let v platnosti a většina dobrých implementací je přijala. (Stejně jako se časem přidávaly věci do Pythonu.) Pokud jde o použitelnost, s tím se dá souhlasit: Dost často je dobré mít nástroj bližší běžným potřebám. I proto (pokud jde o Scheme) používám Gauche, které mě nenutí dělat spoustu i z mého pohledu zbytečných věcí (ilustrativní jsou třeba regexpy a jejich přímá aplikace jako v Perlu nebo Ruby, namísto toho, abych s nimi musel proskakovat nějakými funkcemi). Ostatně i Python je taková praktičtější verze Lispu, tedy aspoň to tvrdí Peter Norvig.
A vůbec, já netvrdím, že Python je špatný jazyk. Mně jen odradil určitý vnitřní bordel v implementaci, když jsem se pokoušel pochopit jazykový model, abych mohl kupříkladu dělat bindingy, nebo se vrtat v runtimu a tak. A příšerně rozházená standardní knihovna, prakticky bez jakýchkoli konvencí, což mě nutilo hledat v dokumentaci a nemohl jsem hádat (= používat intuici), kteýžto postup v Ruby a Gauche prakticky zaručeně funguje a frustruje mě podstatně méně. Jinak jako jazyk (gramatika, sémantika a podobně) je moc fajn, na tom se určitě shodneme.
Jde o to, ze funckionalne clovek (tj. v rekurzivnich smyckach misto iterativnich smycek) clovek dost casto neuvazuje. Patrne proto jste pouzil funkce z urcite (ne)standardni knihovny, ktere tuto komplikaci odstinuji.Ano, takto uvažuje mnohem častěji implementátor jazyka než jeho uživatel. Nicméně v lispovských jazycích může být uživatel jazyka sám sobě jeho implementátorem a tak mu je tail recurision poskytnuta jako základní prostředek k vlastním implementacím jazykových fíčur. Od toho, aby člověk používal konstrukce méně abstraktní a více názorné, jsou tu makra a funkce vyššího řádu (někdy je lepší to, někdy zase ono, a řeší to tak i Python a přiznává to i Guido). Tvrdit, že Scheme je špatné, protože řeší smyčky rekurzivní aplikaci procedur, je asi tak moudré, jako tvrdit, že Cčko je špatné, protože má goto a protože všechny ty whily a fory nakonec skončí jako
Jc <adresa>. Nikdo nikoho v Cčku nenutí psát smyčky pomocí goto. (Když už jsme u těch analogií. )
gosh> (use gauche.array) #<undef> gosh> (define A #,(<array> (0 2 0 2) 10 2 0 -3)) A gosh> (define B #,(<array> (0 2 0 2) 2 1 -1 2)) B gosh> (array-mul A B) #,(<array> (0 2 0 2) 18 14 3 -6) gosh> (array-expt A 2) #,(<array> (0 2 0 2) 100 14 0 9)(Aneb "vždycky se podívej pořádně, co vlastně máš ve standardní knihovně svého jazyka..."
)
(define A '((1 0 2) (-1 3 1)))
(define B '((3 1) (2 1) (1 0))) ;; testovaci matice A, B
(define multiply_matrix
(lambda (A B)
(let create_rows ((A A))
(if (null? A)
'()
(cons
(let create_member ((B B))
(if (null? (car B))
'()
(cons (apply + (map *
(car A)
(map car B)))
(create_member (map cdr B)))))
(create_rows (cdr A)))))))
(multiply_matrix A B) :==> ((5 1) (4 2))
(define multiply_matrix
(lambda (A B)
(map (lambda (x)
(let create_member ((B B))
(if (null? (car B))
'()
(cons (apply + (map *
x
(map car B)))
(create_member (map cdr B))))))
A)))
(define (matrix-multiply a b) (map (lambda (lx) (map (lambda (ly) (apply + (map * lx ly))) (matrix-transpose b))) a))
(define (matrix-multiply a b) (map (lambda (lx) (map (lambda (ly) (apply + (map * lx ly))) (apply map list b))) a))BTW, je to takhle o dva znaky kratší - jak že bylo to řešení v Pythonu na tři řádky?
(Ale moje námitka ohledně efektivity zůstává, a to mlčím i o tom array-mul, co jsem nakonec v Gauche našel. )
(map <něco> A)) byl celkem jasný a na konec (transpozici) jsem přišel kdysi před lety ještě v Pythonu (akorát tam jsem ho dělal přes b_transposed = zip(*b) ), jen ta věc mezi tím mi nějak ušla. Bídáku! A já mám jít spát střízlivý, jo? A ještě s map a apply kroužícími hlavou. (Hmmm, to ale taky není zrovna nejlepší naplnění slova "střízlivý"... )
(apply map list '((1 2 3) (4 5 6)))
=>
(map list '(1 2 3) '(4 5 6))
=> ;; (map f list1 list2 list3 ... listn) -> \
(cons (f (car list1) (car list2) (car list3) ... (car listn))
(map f (cdr list1) (cdr list2) (cdr list3) ... (cdr listn)))
(cons (list 1 4) (cons (list 2 5) (cons (list 3 6) '())))
=>
'((1 4) (2 5) (3 6))
t([[]|_]) -> []; t(X) -> [ [ H || [H|_]<-X ] % cut heads | t([ T || [_|T]<-X ]) % transpose tails ].Ten scheme map je něco jako erlangový zipwith, ale zipwithN. Je to mnohem pružnější, protože erlangový map umí pracovat jen s jedním seznamem.
(map * lx ly) o kousek vlevo byla "brnkačka", tak snad není problém pochopit ani tohle.
apply definováno tak, že poslední argument (zde b) musí být seznam, který se připojí na seznam argumentů volané procedury. Všechny předchozí s výjimkou prvního se připojí před něj, a první poslouží jako operátor. Názorněji: (apply + 1 2 3 '(4 5 6)) je totéž, co (+ 1 2 3 4 5 6). (BTW, apply přece taky patří do "brnkačky"... )
Co že tam přesně nesedí? (BTW, nenárokuju si genialitu, takže je klidně možné, že mi někde něco ušlo. )
(apply map list '((1 2 3) (4 5 6))) => (map list '(1 2 3) '(4 5 6))me z toho leze:
(apply map list '((1 2 3) (4 5 6))) => (map (list '(1 2 3) '(4 5 6)))
Jako že (apply a b c) vede na `(a (b ,@c))? Jaký by to mělo smysl? U mně (apply a b c) zásadně vede na `(a b ,@c), a je to tak i ve specifikaci.
, a dokonce i já to přečtu a pochopím (a to už je co říct, protože na tohle jsem fakt tupej ). Nicméně praktické aspekty numerických výpočtů leží asi jinde - seznamy seznamů žerou paměť, dost často bourají koherenci přístupů do cache a občas i kazí asymptotickou složitost (aspoň v některých případech).
A navíc právě tohle bude asi kód, který napsal předřečník a bylo mu z toho následně šoufl. Gauche mi dovoluje homogenní vícerozměrná pole a dobrovolně si je pro matice odpírat nebudu. Apropos, pokud jde o eleganci, Váš kód ve Scheme je krásný, nicméně nedemonstruje nádheru lambda kalkulu. Stejný kód se dá použít za použití pouze základní funkcionality lambda kalkulu, doporučuji zkusit zapsat za domácí úkol.
(Hint: Většina lisperů si Lisp před jinými podobnými jazyky vybere kvůli možnosti tvorby jazykových abstrakcí, ne proto, že se v něm dá všechno zapsat rekurzivní manipulací se seznamy - i přesto, že teoreticky to samozřejmě jde. Samozřejmě, kazdý by si to měl zkusit, naučit se to - a taky se naučit, kdy to není zrovna dobrý nápad.)
Globální (dynamicky vázané) proměnné se (aspoň v CL) docela hodí pro defaultní parametry funkcí, pokud je jeden netouží psát. Jak tohle řešit bez nich?
clhs pro write:
Parameter Corresponding Dynamic Variable array *print-array* base *print-base* case *print-case* circle *print-circle* escape *print-escape* gensym *print-gensym* length *print-length* level *print-level* lines *print-lines* miser-width *print-miser-width* pprint-dispatch *print-pprint-dispatch* pretty *print-pretty* radix *print-radix* readably *print-readably* right-margin *print-right-margin*
A pořád mi není jasné, jak se principiálně liší globální proměnná od globální funkce - a ty snad ve Scheme jsou morálně bez problému, ne? Ostatně měl jsem za to, že globální proměnné tam taky máte.
Jinak místní schemeři (little, seasoned i reasoned) mě asi nebudou mít rádi, ale myslím, že pro praktické účely je CL často použitelnější (aspoň pokud mluvíme opravdu o holých standardech), byť nabízí více možností a tak je méně čisté - zmiňované do macro (v obou standardech) je IMHO opravdu pruda a méně čitelné než obdobná loop konstrukce. Kromě toho je k dispozici i funkcionálně čistší kombinace map/reduce (což je možná ve scheme taky, ne? Nebo si to lze aspoň napsat s rekurzí), a samozřejmě i ta proklatá rekurze :)
zmiňované do macro (v obou standardech) je IMHO opravdu pruda a méně čitelné než obdobná loop konstrukce.A právě proto máme základní odpověď na scoping, control flow a vůbec, totiž SRFI-42.
22.9.2007 14:20
zoul | skóre: 43
| blog: ☂
| Boskovice
Olomouc, no jo ta stodola na kopci.
Stodola pod kopcem. A mám pocit, že ta stodola tady byla dřív než Praha.
Jinak v komerci jazyk na .... moc sem si zneho neodnesl a v realu jsem ho uz nevidel.
Každému co jeho jest. Je dobře, že v komerci moc není -- zmizela by část vhodnosti pro výuku.
LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot.btw. osobne muzu rict, treba ze az diky uzaverum ve schemu se me podarilo poradne pochopit anonymni tridy v jave... a pak ze to s realnym svetem nema nic spolecneho.
Já osobně nefandím tolik Linuxu, jako OpenSource obecně.
24.9.2007 21:26
delej má obsahovať funkciu, ktorá sa má volať. V tom prípade to bude takto (s ešte malo úpravou, kedy tá funkcia bude brať ako argument počítadlo)
(define (pokud od do delej)
(cond ((>= do od)
(delej od)
(pokud (+ 1 od) do delej))))
A volať sa to bude takto
(pokud 1 5 (lambda (x) (display x) (newline)))Citácia tu nikde potrebná nebude. Dá sa síce napísať makro, ktoré by to volanie
pokud expandovalo na (do - od + 1) volaní zadaného kódu delej, ale to Vy zjavne nepotrebujete.
(#f #f) coby parametr if-u mělo mít hodnotu?
Tiskni
Sdílej:
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.