• uvod
• Ceckarske knihovny X lisparske
• Stavba lispovych knihoven
• Male porovnani
• Hashovaci tabulky
• Autoload
• Kontextova napoveda
• Debugger
• Objekty-CLOS
  • Definovani trid
  • Instance
  • Dedicnost
  • Vicenasobna dedicnost
  • Genericke funkce a metody
  • Kombinovani metod
  • V cem se lispovske objekty lisi?

Uvod

Ceckarske knihovny X lisparske

1. V cecku neni mozne zjistit pocet parametru funkce-je nutne ktomu pouzivat dost zmotany formatovaci retezec co celou vec dost komplikuje a blbe se uci.
2. Neni mozne zjistit jakeho typu jsou parametry a pokud maji ruznou delku na nekterych architekturach neni mozne ani poznat kde nejaky parametr zacina a kde konci. Musime proste verit ze formatovaci retezec je spravne. Pokud ne buh nas chran abychom neslapli do nejake zakazane pameti a nevyvolali segfault nebo jeste neco horsiho. Neni dokonce ani moznost zjistit jestli je treba tenhle kus pameti brany jako ukazatel spravne tedy jestli ukazuje na neco rozumneho.
3. Neni mozne zavolat funkci z promenym poctem parametru stejne jako byla zavolana funkce volajici teda printf nemuze volat fprintf(stdout,parametry co dostala) a musi volat vprintf co uz bere parametry predkousane. Taky treba nemuzeme pomoci jdenoho printf vytisknout n clenu pole kde n je promena proste tim ze bychom si udelali formatovaci retezec a pak tech prvnich n clenu nejak printfu predali
4. Cecko nema zadny dobry system na rizeni chyb vzniklych ve funkcich vetsina funkci proste vypise chybove hlaseni-hlavne matematicke nebo vyvola nejaky signal-treba free nebo malloc ale vetsinou se zneho moc nedozvite a neni zadny centralni mechanizmus na osetrovani takovych chyb. Vetsina funkci se ani moc nehlida a mlcky se predpoklada ze je vsechno vporadku.
5. Cecko nema moc dobrych zpusobu na predavani nejakych pridavnych parametru jako jsou treba parametry v shellu(myslim treba ls -l) Musi se to delat but tak ze se parametr predava vzdycky a nebo predavat nejakou promenou. Jinak by fprintf bylo zbytecne proste bychom printf dali prepinac -output
6. Jsou tu problemy z nestandanrdnosti alokace pameti v cecku-muze se pouzivat malloc ale take to muze byt normalni pole nebo momoci alloca v zasobniku. Proto treba vsprintf nemuze prodlouzit retezec kdyz tistena data se tam uz nevejdou. Dokonce ani nema sanci zjistit jak velke pole je. Proste musi verit tomu ze pole je dost velke a ze neslapne vedle. To ale nemusi byt pravda.
7. Neni tu zadny standard na rozsirovani tekovychto konstrukci - je tu treba "sita na miru" funkce register_printf_function
8. Vsechny ostatni problemy na ktere jsem zapomel

1. Pocet parametru: Parametry funkce dostane v listu-v parametrech date & rest x a x je potom list co obsahuje vsechny parametry funkce co nebyly predany jinak tedy printf by vypadal nejak takhle:
   (defun printf (format & rest parametry) kod)
   spocitat pocet prvku listu je jednoduche - jde to udelat pomoci smycky a samozdrejme ze je pro to funkce length zminena v predchozi skolicce
2. typy: Kazdy obhekt vi svuj typ. Takze si to muzete o jednotlivych parametrech zjistit a bylo by to zahodno to udelat a vybombit chyby
3. Volani z promenym poctem parametru: Protoze si muzu do nejake promene vytvorit list z jejim volanim a potom tento list nechat vyhodnotit a tim ji zavolat to samozdrejme mozne je. Take ktomu slouzi append. treba kod printf by byl:
   (append fprintf stdout format parametry)
   Append bere posledni parametr jako list a prida ho k ostatnim parametru.
