topical media & game development
object-oriented programming
This chapter has treated polymorphism
from a foundational perspective.
In section 1,
we looked at abstract inheritance as
employed in knowledge representation.
1
- abstract inheritance -- declarative relation
- inheritance networks -- non-monotonic reasoning
- taxonomic structure -- predicate calculus
slide: Section 9.1: Abstract inheritance
We discussed the non-monotonic aspects
of inheritance networks
and looked at a first order logic
interpretation of taxonomic
structures.
2
- types -- sets of values
- the subtype relation -- refinement rules
- functions -- contravariance
- objects -- as records
slide: Section 9.2: The subtype relation
In section 2,
a characterization of types as sets of values
was given.
We looked at a formal definition of the
subtype relation and discussed
the refinement rules for functions and objects.
3
- typing -- protection against errors
- flavors -- parametric, inclusion, overloading, coercion
- inheritance -- incremental modification mechanism
slide: Section 9.3: Flavors of polymorphism
In section 3,
we discussed types as a means to prevent errors,
and distinguished between various flavors
of polymorphism,
including parametric polymorphism,
inclusion polymorphism, overloading and
coercion.
Inheritance was characterized as an incremental
modification mechanism, resulting in
inclusion polymorphism.
4
- subtypes -- typed lambda calculus
- overloading -- intersection types
- bounded polymorphism -- generics and inheritance
slide: Section 9.4: Type abstraction
In section 4,
some formal type calculi were presented,
based on the typed lambda calculus.
These included a calculus for simple subtyping,
a calculus for overloading,
employing intersection types,
and a calculus for bounded polymorphism,
employing type abstraction.
Examples were discussed illustrating the (lack of) features
of the C++ type system.
5
- hiding -- existential types
- packages -- abstract data types
slide: Section 9.5: Existential types
In section 5,
we looked at a calculus employing
existential types, modeling abstract
data types
and hiding by means of packages
and type abstraction.
6
- self-reference -- recursive types
- object semantics -- unrolling
- inheritance -- dynamic binding
- subtyping -- inconsistencies
slide: Section 9.6: Self-reference
Finally, in section 6, we discussed self-reference
and looked at a calculus employing recursive
types.
It was shown how object semantics may be determined
by unrolling, and we studied the semantic
interpretation of dynamic binding.
Concluding this chapter, an example was given
showing an inconsistency in the
Eiffel type system.
(C) Æliens
04/09/2009
You may not copy or print any of this material without explicit permission of the author or the publisher.
In case of other copyright issues, contact the author.