#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)

(define (add-mons m1 m2)
  (list (+ (get-coef m1) (get-coef m2))
        (get-exp m1)))

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

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

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

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

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

(define (ascii-art-inner w h chars img [acc '()]))

(define (ascii-art w h chars)
  (lambda (img)
    (ascii-art-inner w h chars img)))

(add-pol '((1 0) (1 1)) '((-1 0) (1 1) (3 2)))
(mult-pol '((1 0) (1 1)) '((-1 0) (1 1) (3 2)))