(define a 1)
(define b a)
(set! a 9)
(eq? a b) ==> #f

You can have objects, that are either mutable or immutable, and you
can bind these objects to variables.  Arguments are passed by values,
that is the object that is bound to a variable is passed as argument,
but since these are objects, in general, it's a reference to the
object that is passed internally.  Of course, in the case of immutable
objects, the compilers can optimize it and copy the object itself, but
the semantics are the same, this is invisible to the user.  Well,
invisible unless you use eq? which is an implementation dependant
operator that allows you to see when such copying is done.  Note that:

(define a 1)
(define b a)
(eqv? a b) ==> #t
(eq?  a b) ==> #t or #f depending on the implementation.

See:
http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-9.html...

Note that when you call vector-set!, you are NOT modifying the binding
of b, but when you call set! you are modifying the binding of b.  So
you shouldn't be surprized that thereafter, eqv? or equal? return different
results. (You could be surprized if eq? returned same results).

Assume we define a functional vector-set:

(define (copy-vector v)
  (let loop ((r (make-vector (vector-length v)))
             (i 0))
     (if (>= i (vector-length v))
         r
         (begin (vector-set! r i (vector-ref v i))
                (loop r (+ 1 i))))))

(define (vector-set v i o)
  (let ((r (copy-vector v)))
     (vector-set! r i o)
     r))

Then we could get similar results, using similar operations:

You should also read: http://www.nhplace.com/kent/PS/EQUAL.html

Ok, but now if what you want to do is to really get aliasing behavior,
you can still implement this abstraction, but not using set!, you'll
have to use alias-set!.  What you need to do, is to store the values,
not as variable binding, but inside a mutable object.  For this, you
can use a vector, a cons cell, a structure, etc.

For example, with conses:

(define (make-alias value)   (cons 'alias value))
(define (alias-get alias)    (cdr alias))
(define (alias-set! alias v) (set-cdr! alias v))

Pascal

Note that you should also consider as immutable any quoted or literal
object.

(let ((mutable-v   (vector 1 2 3))
      (immutable-v #(1 2 3))
      (mutable-l   (list 1 2 3))
      (immutable-l '(1 2 3))
      (mutable-s   (make-string 3 #\a))
      (immutable-s "aaa"))
  (etc))

See "Storage Model":
http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-6.html...

--
__Pascal Bourguignon__                     http://www.informatimago.com/

See
http://www.htdp.org/2003-09-26/Book/curriculum-Z-H-1.html#node_toc_no...