[plt-scheme] when to use define-struct?

I'm learning define-struct from HtDP, to improve some "Lambda algebra"
code I wrote last year to cite in a Math paper.  

HtDP has nice examples of using define-struct to specify tree-like
data.  I liked 14.4 Extended Exercise: Evaluating Scheme.  Simple
Scheme expression are trees consisting of numbers & symbols connected
by + and * (both 2 children). The tree-connections are specified by:

(define-struct add (left right))
(define-struct mul (left right))

so (+ (* x x) (* y y)) is (make-add (make-mul 'x 'x) (make-mul 'y 'y))

My question (very specific below) is when should we use define-struct?
Any time we have a class of objects, say Widget, we can use
define-struct to specify lists of widgets, by 

(define-struct widgets (first rest))

Then we can define lists of widgets in this way

(define w (awidget lowidgets))

and then (widget-first w) and (widget-rest w) are the first & rest of
my list of widgets w.

So my general question is: is this considered to be useful?  Maybe
it's only useful if we have more complicated tree-like data.  HtDP
doesn't seem to pull out structures any times there's a listofWidget.

So here's my simple example that looks like lists of widgets.  I'm
working with a "tensor algebra over Z/2", and I have 1000 lines of
working but maybe-not-transparent DrScheme code.  I define

Monomial =lists of integers n >= 0

So (2 4 8) is a monomial.  The empty list is the "identity element."

I also define 
Polynomial = lists of monomials 

but actually, given any list of monomials, I replace it by the
polynomial given by quicksorting the list with left-lexicographical
order and then deleting repetitions.  (BTW Z/2 = deleting
repititions.)  The empty list is the important "zero element."

Then I have recursive functions : Polynomials ---> Polynomials.

I wrote the code where polynomials were lists of lists of integers.  I
tried to abstract the list-ness away with fancy names of functions:

(define (Poly+Poly X Y)
  ;; Returns the Lambda polynomial X + Y of two polynomials X & Y.
  (append X Y))

(define (Mono*Mono x y)
  ;; Returns the Lambda monomial x * y of two terms x & y.
  (append x y))

See, appending two lists of integers is multiplication, and appending
two lists of monomials is addition in the tensor algebra.  (BTW the
"lambda algebra" is a quotient of this tensor algebra.)

Anyway, I'm wondering if HtDP experts think there's any advantage to
using structures here to define Monomial & Polynomial.  I could say

(define-struct Mono (initial rest))
(define-struct Poly (first rest))

and then my definitions would become selectors:

(define (Mono-initial term)
  ;; Returns the initial  \i_1 of a nontrivial Lambda term \i_1 ... \i_n
  (first term))

(define (Mono-rest term) (rest term))

(define (Poly-first X) (first X))

(define (Poly-rest X) (rest X))

If this isn't the right list to post such a question to, I apologize,
and I can send it to the graveyard c.l.s.  But it seems to me that the
only folks who would be interested & experts are here.