#lang racket

(define (mult-all-pairs l1 l2)
  (apply append
         (map
          (lambda (el1)
            (map
             (curry * el1)
             l2))
          l1)))

(define (f-all-pairs f l1 l2)
  (apply append
         (map
          (lambda (el1)
            (map
             (curry f el1)
             l2))
          l1)))

(define get-coef car)
(define get-exp cadr)

; Adds monomes with the same exponent
(define (add-mons m1 m2)
  (list (+ (get-coef m1) (get-coef m2))
        (get-exp m1)))

(define (add-mon-pol m p)
  (let* [(m-exp (get-exp m))
         (same-exp? (lambda (mp) (= (get-exp mp) m-exp)))
         (same-exps (filter same-exp? p))
         (diff-exps (filter (compose not same-exp?) p))]
    (if (null? same-exps)
        (cons m p)
        (cons (add-mons m (car same-exps)) diff-exps))))

(define (normalize p)
  (sort (filter (compose not zero? get-coef) p)
        ; (lambda (m) (not (zero? (get-coef m))))
        <
        #:key get-exp))

(define (add-pol p1 p2)
  (normalize (foldl add-mon-pol p1 p2)))

(define (mult-mon m1 m2)
  (list (* (get-coef m1) (get-coef m2))
        (+ (get-exp m1) (get-exp m2))))

(define (mult-pol p1 p2)
  (add-pol '() (f-all-pairs mult-mon p1 p2)))

(define p1 '((1 0) (1 1)))
(define p2 '((-1 0) (1 1) (3 2)))

(add-pol p1 p2)
(mult-pol p1 p2)