For Gauche 0.9.15Search (procedure/syntax/module):

Next: , Previous: , Up: Object system   [Contents][Index]

7.1 Introduction to the object system

This section briefly explains the basic structure of Gauche’s object system. It is strongly influenced by CLOS (Common-Lisp Object System). If you have experience in CLOS or related systems such as TinyCLOS, STklos or Guile’s object system, you may skip to the next section.

Three concepts play the central role in CLOS-like object systems: A class, a generic function, and a method.

A class specifies a structure of object. It also defines a datatype (strictly speaking, it’s not the same thing as a datatype, but let’s skip the complicated part for now).

For example, a point in 2D space can be represented by x and y coordinates. A point class can be defined using define-class macro. In the shortest form, it can be defined like this:

(define-class <2d-point> () (x y))

(You can find the code of definitions in the examples of this section in examples/oointro.scm of Gauche’s source distribution.)

The symbol <2d-point> is the name of the class, and also the global variable <2d-point> is bound to a class object. Surrounding a class name by < and > is just a convention; you can pass any symbol to define-class.

The second argument of define-class is a list of direct superclasses, which specifies inheritance of the class. We’ll come back to it later.

The third argument of define-class is a list of slots. A slot is a storage space, usually in each object, where you can store a value. It is something similar to what is called a field or an instance variable in other object-oriented languages; but slots can be configured more than just a per-object storage space.

Now we defined a 2D point class, so we can create an instance of a point. You can pass a class to a generic function make to create an instance. (Don’t worry about what generic function is—think it as a special type of function, just for now).

(define a-point (make <2d-point>))

a-point  ⇒ #<<2d-point> 0x8117570>

If you are using gosh interactively, you can use a generic function describe to inspect the internal of an instance. A short alias, d, is defined to describe for the convenience. (See gauche.interactive - Utilities for interactive session for the details).

gosh> (d a-point)
#<<2d-point> 0x8117570> is an instance of class <2d-point>
  x         : #<unbound>
  y         : #<unbound>

In order to access or modify the value of the slot, you can use slot-ref and slot-set!, respectively. These names are taken from STklos.

