define, quote, ', if, =, +, -, *, /, null?, car, cdr, c…r, cons

(define (faktorial n) 
  (if (= n 0) 
      1 
      (* n (faktorial (- n 1)))))

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

(define (sude ls)
  (if (null? (cdr ls))
      '()
      (if (null? (cddr ls))
          (cdr ls)
          (cons (cadr ls) (sude (cddr ls))))))

append, cond, lambda, let, let*, letrec

(define (maximum1 ls)
  (if (null? (cdr ls)) (car ls)
      (if (> (car ls) (cadr ls))
          (maximum1 (cons (car ls) (cddr ls)))
          (maximum1 (cdr ls))
          )))

(define (maximum2 ls)
  (if (null? (cdr ls)) (car ls)
      (if (> (car ls) (maximum2 (cdr ls)))
          (car ls)
          (maximum2 (cdr ls))
          )))

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

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

(define (split ls)
  (cond ((null? ls) '(().()))
        ((null? (cdr ls)) (cons ls '()))
        (else (let* (
                     (a (car ls))
                     (b (cadr ls))
                     (r (split (cddr ls)))
                     (pa (car r))
                     (pb (cdr r))
                     )
                (cons (cons a pa) (cons b pb))
                ))))
 
(define (merge comparator as bs)
  (cond 
    ((null? as) bs)
    ((null? bs) as)
    ((comparator (car as) (car bs))
     (cons (car as) (merge comparator (cdr as) bs))
     )
    (else (merge comparator bs as))
    ))
 
(define (merge-sort comparator ls)
  (cond
    ((null? ls) ls)
    ((null? (cdr ls)) ls)
    (else (let* (
                 (ss (split ls))
                 (a  (car ss))
                 (b  (cdr ss))
                 (sa (merge-sort comparator a))
                 (sb (merge-sort comparator b))
                 )
            (merge comparator sa sb)
            ))))

> (merge-sort (lambda (x y) (<= x y)) '(9 7 8 1 3 5 4 -2))
(-2 1 3 4 5 7 8 9)
 
> (merge-sort <= '(9 7 8 1 3 5 4 -2))
(-2 1 3 4 5 7 8 9)

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

(define moje-pi 3.14)
 
> moje-pi
3.14

; implementace funkce (+) s proměnlivým počtem argumentů s ladícím výstupem:
(define plus
  (lambda ls
    (define (sum ss)
      (if (null? ss) 0
          (begin (display ls) (newline) (+ (car ss) (sum (cdr ss))))))
    (sum ls)))
 
; alternativní implementace funkce (+) s proměnlivým počtem argumentů s ladícím výstupem:
(define (plus1 . ls)
  (define (sum ss)
    (if (null? ss) 0
        (begin (display ls) (newline) (+ (car ss) (sum (cdr ss))))))
  (sum ls))

;využití vestavěné funkce (eval) s (interaction-environment) (= všechny vazby jsou k dispozici):
> (eval '(+ 1 1) (null-environment 5))
2
 
;pokus o využití vestavěné funkce (eval) s (null-environment 5) (= prázdný seznamem vazeb):
> (eval '(+ 1 1) (null-environment 5))
. . +: undefined;
 cannot reference undefined identifier
 
;využití vestavěné funkce (eval) s (null-environment 5): 
> ((eval '(lambda (+) (+ 1 1)) (null-environment 5)) +)
2

; implementace vestavěné funkce (apply):
(define (moje-apply fun . args)
  (define (collect args)
    (if (null? (cdr args)) (car args)
        (cons (car args) (collect (cdr args))))
    )
  (eval (cons fun (collect args)) (null-environment 5))
  )
 
> (moje-apply +  1 2 3 '(10 20))
36

(define (muj-list . args) args)

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)

(define (nasob ls)
  (if (null? ls) 1
      (* (car ls) (nasob (cdr ls)))))
 
(define (rychle-nasob ls) ; nasobí stejně jako v předchozím případě
  (cond                   
    ((null? ls) 1)
    ((= (car ls) 0) 0)    ; pokud ale narazí na 0 vrátí ihned mezivýsledek 0
    (else (* (car ls) (rychle-nasob (cdr ls)))))
  )
 
(define (super-rychle-nasob ls) ; nasobí stejně jako v předchozím případě
  (define (nasob ls exit)       
    (cond 
      ((null? ls) 1)
      ((= (car ls) 0) (exit 0)) ; pokud ale narazí na 0 vrátí ihned celkový výsledek 0  
      (else (* (car ls) (nasob (cdr ls) exit))))
    )
 
  (call-with-current-continuation 
   (lambda (return) (nasob ls return))
   )
  )

(define (make-cyclic-list! ls)
  (define (zacykli! xs)
    (if (null? (cdr xs))
        (set-cdr! xs ls)
        (zacykli! (cdr xs))
        ))
  (zacykli! ls)
  )
 
> (define week (list 'su 'mo 'tu 'we 'th 'fr 'sa))
 
> week
(su mo tu we th fr sa)
 
>(make-cyclic-list! week)
 
> week
#0=(su mo tu we th fr sa . #0#)
 
> (set! week (cdr week))
 
> week
#0=(mo tu we th fr sa su . #0#)

(define stack '()) ; na začátku je datová struktura zásobníku prázdná
 
(define (top) (car stack)) ;vrací vrchol zásobníku
 
(define (push e) ; vloží prvek e na vrchol zásobníku 
  (set! stack (cons e stack)))
 
(define (pop) ; odebere vrchol ze zásobníku a vrátí tento vrchol jako výsledek
  (let (
        (vysledek (top))
        )
 
    (set! stack (cdr stack)) 
    vysledek
    )
  )  

quasiquote (`), unquote (,), unquote-splicing(,@), delay, force, reprezentace seznamů jako stream, implementace ekvivalentů k funkcím: cons, car a cdr pouze s lambda

(define (derivace expr x)
  (define (d e)
    (cond
      ((number? e) 0)
      ((equal? e x) 1)
      ((symbol? e) 0)
      ((equal? (car e) 'sin) `(* ,(d (cadr e)) (cos ,(cadr e))))
      ((equal? (car e) 'cos) `(* ,(d (cadr e)) (- (sin ,(cadr e)))))
      ((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 `(* ,@(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))
         ))
 
      ))
  (d expr)
  )

(define (cisla_od od)
  (cons od (delay (cisla_od (+ 1 od))))
  )

(define (lcons x s)
  (lambda (f) (f x s)))
 
(define (lcar s)
  (s (lambda (x y) x)))
 
(define (lcdr s)
  (s (lambda (x y) y)))