1 i 3i 4

#lang racket
(require quickcheck)
(define-signature monoid^
  ((contracted
    [elem? (-> any/c boolean?)]
    [neutral elem?]
    [oper (-> elem? elem? elem?)])))

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

  (define (elem? x)
    (if (list? x)
        #t
        #f))

  (define neutral
    null)

  (define (oper xs ys)
    (append xs ys)))

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

  (define (elem? x)
    (if (integer? x)
        #t
        #f))

  (define neutral
    0)

  (define (oper x y)
    (+ x y)))

;(define-values/invoke-unit/infer monoid-lists@);
;(elem? (list 'a 'b))

(define lists-neutral-elem-left-right
  (property ([xs (arbitrary-list arbitrary-integer)])
            (equal? (oper xs neutral) (oper neutral xs))))

(define lists-assoc
  (property ([xs (arbitrary-list arbitrary-integer)]
             [ys (arbitrary-list arbitrary-integer)]
             [zs (arbitrary-list arbitrary-integer)])
            (equal? (oper xs (oper ys zs)) (oper (oper xs ys) zs))))

(define-values/invoke-unit/infer monoid-integers@);

(define integers-neutral-elem-left-right
  (property ([x arbitrary-integer])
            (equal? (oper x neutral) (oper neutral x))))

(define integers-assoc
  (property ([x arbitrary-integer]
             [y arbitrary-integer]
             [z arbitrary-integer])
            (equal? (oper x (oper y z)) (oper (oper x y) z))))


(quickcheck integers-assoc)
(quickcheck integers-neutral-elem-left-right)



(define/contract my-filter
  (parametric->/c [a] (-> procedure? (listof a) (listof a)))
                          filter)
(my-filter (lambda (x) (equal? x 1))
           '(1 2 3 4 5 6 1 2 3 1 2 3))

(define (close-enough-complex? x y)
  (< (magnitude (- x y)) 0.00001))

(define/contract (my-sqrt x)
  (->i ([n number?])
       [result (n) number?]
       #:post (n result)
       (close-enough-complex? (* result result) n))
  (sqrt x))

(define xddd
  (property ([x arbitrary-integer])
            (close-enough-complex? x (* (my-sqrt x)(my-sqrt x)))))

(quickcheck xddd)