;;(define (app-flat t)
;;  (define (iter tt xs)
;;      (if (eq? `leaf tt)
;;           xs
;;           (iter (third tt) (cons (second tt) (iter (fourth tt) xs)))))
;;  (iter t null))

#lang racket

;; struktury z których budujemy drzewa binarne

(struct node (v l r) #:transparent)
(struct leaf () #:transparent)

;; predykat: czy dana wartość jest drzewem binarnym?

(define (tree? t)
  (match t
    [(leaf) true]
    ; wzorzec _ dopasowuje się do każdej wartości
    [(node _ l r) (and (tree? l) (tree? r))]
    ; inaczej niż w (cond ...), jeśli żaden wzorzec się nie dopasował, match kończy się błędem
    [_ false]))

;; przykładowe użycie dopasowania wzroca

(define (insert-bst v t)
  (match t
    [(leaf) (node v (leaf) (leaf))]
    [(node 0 l r) (error "zero w drzewie")]
    [(node w l r)
     (if (< v w)
         (node w (insert-bst v l) r)
         (node w l (insert-bst v r)))]))

(define (paths t)
  (define (add v xs)
    (if (null? xs)
        xs
        (cons (cons v (car xs)) (add v (cdr xs)))))
  (define (rek t)
    (match t
      [(leaf) (list `*)]
      [(node v l r) (add v (append (rek l) (rek r)))]))
  (rek t))

(paths (node 3 (node 2 (leaf)(node 6 (node 7 (leaf) (leaf))(leaf)))(node 7 (leaf) (leaf))))

;; definicja wyrażeń z let-wyrażeniami

(struct const    (val)      #:transparent)
(struct op       (symb l r) #:transparent)
(struct let-expr (x e1 e2)  #:transparent)
(struct variable (x)        #:transparent)

(define (expr? e)
  (match e
    [(variable s)       (symbol? s)]
    [(const n)          (number? n)]
    [(op s l r)         (and (member s '(+ *))
                             (expr? l)
                             (expr? r))]
    [(let-expr x e1 e2) (and (symbol? x)
                             (expr? e1)
                             (expr? e2))]
    [_                  false]))

;; podstawienie wartości (= wyniku ewaluacji wyrażenia) jako stałej w wyrażeniu

(define (subst x v e)
  (match e
    [(op s l r)   (op s (subst x v l)
                        (subst x v r))]
    [(const n)    (const n)]
    [(variable y) (if (eq? x y)
                      (const v)
                      (variable y))]
    [(let-expr y e1 e2)
     (if (eq? x y)
         (let-expr y
                   (subst x v e1)
                   e2)
         (let-expr y
                   (subst x v e1)
                   (subst x v e2)))]))

;; (gorliwa) ewaluacja wyrażenia w modelu podstawieniowym

(define (eval e)
  (match e
    [(const n)    n]
    [(op '+ l r)  (+ (eval l) (eval r))]
    [(op '* l r)  (* (eval l) (eval r))]
    [(let-expr x e1 e2)
     (eval (subst x (eval e1) e2))]
    [(variable n) (error n "cannot reference an identifier before its definition ;)")]))

;; przykładowe programy

;;(define p1
;;  (let-expr 'x (op '+ (const 2) (const 2))
;;     (op '+ (const 1000) (let-expr 'y (op '+ (const 5) (const 5))
;;                            (op '* (variable 'x) (variable 'y))))))
;;
;;(define p2
;;  (let-expr 'x (op '+ (const 2) (const 2))
;;     (op '+ (const 1000) (let-expr 'x (op '+ (const 5) (const 5))
;;                            (op '* (variable 'x) (variable 'x))))))
;;
;;(define p3
;;  (let-expr 'x (op '+ (const 2) (const 2))
;;     (op '+ (const 1000) (let-expr 'y (op '+ (const 5) (const 5))
;;                            (op '* (variable 'x) (variable 'z))))))
;;
;;(define p4
;;     (let-expr 'y (op '+ (const 5) (const 5))
;;                            (op '* (const '2) (variable 'y))))


(define (eval-sign e)
  (match e
    [(const n)    0]
    [(op '+ l r)  (+ 1 (eval-sign l) (eval-sign r))]
    [(op '* l r)  (- (+ (eval-sign l) (eval-sign r)) 1)]
    [(let-expr x e1 e2)
     (eval-sign (subst x (eval e1) e2))]
    [(variable n) (error n "cannot reference an identifier before its definition ;)")]))


;;(eval-sign p1)
;;(eval-sign p2)
;;(eval-sign p4)
;;(eval p3)

(struct text (title auth chaps))
(struct chapt (title lst))

(define (list-of? xs p?)
  (define (iter xs)
    (if (null? xs)
        #t
        (if (p? (car xs))
            (iter (cdr xs))
            #f)))
  (if (< 0 (length xs))
      (iter xs)
      #f))

(define (chap? c)
  (match c
    [(chapt t l)
      (and
        (string? t)
        (list-of? l (lambda x (or (string? (car x))
                                  (chap? x)))))]
    [_                                  false]))


(define (doc? d)
  (match d
    [(text t a c)
      (and
          (string? t)
          (string? a)
          (chap?   c))]
    [_                   false]))

(doc? (text "tytul" "autor" (chapt "tytul2" (list "akap1" "akap2"))))

(define a "xd")

(define (beg x)
  (printf (~a "<" x ">")))

(define (end x)
  (printf (~a "<" x "/>")))





;;(beg `html)
;;(end `html)

(`1 `. `2)