xdddd

#lang typed/racket
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~2~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(struct  vector2  ([x : Real] [y : Real]) #:transparent)
(struct  vector3  ([x : Real] [y : Real] [z : Real]) #:transparent)

(: vector-length (-> (U vector2 vector3) Real))
(define (vector-length vec)
  (cond [(vector2? vec)
         (sqrt (+ (sqr (vector2-x vec))
                  (sqr (vector2-y vec))))]
        [(vector3? vec)
         (sqrt  (+ (sqr (vector3-x vec))
                   (sqr (vector3-y vec))
                   (sqr (vector3-z vec))))]))

(: vector-length2 (-> (U vector2 vector3) Real))
(define (vector-length2 vec)
  (match vec
    [(vector2 x y)
         (sqrt (+ (sqr x)
                  (sqr y)))]
    [(vector3 x y z)
     (sqrt (+ (sqr x)
              (sqr y)
              (sqr z)))]))
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

(: prefixes (All (A) (-> (Listof A ) (Listof (Listof A)))))
 (define (prefixes xs)
   (if (null? xs)
       null
       (append (list (list (car xs)))
               (map (lambda ([x : (Listof A)]) (cons (car xs) x))
                    (prefixes (cdr xs))))))
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~4~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

(define-type Leaf 'leaf)
(define-type (Node a b) (List 'node a (Listof b)))
(define-type (Tree a) (U Leaf (Node a (Tree a))))

(define-predicate leaf? Leaf)
(define-predicate node? (Node Any Any))
(define-predicate tree? (Tree Any))

(: node-val (All (a b) (-> (Node a b) a)))
(define (node-val x)
  (second x))

(: node-list (All (a b) (-> (Node a b) (Listof b))))
(define (node-list x)
  (third x))

(: leaf Leaf)
(define leaf 'leaf)

(: rose-pre-order (-> (Tree Integer) (Listof Integer)))
(define (rose-pre-order t)
  (cond [(leaf? t) null]
        [else (cons (node-val t) (append-map (lambda (x) (rose-pre-order x)) (node-list t)))]))

(tree? (list 'node 1    (list (list 'node 3
                                    (list leaf
                                          leaf
                                          (list 'node 2 (list leaf))))
                              (list 'node 4 (list leaf)))))

(rose-pre-order (list 'node 1    (list (list 'node 3
                                    (list (list 'node 2 (list leaf))))
                              (list 'node 4 (list leaf)))))

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~4~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

(: map (All (a b) (-> (-> a b) (Listof a) (Listof b))))
(define (map f xs)
  (if (null? xs)
      null
      (cons (car xs) (cons (f (car xs))
            (map f (cdr xs))))))

(: map2 (All (a) (-> (-> a a) (Listof a) (Listof a))))
(define (map2 f xs)
  (if (null? xs)
      null
      (cons (car xs) (cons (f (car xs))
            (map2 f (cdr xs))))))

(map (lambda (x) x) '(1 2 3))
;;zmieniony typ ograncza np (map2 char->integer '(#\a #\b #\c))
--------------------------------------
(define/contract (map f xs)
(parametric->/c [a b] (-> (-> a b) (listof a) (listof b)))
  (if (null? xs)
      null
      (cons (car xs) (cons (f (car xs))
            (map f (cdr xs))))))

(define/contract (map2 f xs)
(parametric->/c [a] (-> (-> a a) (listof a) (listof a)))
  (if (null? xs)
      null
      (cons (car xs) (cons (f (car xs))
            (map2 f (cdr xs))))))

(define x (lambda (x) (* 2 x)))

;(map x '(1 2 3))
(map2 x '(1 2 3))
;;tu nie bo chyba poprostu a opakuje to wszystko
(map2 char->integer '(#\a #\b #\c))