Still learning :)

In other languages, you can easily change the values contained in an object.
So far as I can tell, the convention in Scheme is to define constants using
the DEFINE keyword and local variables using SET.

My question is most likely entirely silly but ... nothing ventured ... and
as always, please feel free to correct my thoughts.

(define a-list (list 3 0)); create a constant of type list.
(define (some-proc a-list) ; values in object a-list passed to procedure
  (if (= 0 (first a-list))
   (+ 1 (first a-list))
   (+ 2 (second a-list)))
)
(some-proc a-list) ; ===> the value 2

In the above, a-list values remain unchanged.  Even though I used a-list in
the procedure, I'm not really 'touching' it because it is not a-list that is
directly passed but the values contained in a-list.  The result produced by
some-proc are assigned to the object some-proc.

So far as I can tell, I cannot alter any value in a-list itself within a
procedure however I can redefine it after the procedure like this: (define
a-list (list 3 2)).  But seems an inappropriate thing to do to a constant
(assuming this is the way Scheme creates constants) and generally poor
coding technique.  The reason I am assuming that (define foo 1) is how
Scheme creates constants is that this: (define foo a-list) will create a
'constant' containing the procedure a-list (if written below the code
above).

foo ;==> returns (3 #<procedure:some-proc>).

Not exactly a 'constant' in the strict sense of a non-changing value
(constant) but one containing a procedure whose address is constant (again,
an assumption) but might hold different values depending upon how the
procedure resolves.

Suppose a-list contained two values representing dollars and cents, and a
process resolves to a new list with different values.  If I wanted to
reflect those changes in a-list, I can't see any way to do it (excluding
using SET!).  As I said earlier, if a-list is the Scheme equivalent of a
constant I don't think it is good technique to do this but I was wondering
if it were possible to do.  So, how do you change the values in a-list
(above example) without using SET! and is using SET! a 'good' thing or a
work-around the restriction of the defined constant?

Be interested in your thoughts.

Kindest regards,

Not really.  There is no such thing as a constant; you use "define"
for any kind of object.  You use set! to make an existing variable
contain a new value.

    Mike> (define a-list (list 3 0)); create a constant of type list.
No; it merely defines a list.  It's not constant.
    Mike> (define (some-proc a-list) ; values in object a-list passed to procedure
    Mike>   (if (= 0 (first a-list))
    Mike>    (+ 1 (first a-list))
    Mike>    (+ 2 (second a-list)))
    Mike> )
    Mike> (some-proc a-list) ; ===> the value 2

    Mike> In the above, a-list values remain unchanged.  

Correct.

    Mike> So far as I can tell, I cannot alter any value in a-list
    Mike> itself within a procedure

You've overlooked set-car! and set-cdr!, which do exactly what you want.

    > (define a-list (list 3 0))
    > a-list
    (3 0)
    > (define (some-other-proc a-list)
        (set-car! a-list 'three)
        (set-car! (cdr a-list) 'zee-row ))
    > a-list
    (3 0)
    > (some-other-proc a-list)
    > a-list
    (three zee-row)
    >