principles of programming languages, 2 - intranet deibhome.deib.polimi.it/pradella/pl/02-oo.pdf ·...

Principles of Programming Languages, 2

Matteo Pradella

February 2015

Matteo Pradella Principles of Programming Languages, 2 February 2015 1 / 23

1 Object Oriented Programming (OO)

Matteo Pradella Principles of Programming Languages, 2 February 2015 2 / 23

What is Object Oriented programming?

1 First of all, I assume you already know the main concepts from Java2 OO means different things to different people3 According to Alan Kay, who introduced the term:

1 OOP to me means only messaging, local retention and protection and hidingof state-process, and extreme late-binding of all things. It can be done inSmalltalk and in Lisp. There are possibly other systems in which this ispossible, but I’m not aware of them.

2 Actually I made up the term "object-oriented", and I can tell you I did nothave C++ in mind.

4 On the other hand, Stroustrup based C++’s OO model on Simula, notSmalltalk. Interesting comparison with Objective-C.

Matteo Pradella Principles of Programming Languages, 2 February 2015 2 / 23

Closures as objects (1)

1 basic idea: use "closed" values for encapsulation of values and methods + asimple dispatcher for messages:

(define (make-simple-object)(let (( my-var 0))

(define (init)(set! my-var 0)my-var)

(define (my-add x)(set! my-var (+ my-var x))my-var)

(define (get-my-var)my-var)

Matteo Pradella Principles of Programming Languages, 2 February 2015 3 / 23

Closures as objects (2)

(define (my-display)(newline)(display "my Var is:")(display my-var)(newline ))

(lambda (message . args) ; dispatcher(apply (case message

((init) init)(( my-add) my-add)(( my-display) my-display)(( get-my-var) get-my-var)(else (error "Unknown Method!")))

args ))))

Matteo Pradella Principles of Programming Languages, 2 February 2015 4 / 23

Closures as objects (3)

1 make-simple-object returns a closure which contains the dispatcher2 Example usage:

(define a (make-simple-object ))(define b (make-simple-object ))(a ’init) ; => 0(b ’init) ; => 0(a ’my-add 3) ; => 3(a ’my-add 4) ; => 7(a ’get-my-var) ; => 7(b ’get-my-var) ; => 0(a ’my-display) ; => My Var is: 7

Matteo Pradella Principles of Programming Languages, 2 February 2015 5 / 23

Inheritance by delegation (1)

(define (make-son)(let (( parent (make-simple-object ))

(name "an object"))(define (init)

(parent ’init))(define (hello)

"hi!")(define (my-display)

(display "My name is ")(display name)(display " and")(parent ’my-display ))

Matteo Pradella Principles of Programming Languages, 2 February 2015 6 / 23

Inheritance by delegation (2)

(lambda (message . args)(case message

((init) (apply init args)); overriding:(( my-display) (apply my-display args))((hello) (apply hello args))(else (apply parent (cons message args )))))))

Matteo Pradella Principles of Programming Languages, 2 February 2015 7 / 23

Inheritance by delegation (3)

1 Example usage:

(define c (make-son ))(c ’init)(c ’my-display) ; => My name is an object and

; my Var is:0(display (c ’hello )) ; => hi!

Matteo Pradella Principles of Programming Languages, 2 February 2015 8 / 23

A prototype-based object system

1 Self (1987), a variant of Smalltalk, is the programming language thatintroduced prototype-based object orientation

2 There are no classes: new objects are obtained by cloning and modifyingexisting objects

3 Its OO model inspired the one of JavaScript4 We will see here how to implement it on top of Scheme, using hash tables

as the main data structure

Matteo Pradella Principles of Programming Languages, 2 February 2015 9 / 23

Proto-oo

1 An object is implemented with an hash table

(define new-object make-hash)

(define (clone object)(hash-copy object ))

2 keys are attribute/method names

Matteo Pradella Principles of Programming Languages, 2 February 2015 10 / 23

Proto-oo: syntactic sugar

1 just for convenience:

(define-syntax !! ;; setter(syntax-rules ()

((_ object msg new-val)(hash-set! object ’msg new-val ))))

(define-syntax ?? ;; reader(syntax-rules ()

((_ object msg)(hash-ref object ’msg ))))

(define-syntax -> ;; send message(syntax-rules ()

((_ object msg arg ...)(( hash-ref object ’msg) object arg ...))))

Matteo Pradella Principles of Programming Languages, 2 February 2015 11 / 23

An example

1 First, we define an object and its methods