(slot-ref a-point 'x)  ;; access to the slot x of a-point
  ⇒ error, since slot ’x doesn’t have a value yet

(slot-set! a-point 'x 10.0)  ;; set 10.0 to the slot x of a-point

(slot-ref a-point 'x)
  ⇒ 10.0

Gauche also provides a shorter name, ref, which can also be used in SRFI-17’s generalized set! syntax:

(ref a-point 'x) ⇒ 10.0

(set! (ref a-point 'y) 20.0)

(ref a-point 'y) ⇒ 20.0

Now you can see slot values are set.

gosh> (d a-point)
#<<2d-point> 0x8117570> is an instance of class <2d-point>
  x         : 10.0
  y         : 20.0

In practice, it is usually convenient if you can specify the default value for a slot, or give values for slots when you create an instance. Such information can be specified by slot options. Let’s modify the definition of <2d-point> like this:

(define-class <2d-point> ()
  ((x :init-value 0.0 :init-keyword :x :accessor x-of)
   (y :init-value 0.0 :init-keyword :y :accessor y-of)))

Note that each slot specification is now a list, instead of just a symbol as in the previous example. The list’s car now specifies the slot name, and its cdr gives various information. The value after :init-value defines the default value of the slot. The keyword after :init-keyword defines the keyword argument which can be passed to make to initialize the slot at creation time. The name after keyword :accessor is bound to a generic function that can be used to access/modify the slot, instead of using slot-ref/slot-set!.

Let’s see some interactive session. You create an instance of the new <2d-point> class, and you can see the slots are initialized by the default values.

gosh> (define a-point (make <2d-point>))
gosh> (d a-point)
#<<2d-point> 0x8148680> is an instance of class <2d-point>
  x         : 0.0
  y         : 0.0

You create another instance, this time giving initialization values by keyword arguments.

gosh> (define b-point (make <2d-point> :x 50.0 :y -10.0))
gosh> (d b-point)
#<<2d-point> 0x8155b80> is an instance of class <2d-point>
  x         : 50.0
  y         : -10.0

Accessors are less verbose than slot-ref/slot-set!, thus convenient.

gosh> (x-of a-point)
gosh> (x-of b-point)
gosh> (set! (y-of a-point) 3.33)
gosh> (y-of a-point)

The full list of available slot options is described in Defining class. At a first glance, the declarations of such slot options may look verbose. The system might have provide a static way to define init-keywords or accessor names automatically; however, CLOS-like systems prefer flexibility. Using a mechanism called metaobject protocol, you can customize how these slot options are interpreted, and you can add your own slot options as well. See Metaobject protocol, for details.

We can also have <2d-vector> class in similar fashion.

(define-class <2d-vector> ()
  ((x :init-value 0.0 :init-keyword :x :accessor x-of)
   (y :init-value 0.0 :init-keyword :y :accessor y-of)))

Yes, we can use the same accessor name like x-of, and it is effectively overloaded.

If you are familiar with mainstream object-oriented languages, you may wonder where methods are. Here they are. The following form defines a method move-by! of three arguments, pt, dx, dy, where pt is an instance of <2d-point>.

(define-method move-by! ((pt <2d-point>) dx dy)
  (inc! (x-of pt) dx)
  (inc! (y-of pt) dy))

The second argument of define-method macro specifies a method specializer list. It indicates the first argument must be an instance of <2d-point>, and the second and third can be any type. The syntax to call a method is just like the one to call an ordinary function.

gosh> (move-by! b-point 1.4 2.5)
gosh> (d b-point)
#<<2d-point> 0x8155b80> is an instance of class <2d-point>
  x         : 51.4
  y         : -7.5

You can overload the method by different specializers; here you can move a point using a vector.

(define-method move-by! ((pt <2d-point>) (delta <2d-vector>))
  (move-by! pt (x-of delta) (y-of delta)))

Specialization isn’t limited to a user-defined classes. You can also specialize a method using Gauche’s built-in type.

(define-method move-by! ((pt <2d-point>) (c <complex>))
  (move-by! pt (real-part c) (imag-part c)))

And here’s the example session:

gosh> (define d-vector (make <2d-vector> :x -9.0 :y 7.25))
gosh> (move-by! b-point d-vector)
gosh> (d b-point)
#<<2d-point> 0x8155b80> is an instance of class <2d-point>
  x         : 42.4
  y         : -0.25
gosh> (move-by! b-point 3+2i)
gosh> (d b-point)
#<<2d-point> 0x8155b80> is an instance of class <2d-point>
  x         : 45.4
  y         : -2.25

You see that a method is dispatched not only by its primary receiver (<2d-point>), but also other arguments. In fact, the first argument is no more special than the rest. In CLOS-like system a method does not belong to a particular class.

So what is actually a method? Inspecting move-by! reveals that it is an instance of <generic>, a generic function. (Note that describe truncates the printed value in methods slot for the sake of readability).

gosh> move-by!
#<generic move-by! (3)>
gosh> (d move-by!)
#<generic move-by! (3)> is an instance of class <generic>
  name      : move-by!
  methods   : (#<method (move-by! <2d-point> <complex>)> #<method (move-
gosh> (ref move-by! 'methods)
(#<method (move-by! <2d-point> <complex>)>
 #<method (move-by! <2d-point> <2d-vector>)>
 #<method (move-by! <2d-point> <top> <top>)>)

I said a generic function is a special type of function. It is recognized by Gauche as an applicable object, but when applied, it selects appropriate method(s) according to its arguments and calls the selected method(s).

What the define-method macro actually does is (1) to create a generic function of the given name if it does not exist yet, (2) to create a method object with the given specializers and the body, and (3) to add the method object to the generic function.

The accessors are also generic functions, created implicitly by the define-class macro.

gosh> (d x-of)
#<generic x-of (2)> is an instance of class <generic>
  name      : x-of
  methods   : (#<method (x-of <2d-vector>)> #<method (x-of <2d-point>)>)

In the mainstream dynamic object-oriented languages, a class has many roles; it defines a structure and a type, creates a namespace for its slots and methods, and is responsible for method dispatch. In Gauche, namespace is managed by modules, and method dispatch is handled by generic functions.

The default printed representation of object is not very user-friendly. Gauche’s write and display function call a generic function write-object when they encounter an instance they don’t know how to print. You can define its method specialized to your class to customize how the instance is printed.

(define-method write-object ((pt <2d-point>) port)
  (format port "[[~a, ~a]]" (x-of pt) (y-of pt)))

(define-method write-object ((vec <2d-vector>) port)
  (format port "<<~a, ~a>>" (x-of vec) (y-of vec)))

And what you’ll get is:

gosh> a-point
[[0.0, 3.33]]
gosh> d-vector
<<-9.0, 7.25>>

If you customize the printed representation to conform SRFI-10 format, and define a corresponding read-time constructor, you can make your instances to be written-out and read-back just like built-in objects. See Read-time constructor for the details.

Several built-in functions have similar way to extend their functionality for user-defined objects. For example, if you specialize a generic function object-equal?, you can compare the instances by equal?:

(define-method object-equal? ((a <2d-point>) (b <2d-point>))
  (and (equal? (x-of a) (x-of b))
       (equal? (y-of a) (y-of b))))

(equal? (make <2d-point> :x 1 :y 2) (make <2d-point> :x 1 :y 2))
  ⇒ #t

(equal? (make <2d-point> :x 1 :y 2) (make <2d-point> :x 2 :y 1))
  ⇒ #f

(equal? (make <2d-point> :x 1 :y 2) 'a)
  ⇒ #f

(equal? (list (make <2d-point> :x 1 :y 2)
              (make <2d-point> :x 3 :y 4))
        (list (make <2d-point> :x 1 :y 2)
              (make <2d-point> :x 3 :y 4)))
  ⇒ #t

Let’s proceed to more interesting examples. Think of a class <shape>, which is an entity that can be drawn. As a base class, it keeps common attributes such as a color and line thickness in its slots.

(define-class <shape> ()
  ((color     :init-value '(0 0 0) :init-keyword :color)
   (thickness :init-value 2 init-keyword :thickness)))

When an instance is created, make calls a generic function initialize, which takes care of initializing slots such as processing init-keywords and init-values. You can customize the initialization behavior by specializing the initialize method. The initialize method is called with two arguments, one is a newly created instance, and another is a list of arguments passed to make.

We define a initialize method for <shape> class, so that the created shape will be automatically recorded in a global list. Note that we don’t want to replace system’s initialize behavior completely, since we still need the init-keywords to be handled.

(define *shapes* '())  ;; global shape list

(define-method initialize ((self <shape>) initargs)
  (next-method)  ;; let the system to handle slot initialization
  (push! *shapes* self)) ;; record myself to the global list

The trick is a special method, next-method. It can only be used inside a method body, and calls less specific method of the same generic function—typically, it means you call the same method of superclass. Most object-oriented languages have the concept of calling superclass’s method. Because of multiple-argument dispatching and multiple inheritance, next-method is a little bit more complicated, but the basic idea is the same.

So, what’s the superclass of <shape>? In fact, all Scheme-defined class inherits a class called <object>. And it is <object>’s initialize method which takes care of slot initialization. After calling next-method within your initialize method, you can assume all the slots are properly initialized. So it is generally the first thing in your initialize method to call next-method.

Let’s inspect the above code. When you call (make <shape> args …), the system allocates memory for an instance of <shape>, and calls initialize generic function with the instance and args …. It is dispatched to the initialize method you just defined. In it, you call next-method, which in turn calls <object> class’s initialize method. It initializes the instance with init-values and init-keywords. After it returns, you register the new <shape> instance to the global shape list *shapes*.

The <shape> class represents just an abstract concept of shape. Now we define some concrete drawable shapes, by subclassing the <shape> class.

(define-class <point-shape> (<shape>)
  ((point  :init-form (make <2d-point>) :init-keyword :point)))

(define-class <polyline-shape> (<shape>)
  ((points :init-value '() :init-keyword :points)
   (closed :init-value #f  :init-keyword :closed)))

Note the second argument passed to define-class. It indicates that <point-shape> and <polyline-shape> inherit slots of <shape> class, and also instances of those subclasses can be accepted wherever an instance of <shape> class is accepted.

The <point-shape> adds one slot, point, which contains an instance of <2d-point> defined in the beginning of this section. The <polyline-shape> class stores a list of points, and a flag, which specifies whether the end point of the polyline is connected to its starting point or not.

Inheritance is a powerful mechanism that should be used with care, or it easily result a code which is untractable ("Object-oriented programming offers a sustainable way to write spaghetti code.", as Paul Graham says in his article "The Hundred-Year Language"). The rule of thumb is to make a subclass when you need a subtype. The inheritance of slots is just something that comes with, but it shouldn’t be the main reason to do subclassing. You can always "include" the substructure, as is done in <point-shape> class.

There appeared a new slot option in <point-shape> class. The :init-form slot option specifies the default value of the slot when init-keyword is not given to make method. However, unlike :init-value, with which the value is evaluated at the time the class is defined, the value with :init-form is evaluated when the system actually needs the value. So, in the <point-shape> instance, the default <2d-point> instance is only created if the <point-shape> instance is created without having :point init-keyword argument.

A shape may be drawn in different formats for different devices. For now, we just consider a PostScript output. To make the draw method polymorphic, we define a postscript output device class, <ps-device>.

(define-class <ps-device> () ())

Then we can write a draw method, specialized for both <shape> and <ps-device>.

(define-method draw ((self <shape>) (device <ps-device>))
  (format #t "gsave\n")
  (draw-path self device)
  (apply format #t "~a ~a ~a setrgbcolor\n" (ref self 'color))
  (format #t "~a setlinewidth\n" (ref self 'thickness))
  (format #t "stroke\n")
  (format #t "grestore\n"))

In this code, the device argument isn’t used within the method body. It is just used for method dispatching. If we eventually have different output devices, we can add a draw method that is specialized for such devices.

The above draw method does the common work, but actual drawing must be done in specialized way for each subclasses.

(define-method draw-path ((self <point-shape>) (device <ps-device>))
  (apply format #t "newpath ~a ~a 1 0 360 arc closepath\n"
         (point->list (ref self 'point))))

(define-method draw-path ((self <polyline-shape>) (device <ps-device>))
  (let ((pts (ref self 'points)))
    (when (>= (length pts) 2)
      (format #t "newpath\n")
      (apply format #t "~a ~a moveto\n" (point->list (car pts)))
      (for-each (lambda (pt)
                  (apply format #t "~a ~a lineto\n" (point->list pt)))
                (cdr pts))
      (when (ref self 'closed)
        (apply format #t "~a ~a lineto\n" (point->list (car pts))))
      (format #t "closepath\n"))))

;; utility method
(define-method point->list ((pt <2d-point>))
  (list (x-of pt) (y-of pt)))

Finally, we do a little hack. Let draw method work on the list of shapes, so that we can draw multiple shapes within a page in batch.

(define-method draw ((shapes <list>) (device <ps-device>))
  (format #t "%%\n")
  (for-each (cut draw <> device) shapes)
  (format #t "showpage\n"))

Then we can write some simple figures ….

(use math.const)  ;; for constant pi

(define (shape-sample)

  ;; creates 5 corner points of pentagon
  (define (make-corners scale)
    (map (lambda (i)
           (let ((pt (make <2d-point>)))
             (move-by! pt (make-polar scale (* i 2/5 pi)))
             (move-by! pt 200 200)
         (iota 5)))

  (set! *shapes* '())  ;; clear the shape list
  (let* ((corners (make-corners 100)))
    ;; a pentagon in green
    (make <polyline-shape>
      :color '(0 1 0) :closed #t
      :points corners)
    ;; a star-shape in red
    (make <polyline-shape>
      :color '(1 0 0) :closed #t
      :points (list (list-ref corners 0)
                    (list-ref corners 2)
                    (list-ref corners 4)
                    (list-ref corners 1)
                    (list-ref corners 3)))
    ;; put dots in each corner of the star
    (for-each (cut make <point-shape> :point <>)
              (make-corners 90))
    ;; draw the shapes
    (draw *shapes* (make <ps-device>)))

The function shape-sample writes out a PostScript code of simple drawing to the current output port. You can write it out to file by the following expression, and then view the result by PostScript viewer such as GhostScript.

(with-output-to-file "" shape-sample)

Next: , Previous: , Up: Object system   [Contents][Index]

For Gauche 0.9.15Search (procedure/syntax/module):