====== Scheme přednáška 1 ======
define, quote, ', if, =, +, -, *, /, null?, car, cdr, cons
<code scheme>
(define (faktorial n)
  (if (= n 0) 1 (* n (faktorial (- n 1))))
  )

(define (posledni ls)
  (if (null? (cdr ls))
      (car ls)
      (posledni (cdr ls))
      ))

(define (negace? b)
  (if b #f #t)
  )

(define (lichy? ls)
  (if (null? ls) #f
      (if (null? (cdr ls))
          #t
          (negace? (lichy? (cdr ls)))
          )))

</code>

====== Scheme přednáška 2 ======
append, cond, lambda, let, let*, letrec

<code scheme>
;(define (maximum ls)
(define maximum
  (lambda (ls)
    (if (null? (cdr ls))
        (car ls)
        (if (> (car ls) (maximum (cdr ls)))
            (car ls)
            (maximum (cdr ls))
            )
        )
    )
  )

(define maximum2
  (lambda (ls)
    (if (null? (cdr ls))
        (car ls)
        (let ( (m (maximum2 (cdr ls)))
               )
          (if (> (car ls) m)
              (car ls)
              m
              )
          )
        )
    )
  )

(define maximum3
  (lambda (ls)
    (if (null? (cdr ls))
        (car ls)
        ((lambda (m)
           (if (> (car ls) m)
               (car ls)
               m
               )
           ) (maximum3 (cdr ls)))
        )
    )
  )
</code>

<code scheme>
(define (split ls)
  (cond
    ((null? ls) (cons '() '()))
    ((null? (cdr ls)) (cons ls '()))
    (else
     (let* ((a (car ls))
            (b (cadr ls))
            (rs (cddr ls))
            (p (split rs))
            )
       (cons (cons a (car p)) (cons b (cdr p)))
       ))))

(define (slij as bs)
  (cond
    ((null? as) bs)
    ((null? bs) as)
    ((<= (car as) (car bs))
     (cons (car as) (slij (cdr as) bs)))
    (else (slij bs as))
    )
  )
     
(define (merge-sort ls)
  (cond
    ((null? ls) ls)
    ((null? (cdr ls)) ls)
    (else
     (let* ( (p (split ls))
             (as (car p))
             (bs (cdr p))
             (sas (merge-sort as))
             (sbs (merge-sort bs))
             )  
       (slij sas sbs)
       )
     )))            
</code>

====== Scheme přednáška 3 ======
použití define pro definici uživatelských hodnot, vnořený define, lambda s proměnlivým počtem argumentů, list, eval, (interaction-environment), (scheme-report-environment 5), (null-environment 5), apply, display, newline, begin

<code scheme>
(define soucet
  (lambda ls
    (define (sum ls)
      (if (null? ls) 0
          (+ (car ls) (sum (cdr ls)))
          ))
    (sum ls)
    ))
  
(define (soucet1 . ls)
  (define (sum ls)
    (if (null? ls) 0
        (+ (car ls) (sum (cdr ls)))
        ))
  (sum ls)
  )

(define (soucet2 . ls) (apply + ls))
</code>

<code scheme>
(define (my-list . ls) ls)
</code>

<code scheme>
(define (my-apply f . ls)
  (define (argumenty ls)
    (if (null? (cdr ls)) (car ls)
        (cons (car ls) (argumenty (cdr ls)))))
  (eval (cons f (argumenty ls)) (interaction-environment))
  )
</code>


====== Scheme přednáška 4 ======
map, call-with-current-continuation, vector, vector?, list?, list→vector, vector→list, make-vector, vector-ref, vector-set!, set!, set-car!, set-cdr!, cyklické datové struktury, jazykem scheme garantovaná optimalizace koncového volání (tail call optimization)

<code scheme>
(define (make-cyclic-list! ls)
  (define (cyc! xs)
    (if (null? (cdr xs))
        (set-cdr! xs ls)
        (cyc! (cdr xs))
        ))
  (cyc! ls))
</code>


====== Scheme přednáška 5 ======
quasiquote (`), unquote (,), unquote-splicing(,@), delay, force, reprezentace seznamů jako stream, implementace ekvivalentů k funkcím: cons, car a cdr pouze s lambda

<code scheme>
(define (derivuj expr x)
  (define (d e)
    (cond
      ((number? e) 0)
      ((equal? e x) 1)
      ((symbol? e) 0)
      ((equal? (car e) '+) `(+ ,@(map d (cdr e))))
      ((equal? (car e) '-) `(- ,@(map d (cdr e))))
      ((equal? (car e) '*)
       (if (null? (cddr e)) (d (cadr e))
           (let* (
                  (f (cadr e))
                  (g (cons '* (cddr e)))
                  (df (d f))
                  (dg (d g))
                  )
             `(+ (* ,df ,g) (* ,f ,dg))
             )))
      ((equal? (car e) '/)
       (let* (
              (f (cadr e))
              (g (caddr e))
              (df (d f))
              (dg (d g))
              )
         `(/ (- (* ,df ,g) (* ,f ,dg)) (* ,g ,g))
         ))
      ((equal? (car e) 'sin) `(* (cos ,(cadr e)) ,(d (cadr e))))
      ((equal? (car e) 'cos) `(* (- (sin ,(cadr e))) ,(d (cadr e))))
      ))

  (d expr)
  )

</code>

<code scheme>
(define (my-cons e mls)
  (lambda (f) (f e mls))
  )
(define (my-car mls)
  (mls (lambda (x y) x))
  )
(define (my-cdr mls)
  (mls (lambda (x y) y))
  )
</code>