🚀 go-pugleaf

W dniu sobota, 22 kwietnia 2017 08:39:33 UTC+2 użytkownik (fir) napisał:

> chodzi o zwykla kompilacje

Aha, czyli np. coś takiego:
                                                                                                                                                                        
(define (compile expression result)                                                                                                                                     
  (match expression                                                                                                                                                     
    ((<*> a b)                                                                                                                                                          
     (let ((a+ (name a))                                                                                                                                                
           (b+ (name b)))                                                                                                                                               
       `(,@(compile a a+)                                                                                                                                               
         ,@(compile b b+)                                                                                                                                               
         (,result = ,a+ ,<*> ,b+))))                                                                                                                                    
    (_                                                                                                                                                                  
     '()))) 

gdzie "name" to coś co zwraca nam nową nazwę dla wyrażenia
(chyba że samo wyrażenie już jest nazwą, to wtedy zwraca to wyrażenie):

(define name                                                                                                                                                            
  (let ((counter 0))                                                                                                                                                    
    (λ (original)                                                                                                                                                       
      (cond ((symbol? original)                                                                                                                                         
             original)                                                                                                                                                  
            (else                                                                                                                                                       
             (set! counter (+ counter 1))                                                                                                                               
             (string->symbol (string-append "t"                                                                                                                         
                                            (number->string counter))))))))                                                                                             

na przykład

(compile '(+ (* a b) (/ c d)) 'result)

zwraca

((t1 = a * b)
 (t2 = c / d)
 (result = t1 + t2))

>  czyli przerobienie tekstu na tekst;

No, ściśle rzecz biorąc chodzi i przerobienie struktury na inną strukturę.
W Lispie szczególne jest to, że wyraża strukturę bezpośrednio,
w sposób jawny i niezawoalowany. (To, co zwróciła moja funkcja,
jest listą trójelementową, choć oczywiście zapisaną w postaci tekstowej)

rzecz w tym, że programista Lispa woli unikać bezsensownych problemów
(takich jak parsowanie czy serializacja), niż rozwiązywać je setki
razy w różnych kontekstach na różne sposoby.

na cholere mam wymyślać różne głupie składnie, jakieś XMLe, pliki
ini, JSONy, YMLe, żeby przechowywać dane, czy różne składnie w rodzaju
Pythona, C, (o zgrozo) C++ itp, do zapisu kodu, skoro to wszystko
jest zasadniczo równoważne temu, co mogę wrazić w lispie?

> wydaje sie ze w tej dziedzinie jakis jezyk ktory
> nie jest tak jak c ufundowany na bajtach i cyklach 
> (c moze nie jest dokladnie ufundowany na bajtach i cyklach,
> ale 'ma je w pamieci') a bardziej na jakims
> rozbiorze gramatycznym czy czyms pokrewnym,
> (czyli w sumie cos lispopodobnego moze) bylby tu lepszy

jest lepszy. ogólnie do przetwarzania struktur programy funkcyjne
są dużo lepsze. Lisp jest moim faworytem, ale w dziedzinie
metaprogramowania na pewno ML ma duże tradycje, no i Haskell

> jak sobie wyobrazam mogloby to dzialac, byla by jakas funkcja 'reduce' ktora bralaby string z wyrazeniem dzilila go na pod wyrazenia i wywolywala sama siebie na podwyrazeniach az dodtarla by to wyrazen z dwoma operatorami ktore moglaby juz zredukowac (czyli pozamianiac na te wpisy t1=a*b ) - to mialoby szanse chyba byc krotkie ale nie chce mi sie co prawda za bardzo nad tym myslec - aczkolwiek bylaby dobra okazja pomyslec w czym taki kod bylby podobny a w czym rozny od kodu w c

tzn. samą ideę można też oczywiście zaimplementować w C, bo
w C można tworzyć funkcje rekurencyjne. tyle że trzeba by było
zaimplementować listy jednokierunkowe (co oczywiście jest łatwe,
ale nie jest trywialne w takim sensie, jak w językach funkcyjnych),
a także operacje na tych listach (np. łączenie dwóch list),
no i oczywiście zastanowić się, jak reprezentować atomy języka
(tzn. symbole i liczby) [zwyczajowo pewnie jako jakąś otagowaną
unię przechowującą wskaźnik na stringa albo wartość liczbową
wyrażenia]