[gambit-list] Figuring out opaque:, and macros expanding to macros

Marc Feeley feeley at iro.umontreal.ca
Thu May 1 00:02:50 EDT 2014


On Apr 21, 2014, at 6:38 AM, Álvaro Castro-Castilla <alvaro.castro.castilla at gmail.com> wrote:

> Hi,
> 
> Although this may seem a very obvious question, none of the obvious answers are true. I think many Gambit users would benefit of really knowing how to use this, since there is barely any code that you can use as reference, no documentation and no google results:
> 
> https://github.com/search?l=Scheme&q=opaque%3A&ref=advsearch&type=Code
> https://www.google.es/search?q=gambit+opaque&oq=gambit+opa&aqs=chrome.0.69i59j69i57j69i60j0j69i64.1665j0j1&sourceid=chrome&es_sm=91&ie=UTF-8
> 
> False hypothesis I could come up with:
> 
> * Opaque types make their fields not accessible to extending types so you can't access them using the parent type's procedures
> * Opaque types make the fields unprintable by default
> * Opaque types have R6RS semantics: [The opaque? flag must be a boolean. If true, the record type is opaque. If passed an instance of the record type, record? returns #f. Moreover, if record-rtd (see “Inspection” below) is called with an instance of the record type, an exception with condition type &assertion is raised. The record type is also opaque if an opaque parent is supplied. If opaque? is #f and an opaque parent is not supplied, the record is not opaque.] This doesn't hold true either for Gambit's types and you don't have such inspection procedures.
> * Opaque makes the predicates yield #f for instances of the type always
> * Opaque makes the predicates of the parent types yield #f for inherited types' instance
> * Opaque disables the generation of a type exhibitor
> * Opaque generates different code somehow. At least, I can't see a single difference.
> * Opaque types can't be serialized and deserialized with object->u8vector
> 
> Is there any other obvious possibility that I'm missing out?
> 
> Thank you

The opaque: flag causes a change in the behavior of equal? and equal?-hash .  When the opaque: flag is not used, two structures are equal? if they have the same type and each field is equal? in both structures.  When the opaque: flag is used, two structures are equal? only if they are eq? (i.e. the same instance).

Here’s an example:

(define-type foo
  opaque:
  a
  b
)

(define x (make-foo 11 22))
(define y (make-foo 11 22))

(pp x)
(pp y)

(pp (equal? x y))

(pp (equal?-hash x))
(pp (equal?-hash y))

;; prints:
;; #<foo #2 a: 11 b: 22>
;; #<foo #3 a: 11 b: 22>
;; #f
;; 2
;; 3

;; without the opaque: flag prints:
;; #<foo #2 a: 11 b: 22>
;; #<foo #3 a: 11 b: 22>
;; #t
;; 206628681
;; 206628681

Marc




More information about the Gambit-list mailing list