4. Chyby:
   Rizeni chyb jde v lispu udelat moc zpusobama-treba ceckarsky udelat nejakou funkci errno a vracet string z chybou a pritom errno nastavit. nebo udelat nejaky zberac chyb jako jsou signaly proste funkci co se zavola pri vzniku chyby a moc dalsich veci. Taky otestovani chyb v lispu jde udelat lepe protoze si funkce muze testovat pocet a typy svych parametru.
5. Pridavny parametry:
   Protoze volitebny pocet parametru je v lispu sranda jde udelat funkce z promenym poctem parametru kde se bezne pouzivaji jen n prvnich a dalsi pouzit prave pro predavani optionu. Protoze slova od : jsou konstanty jde predavani delat treba (jmenofunkce normalparametry :test testovacifunkce) Takze treba funkce OPEN bere jeden parametr se jmenem a potom parametry jako :io :append :overwrite apod. A hned je pouzivani jednodusi. A kdyz clovek od funkce potrebuje neco vic-otevirat pro zapis proste se jukne do manualu a ono to tam vetsinou je. Clisp ma na to dokonce rozsireni v definici funkce-& key jestli si pamatujete od minule skolicky. Takze tenhle styl predavani jde celmi jednoduse.
6. O allokaci pameti se staraji objekty-proste objekt vytvorite pamet se mu automaticky prideli a pridava nebo ubira se jak je treba stara se o to vlastni interpretr zcela dynamicky. Tenhle problem v lispu proste nenastane.
7. To neni chyba jazyka ale spis navrhu knihoven. V common lispu se ten standard jmenuje CLOS

Stavba lispovych knihoven

1. Funkce member nemusi pracovat z listama ale treba z polema. To znamena ze je genericka-sama si zjisti typ co dostala a podle toho se zachova. Je to typicky priklad funkce co pracuje ze sekvencema. To je typ co ma nekolik casti a na kazdou tu cast se da pristupovat pomoci genericke funkce elt coz je funkce co vrati n. prvek sekvence. Pomoci ni a jeste dalsi genericke funkce length co zjisti delku sekvence uz member jde jednoduse napsat a bude fungovat taky na vsechny sekvence-samozdrejme ze funkce member ma urcite specialni optimalizovany kod pro listy kde tenhle pristup by zdrzoval.
2. Co treba kdyz potrebujeme zjistit jestli je v sekvenci nejaky string? No to je vpodstate stejny problem jenom misto eql tedy zjistovani jestly jsou objekty schodne pouzijeme jinou funkci. To by v cecku znamenalo delat novou funkci. Ale v lispu jednoduse pridame parametr :test co umoznuje definovat novou testovaci funkci. Samozdrejme ze takovych optionu ma member vic. Treba test-not apod.

