[racket-dev] When are values chaperones of another?

From: Eric Dobson (eric.n.dobson at gmail.com)
Date: Thu Jul 12 01:08:33 EDT 2012

The docs on when a value is a chaperone of another are confusing and
don't seem to match the implementation.

They seem to say that (and (not (chaperone? a)) (not (chaperone? b))
(equal? a b)) implies (chaperone-of? a b) but this does not seem to
They also change behavior if I switch from a transparent structure to
a structure where I explicitly implement equality.

 #lang racket
 (struct foo (v)
   #:property prop:equal+hash
       (lambda (l r equal?)
         (equal? l r))
       (lambda (v hash)
         (hash v))
       (lambda (v hash)
         (hash v))))
 (struct foo (v) #:transparent)

 (define foo1 (foo (box 0)))
 (define foo2 (foo (box 0)))
 (define foo3 (foo (foo-v foo1)))

 "1 2"
 (equal? foo1 foo2)
 (chaperone-of? foo1 foo2)
 (chaperone-of? foo2 foo1)

 "1 3"
 (equal? foo1 foo3)
 (chaperone-of? foo1 foo3)
 (chaperone-of? foo3 foo1)


"1 2"
"1 3"

I expect these to all return true but only the equals do. If I switch
to transparent equality then 1 and 3 are equal.

The goal in this is to have my own struct type (free identifier
tables) be able to support chaperone-of? like immutable hashes do:

(chaperone-of? (hash 'a 'b) (hash 'a 'b)) ;; => #t

These are different hashes but are chaperones of each other. The
importance of this is chaperone contracts on free identifier tables
need to make a copy like hash/c does on immutable hashes.

Posted on the dev mailing list.