I was porting a C++ library to Scheme and this sort of verbosity was
getting outta hand. I wondered, is Scheme powerful enough to overcome
this challenge? After some experimentation, hackage, some help from a
macro jedi, and a bunch of syntax-case macros, Scheme pulled through, enough for my needs.

The result of the hacking was an extended form of
define-record-type. Let's do our point again:

(define-record-type++ point
(fields x y))

Define a variable p0 to a point value:

(define p0 (make-point 1 2))

Now the magic comes. Much like in C, we declare the variable to be
of "type" point:

(is-point p0)

And now we have concise accessors:

p0.x
p0.y

FAQ: Are those variables? If so, what happens when you change the
value of a field? Are the variables somehow updated?

Answer: No, those are not variables. They are identifier syntax macros (see this for more details). This is syntax:

p0.x

and it expands at compile time to this expression:

(point-x p0)

FAQ: Supposing that a field is mutable, is there nice syntax for updating the field?

Answer: Yes:

(p0.x! 10)

That syntax expands into:

(point-x-set! p0 10)

Any more questions? OK, let's continue.

What about getting at sub-components of the spaceship? We can declare
the fields to be of a certain type: