#lang racket

;; kartkówka


(define/contract (sum args)
  (-> (listof number?) number?)
  (if (null? args)
      0
      (apply + args)))


;; ćw. 1

(define/contract (suffixes xs)
  (let ((a (new-∀/c 'a)))
    (-> (listof a) (listof (listof a))))
  (if (null? xs)
      (list '())
      (cons xs (suffixes (cdr xs)))))

;; ćw. 2

(define/contract (dist x y)
  (-> number? number? number?)
  (abs (- x y)))

(define/contract (average x y)
  (-> number? number? number?)
  (/ (+ x y) 2))

(define/contract (square x)
  (-> number? number?)
  (* x x))

(define/contract (sqrt x)
  ;(->i ([x positive?])
       ;[result positive?]
       ;#:post (result x)
       ;(< (abs (- x (square result))) 0.0001))
  (->i ([x positive?])
       [result (x) (and/c positive?
                          (λ (y) (< (dist (square y) x) 0.001)))])

  (define (improve approx)
    (average (/ x approx) approx))
  (define (good-enough? approx)
    (< (dist x (square approx)) 0.0001))
  (define (iter approx)
    (cond
      [(good-enough? approx) approx]
      [else                  (iter (improve approx))]))

  (iter 1.0))

;; ćw. 3

(define/contract (filter p? xs)
  (let ((a (new-∀/c 'a)))
    (and/c
     (-> (-> a boolean?) (listof a) (listof a))
     (->i ([p? (-> any/c boolean?)]
           [xs (listof any/c)])
          [result (listof any/c)]
          #:post (p? result)
          (andmap p? result))))
  (cond [(null? xs) null]
        [(p? (car xs)) (cons (car xs) (filter p? (cdr xs)))]
        [else (filter p? (cdr xs))]))

;; ćw. 4

(define-signature  monoid^
  (( contracted
     [elem?    (-> any/c  boolean ?)]
     [neutral  elem?]
     [oper     (-> elem? elem? elem?)])))

;; ćw. 5

;; ćw. 6

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