(define Pino (new-object ))(!! Pino name "Pino") ;; slot added(!! Pino hello

(lambda (self x) ;; method added(display (?? self name))(display ": hi, ")(display (?? x name))(display "!")(newline )))

Matteo Pradella Principles of Programming Languages, 2 February 2015 12 / 23

An example (cont.)

1 a couple of other methods:

(!! Pino set-name(lambda (self x)

(!! self name x)))(!! Pino set-name- &-age

(lambda (self n a)(!! self name n)(!! self age a)))

2 and a clone:

(define Pina (clone Pino))(!! Pina name "Pina")

Matteo Pradella Principles of Programming Languages, 2 February 2015 13 / 23

Using the example

(-> Pino hello Pina) ; Pino: hi , Pina!(-> Pino set-name "Ugo")(-> Pina set-name- &-age

"Lucia" 25)(-> Pino hello Pina) ; Ugo: hi , Lucia!

Matteo Pradella Principles of Programming Languages, 2 February 2015 14 / 23

Proto-oo: inheritance

1 Inheritance is not typical of prototype object systems2 Still, it is used in JavaScript to provide a "more standard" way of reusing

code3 Again, inheritance by delegation:

(define (son-of parent)(let ((o (new-object )))

(!! o <<parent >> parent)o))

Matteo Pradella Principles of Programming Languages, 2 February 2015 15 / 23

Proto-oo: dispatching

1 basic dispatching:

(define (dispatch object msg)(if (eq? object ’unknown)

(error "Unknown message" msg)(let ((slot (hash-ref

object msg ’unknown )))(if (eq? slot ’unknown)

(dispatch (hash-ref object’<<parent >>’unknown) msg)

slot ))))

Matteo Pradella Principles of Programming Languages, 2 February 2015 16 / 23

Proto-oo: dispatching (cont.)

1 we now have to modify ?? and -> for dispatching

(define-syntax ?? ;; reader(syntax-rules ()

((_ object msg)(dispatch object ’msg ))))

(define-syntax -> ;; send message(syntax-rules ()

((_ object msg arg ...)(( dispatch object ’msg) object arg ...))))

Matteo Pradella Principles of Programming Languages, 2 February 2015 17 / 23

And the example:

(define Glenn (son-of Pino))(!! Glenn name "Glenn")(!! Glenn age 50)

(-> Glenn hello Pina) ; Glenn: hi, Lucia!(-> Glenn ciao) ; error: Unknown message

Matteo Pradella Principles of Programming Languages, 2 February 2015 18 / 23

About inheritance: single or multiple?

1 Different languages have different approaches (Java vs C++ vs Python vsRuby . . . )

2 many recent languages prefer it single (e.g. Java, Ruby)3 workarounds for its shortcomings: interfaces (like in Java), mixins

Matteo Pradella Principles of Programming Languages, 2 February 2015 19 / 23

Proto-oo: mixins

1 mixins are containers of data/methods which can be combined to addbehavior to objects

2 We may introduce mixins in proto-oo as follows:

(define (extend target mixin)(hash-for-each mixin ; loop on table "mixin"(lambda (key val)

(hash-set! target key val ))))

Matteo Pradella Principles of Programming Languages, 2 February 2015 20 / 23

Example:

(define Pianist (new-object )) ; a mixin(!! Pianist piano "Steinway CD318")(!! Pianist play (lambda (self)

;; assumes a name:(display (?? self name))(display " is playing his ")(display (?? self piano))(newline )))

;; using the Pianist mixin:(extend Glenn Pianist)(-> Glenn play);; Glenn is playing his Steinway CD318

Matteo Pradella Principles of Programming Languages, 2 February 2015 21 / 23

Concluding remarks: Object Systems for Lisps

1 There is a long tradition of object systems for Lisp and Scheme2 Common Lisp contains a standard, flexible and very sophisticated object

system (called CLOS), that provides e.g. generic functions (for multipledispatch), and method combination

3 There is an implementation for Scheme, written by Gregor Kiczales, andcalled Tiny CLOS (there are also many variants)

4 These concepts are forerunners of Aspect-Oriented Programming (AOP)5 For the interested: Gregor Kiczales, Jim Des Rivieres, Daniel G. Bobrow: The

Art of the Metaobject Protocol, MIT Press, 1991

Matteo Pradella Principles of Programming Languages, 2 February 2015 22 / 23

Legal stuff

1 ©2012-2015 by Matteo Pradella2 Licensed under Creative Commons License, Attribution-ShareAlike 3.0

Unported (CC BY-SA 3.0)

Matteo Pradella Principles of Programming Languages, 2 February 2015 23 / 23