#lang racket

; 1. Kontrakt zależny sprawdzający poprawność procedury sqrt z wykładu
(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 sqrt/c
  (->i ([x positive?])
       [result positive?]
       #:post (x result)
       (< (dist x (square result)) 0.0001)))

(define/contract (sqrt x)
  sqrt/c
  (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))


; 2. Napisz kontrakty a)parametryczny oraz b)zależny dla procedury filter
(define filter/c
  (parametric->/c [a]
                  (-> (-> a boolean?) (listof a) (listof a))))

(define filter-complex/c
  (and/c
   filter/c
   (->i ([p? (-> any/c boolean?)]
         [xs (listof any/c)])
        [result (listof any/c)]
        #:post
        (p? result)
        (andmap p? result))))

(define/contract (filter p xs)
  filter-complex/c
  (if (empty? xs)
      '()
      (if (not (p (car xs)))
          (filter p (cdr xs))
          (cons (car xs) (filter p (cdr xs))))))

; 3. Napisz implementacje na liczbach całkowitych i listach interfejsu monoid
(define-signature monoid^
  ((contracted
    [elem? (-> any/c boolean?)]
    [neutral elem?]
    [oper (-> elem? elem? elem?)])))

(define-unit monoid-integer@
  (import)
  (export monoid^)

  (define (elem? e)
    (integer? e))

  (define neutral 0)

  (define (oper a b)
    (+ a b)))

(define-unit monoid-list@
  (import)
  (export monoid^)

  (define (elem? e)
    (list? e))

  (define neutral '())

  (define (oper a b)
    (append a b)))

; 5.

(define-signature integer-set^
  ((contracted
    [set? (-> any/c boolean?)]
    [set-member? (-> e set? boolean?)]
    [set-empty? (-> any/c boolean?)]
    [empty-set (and/c set? set-empty?)]
    [length (any/c number?)]
    [singleton (and/c set? (not/c set-empty?)
                      (->i (set any/c)
                           [result set]
                           #:post
                           (= (length set) 1)))]
    )))