(member "neco" *modules* :test #'string-equal)

Projde list v promene *modules* jestli neobsahuje retezec neco a pritom bude pouzivat funkci na porovnavani retezcu. Jak vidite to dela z funkce co by v cecku nestala za rec hrozne sikovnou funkci co umi nahradit hodne smycek ktere citelnosti programu nepridaji. Tad si presdstavte ze by jste v cecku delali ze jedna funkce includi fajly a druha ma za ukol zjistit jestli byl fajl uz zincludenej nebo ne-museli by jste udelat jdenosmerne vazany seznam struktur co by obsahovaly string. Funkce co pridava fajly by musela dynamicky naalokovat misto pro nazev a otestovat chyby naalokovat misto pro strukturu a okestovat chyby a pridat do listu-nastavit ukazatel na dalsi a startovaci ukazatel listu. Funkce na testovani by musela list prochazet a pomoci strcmp porovnavat atd. A vidite v lispu si proste vytvorite prazdny list:

(setq *modules* ())

(pop jmeno *modules*)

Takhle nejak by se dalo udelat printf funkce v lispu:

Napred by bylo treba napsat funkce na praci ze streamy a nejaky streamovy typ,funkce pro praci z fajlovymi streamy i streamy co ze sapisujou do stringu-aby se dalo udelat sprintf. Potom napsat generickou funkci print co jako prvni parametr bere co ma vypsat a jako mozny druhy kam-stream jinak si sama dosati stdout a dal nejake ty formatovaci optiony. Jako :hex. Zaklad by byla na psani stringu-ta by byla jednoducha proste zapis do streamu. Potom by se udelaly ostatni co by tu na string volaly-taky celkem jednoduche. A mame tisteni na uplne vsechno-neni to snadne? No a aby to bylo jeste hezci mohlo by se dodelat funkce printf co by brala vic parametru a na kazdy by zavolala print a navic by umoznovala pametry:

(printf 2 :bin "ahoj" "caf")
 =>10ahojcaf

1983

prvni xt

1984

Rozsireni sharpa MZ-800 sinclairu a podobnych Z-80 pocitacu Tusim ze taky rok standarizace ansi-c a prvni AT msdos 2.0 z castecnou podporou harddisku V ty dobe se o C++ jeste nikomu nesnilo

          (setq nums '(1 3 2 6 5 4 0))
               => (1 3 2 6 5 4 0)
          (sort nums '<)
               => (0 1 2 3 4 5 6)
          nums
               => (0 1 2 3 4 5 6)

#include < stdio.h> 
#include < stdlib.h> 
int nums[] =
{1, 3, 2, 6, 5, 4, 0};
int
compar (const void *a, const void *b)
{
  return (*(int *) a - *(int *) b);
}
void
main (void)
{
  int i;
  qsort (nums, sizeof (nums) / sizeof (int), sizeof (int), compar);
  for (i = 0; i < sizeof (nums) / sizeof (int); i++)
    printf (" %i " , nums[i]); 
  printf (" \n" );
}

((ahoj . hallo) (pocitac . computer))

(make-hash-table)

gethash KEY TABLE &optional DEFAULT

(setf (gethash klic table) hodnota)

a takhle je autoload udelany v common lispu:
tech , a ` si nevsimejte ty urcuji postup expandovani makra-co expandovat a co ne ` funguje stejne jako ' ale bere jako parametr list a pomoci , se da zrusit ucinek na vybrany parametry

(defmacro defautoload (name module)
  `(defun ,name (&rest argument-list);vytvorime tu funkci
     (autoloader ',name ,module argument-list)))  ;telo vytvarene 
;funkce-zavolani autoloader

(defun autoloader (name module argument-list) ; tohle se zavola pri 
;prvnim pouziti
  (unless (member module *modules* :test #'string-equal) 
;uz byl modul nahran-je module
;clenem posloupnosti modules 
;pritom pouzivej testovaci 
;funkci co porovnava stringy
;v cecku by to byla celkem
;slusna smycka :)
          (fmakunbound name)
          (load (merge-pathnames module si::*system-directory*)))
        ;nebyl-nahrajeme
  (apply name argument-list));a zavolame-presne jak jsem rikal

Strukturovane typy

(defstruct 
    jmeno-prvni-promene
    jmeno-druhe-promene atd)

(defstruct blb jedna dva tri)

> (make-blb)
#s(BLB :JEDNA NIL :DVA NIL :TRI NIL)

> (make-blb :jedna 1 )
#s(BLB :JEDNA 1 :DVA NIL :TRI NIL)

> (blb-jedna blb);prohlidnout si hodnotu
NIL
a jak jsem psal v predchozi skolicce:
> (setf (blb-jedna blb) 2);nastavit hodnotu
2
> (blb-jedna blb);a uz je zmenena
2

Kontextova napoveda

(defvar vc-default-back-end nil
  "*Back-end actually used by this interface; may be SCCS or RCS.

Debuger

Oobjekty-CLOS

Definovani trid:

   (DEFCLASS class-name (superclass-name*)
     (slot-description*)
     class-option*
   )

   :ACCESSOR function-name
   :INITFORM expression
   :INITARG symbol

   (defstruct person
     (name 'bill)
     (age 10)
   )

   (make-person :name 'george :age 12)

   (defclass person ()
     ((name :accessor person-name
            :initform 'bill
            :initarg :name
      )
      (age :accessor person-age
           :initform 10
           :initarg :age
   ) ))

Instance

   (MAKE-INSTANCE class {initarg value}*)

   (make-instance 'person :age 100)

  (defun make-person (name age)
    (make-instance 'person :name name :age age)
  )

   [cl] (setq p1 (make-instance 'person :name 'jill :age 100)) ;vytvorime
   #< person @ #x7bf826> ;zase jiny format tisteni..v clispu bezne

   [cl] (person-name p1);chceme jmeno
   jill

   [cl] (person-age p1);chceme stari
   100

   [cl] (setf (person-age p1) 101);zmenime jmeno
   101

   [cl] (person-age p1);zmenime stari
   101

   [cl] (slot-value p1 'name)
   jill

   [cl] (describe p1)
   #< person @ #x7bf826>  is an instance of class
        #< clos:standard-class person @ #x7ad8ae> :
   The following slots have :INSTANCE allocation:
   age     101
   name    jillian

   :ACCESSOR  --  sjednoceni
   :INITARG   --  sjednoceni
   :INITFORM  --  prepise

   [cl] (defclass teacher (person)
          ((subject :accessor teacher-subject
                    :initarg :subject
        ) ))
   #< clos:standard-class teacher @ #x7cf796> 

   [cl] (defclass maths-teacher (teacher)
          ((subject :initform "Mathematics"))
        )
   #< clos:standard-class maths-teacher @ #x7d94be> 

   [cl] (setq p2 (make-instance 'maths-teacher
                    :name 'john
                    :age 34
        )        )
   #< maths-teacher @ #x7dcc66> 

   [cl] (describe p2)
   #< maths-teacher @ #x7dcc66>  is an instance of
        class #< clos:standard-class maths-teacher @ #x7d94be> :
    The following slots have :INSTANCE allocation:
    age        34
    name       john
    subject    "Mathematics"

  (defclass a (b c) ...)

  (SEND instance operation-name arg*)

  (operation-name instance arg*)

   (DEFMETHOD generic-function-name specialized-lambda-list
     forms
   )

   (DEFUN function-name lambda-list form*)

  ((var1 class1) (var2 class2) ...)

   (defmethod change-subject ((teach teacher) new-subject)
     (setf (teacher-subject teach) new-subject)
   )

   (defmethod change-subject ((teach teacher) (new-subject string))
     (setf (teacher-subject teach) new-subject)
   )

   (defmethod test ((x number) (y number))
     '(num num)
   )

   (defmethod test ((i integer) (y number))
     '(int num)
   )

   (defmethod test ((x number) (j integer))
     '(num int)
   )

   (test 1 1)      =>  (int num), not (num int)
   (test 1 1/2)    =>  (int num)
   (test 1/2 1)    =>  (num int)
   (test 1/2 1/2)  =>  (num num)

   (defclass food () ())

   (defmethod cook :before ((f food))
     (print "A food is about to be cooked.")
   )

   (defmethod cook :after ((f food))
     (print "A food has been cooked.")
   )

   (defclass pie (food)
     ((filling :accessor pie-filling :initarg :filling :initform 'apple))
   )

   (defmethod cook ((p pie))
     (print "Cooking a pie")
     (setf (pie-filling p) (list 'cooked (pie-filling p)))
   )

   (defmethod cook :before ((p pie))
     (print "A pie is about to be cooked.")
   )

   (defmethod cook :after ((p pie))
     (print "A pie has been cooked.")
   )

   (setq pie-1 (make-instance 'pie :filling 'apple))

   [cl] (cook pie-1)
   "A pie is about to be cooked."
   "A food is about to be cooked."
   "Cooking a pie"
   "A food has been cooked."
   "A pie has been cooked."
   (cooked apple)